The Swift Programming Language ゆるふわ和訳　その１ ~About Swift~・~Swift Tour~


OSX/iOS開発のための新言語SwiftについてAppleが提供しているドキュメントを、要点だけおさえてふわっと和訳しました。

原文: Apple Inc. “The Swift Programming Language”。 iBooks. https://itun.es/jp/jEUH0.l

# Swiftについて

- SwiftはCとObjective-CでビルドされたiOSとOSX用の新しいプログラミング言語
- Swiftはモダンな機能を備え、プログラミングをもっと簡単に、柔軟に、もっと楽しくします
- Objective-Cの名前付きパラメータや動的オブジェクトモデルを採用してるので、Objective-C開発者にやさしい
- スクリプト言語のように柔軟な表現ができるので初心者にもやさしい。「playground」を使えば実行結果が即座に反映されて見ることができる

# Swiftツアー

- まずは恒例の"Hello World"。Swiftではこの一行だけです

```
println("Hello, world")
```
- ライブラリのimportは必要ない
- main文とかもいらない
- 文末にセミコロンも必要ない

>XcodeのPlaygroundsを使えば編集した内容が即座に見えてオススメです

## 値
### 宣言
- 定数宣言は **let**
- 変数宣言は **var**

```
var myVariable = 42
myVariable = 50
let myConstant = 42
```
###型推論
- 型はコンパイラーが予測して判定してくれます

```
let implicitInteger = 70
let implicitDouble = 70.0
let explicitDouble: Double = 70
```

- 変数名の後に型名をつければ型を指定できます

```
let label = "The width is "
let width = 94
let widthLabel = label + String(width)
```

- 一度、型推論された後は型は自動で変換されないので、明示的に型を指定して変換する必要があります

- 文字列の中に変数を入れたいときは、変数を括弧で囲んで前にバックスラッシュをつけると楽です

```
let apples = 3
let oranges = 5
let appleSummary = "I have \(apples) apples."
let fruitSummary = "I have \(apples + oranges) pieces of fruit."
```

###配列・ディクショナリ
- 配列やディクショナリを作るには[]を使います。要素にアクセスするときは[]の中にインデックスを指定します

```
var shoppingList = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"
 
var occupations = [
    "Malcolm": "Captain",
    "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations
```
- 空の配列やディクショナリを作るときは、初期シンタックスがいります

```
let emptyArray = String[]()
let emptyDictionary = Dictionary<String, Float>()
```
- 型が定義済みの場合には、配列なら[]、ディクショナリなら[:]で代入できます

```
shoppingList = []   // Went shopping and bought everything.
```

## 制御句

- 条件分はifとswitch
- ループはfor-in, for, while,do-while
- 条件分やループの変数に()はつけなくてもいい
- 条件分やループの本体の{}は必須

```
let individualScores = [75, 43, 103, 87, 12]
var teamScore = 0
for score in individualScores {
    if score > 50 {
        teamScore += 3
    } else {
        teamScore += 1
    }
}
teamScore
```

###if 
- if文の条件式はBooleanでなければならない。 つまり、if score { ... }のような0であるかみたいのはエラーになる

- ifとletを使うことで値があるかの判定が行えます。そのときの判定する値の型には、型の後ろに?をつけます

```
var optionalString: String? = "Hello"
optionalString == nil
 
var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}
```
- 条件式がnilになれば結果はfalseになり、{}の中は実行されない。結果がtrueであればletで定義した値はブロック内で使用できます

### switch
- switch文での条件の変数はinteger以外も使用できます

```
let vegetable = "red pepper"
switch vegetable {
case "celery":
    let vegetableComment = "Add some raisins and make ants on a log."
case "cucumber", "watercress":
    let vegetableComment = "That would make a good tea sandwich."
case let x where x.hasSuffix("pepper"):
    let vegetableComment = "Is it a spicy \(x)?"
default:
    let vegetableComment = "Everything tastes good in soup."
}
```
- switchの条件がcaseの値と一致すれば、caseブロックの処理が行われてswitch文から抜けます。後ろのcase文には行かないのでbreakは不要です

### for-in
- for-inでは２つの変数を指定されれば、ディクショナリーをkey-valueの値でループできます

```
let interestingNumbers = [
    "Prime": [2, 3, 5, 7, 11, 13],
    "Fibonacci": [1, 1, 2, 3, 5, 8],
    "Square": [1, 4, 9, 16, 25],
]
var largest = 0
for (kind, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
largest
```

### while
- whileは、条件をぬけるまでブロック内の処理を繰り返します

- do-whileでwhileを後ろにつければ、ブロック内の処理は必ず一度は行われます

```
var n = 2
while n < 100 {
    n = n * 2
}
n
 
var m = 2
do {
    m = m * 2
} while m < 100
m
```

- ..を使ってループの範囲を指定することもできます。下の二つは同じ結果になります。
- ..は上限の値まで含みませんが、...は上限の値を含みます

```
var firstForLoop = 0
for i in 0..3 {
    firstForLoop += i
}
firstForLoop

var secondForLoop = 0
for var i = 0; i < 3; ++i {
    secondForLoop += 1
}
secondForLoop
```

## 関数とクロージャ

###関数
- 関数の宣言はfunc
- funcの後ろに関数名と括弧の中に引数。その後ろに->と戻りの型を書く

```
func greet(name: String, day: String) -> String {
    return "Hello \(name), today is \(day)."
}
greet("Bob", "Tuesday")
```

- タプルを使って複数の戻り値を設定できます

```
func getGasPrices() -> (Double, Double, Double) {
    return (3.59, 3.69, 3.79)
}
getGasPrices()
```

- 引数を可変長にすることもできます

```
func sumOf(numbers: Int...) -> Int {
    var sum = 0
    for number in numbers {
        sum += number
    }
    return sum
}
sumOf()
sumOf(42, 597, 12)
```


###ネスト

- 関数はネストできます。
- ネストした関数内では外で宣言された変数名が使用できます。
- コードが長くなったり複雑になる場合はネストした関数を使いましょう
 
```
func returnFifteen() -> Int {
    var y = 10
    func add() {
        y += 5
    }
    add()
    return y
}
returnFifteen()
```

- 関数はファーストクラスとして扱われます。つまり、関数を値のように戻り値にできます

```
func makeIncrementer() -> (Int -> Int) {
    func addOne(number: Int) -> Int {
        return 1 + number
    }
    return addOne
}
var increment = makeIncrementer()
increment(7)
```
- 関数の引数に他の関数を使うこともできます

```
func hasAnyMatches(list: Int[], condition: Int -> Bool) -> Bool {
    for item in list {
        if condition(item) {
            return true
        }
    }
    return false
}
func lessThanTen(number: Int) -> Bool {
    return number < 10
}
var numbers = [20, 19, 7, 12]
hasAnyMatches(numbers, lessThanTen)
```

###クロージャ
- 関数は実際はクロージャの一つです
- クロージャは関数名を書かずに全体を{}で囲むことで書くことができます。引数、戻り値と処理の間にinを使います

```
numbers.map({
    (number: Int) -> Int in
    let result = 3 * number
    return result
    })
```

- クロージャーはさまざまな書き方がありさらに簡潔にすることができます
- コールバックのデリゲートのように形式が既知であれば、引数や戻り値を省略できます
- クロージャのコードが１行の場合はその処理の結果が戻り値になります

```
numbers.map({ number in 3 * number })
```

- 引数を引数名ではなく番号から使用することもできます。
- 関数の一番最後の引数として渡されたクロージャは括弧の後ろに置くことができます

```
sort([1, 5, 3, 12, 2]) { $0 > $1 }
```

[その２](http://qiita.com/kiita312/items/2f4284eefef8f5a6c94b)へ続く