Swiftに関するメモ


* [
Swiftに関するメモ - 一覧](http://qiita.com/takkyun/items/f34abf857deed808c610)

https://developer.apple.com/swift/ より

まだコード書いていません。

とりあえず[The Swift Programming Language (iBooks Store)](https://itunes.apple.com/us/book/the-swift-programming-language/id881256329?mt=11)をざっくり目を通してつらつらと。

こちらに[続き](http://qiita.com/takkyun@github/items/384013e52f404773893b)があります。

# 定数と変数

定数は `let` で、変数は `var` で。`:` で型指定できる。


# 配列とディクショナリ（連想配列）

配列 : `[value0,value1,value2]`
ディクショナリ : `[key1:value1,key2:value2]`

`let`で宣言すれば immutable で、`var`で宣言すれば mutable 。


## 配列
`in` でイテレーション。

配列の要素の型を指定する時は型に`[]`をつける。例えば、`String[]`。

(2014.07.08 追記) beta 3 より `[String]` と括弧で囲む書式に変更されました (上記書式も引き続きサポートされています)。

## ディクショナリ
`in`でイテレーション。キーとバリューを双方取る。

```swift
for (key, value) in dictionary {
}
```

キーだけ回したい時は`keys`を使う

```swift
for key in dictionary.keys {
}
```

バリューだけ回したい時は`values`を使う

```swift
for values in dictionary.values {
}
```

ディクショナリで型を指定する場合は`<>`を使う。例えば、`Dictionary<Int, String>`


# 制御文
## for-in ループ

`for` 〜 `in` で要素をイテレーションできる。

```swift
for value in array {
}
```

`開始...終了`で範囲イテレーション。この場合、終了の値を含む。

```swift
for value in 1...5 {
  // value は 1 から 5
}
```

`開始..終了`とした場合、終了の値を含まない。

```swift
for value in 0..5 {
  // value は 0 から 4
}
```


## for ループ

初期値と条件と変化値を指定するいわゆる`for`ループ

```swift
for 初期; 条件; 変化 {
  実行
}
```

こんな感じ

```swift
for var i=0; i<n; ++i {
}
```

## while ループ

```swift
初期
while 条件 {
  実行
  変化
}
```

```swift
初期
do {
  実行
} while 条件
```

## if

まぁ、普通に`if`文です。

```swift
if 条件1 {
  
} else if 条件2 {
  
} else {
  
}

```

## switch

`switch` には列挙子や整数以外、文字や範囲指定なんかも行えます。

```swift
switch count {
case 0:
  naturalCount = "no"
case 1...3:
  naturalCount = "a few"
```

```swift
switch anotherCharacter {
case "a":
case "A":
  println("The letter A")
default:
  println("Not the letter A")
}
```

## break と continue

ループ文・`switch`文には`break`と`continue`が使えます。

面白いのは`fallthrough`というのが明示できること。というか、`break`がデフォルトの動作。`fallthrough`を明示しない限り、次の`case`や`default`は実行されません。

```swift
switch integer {
case 2,4,6,8:
  description += "偶数で、"
  fallthrough // 次の case もしくは default も実行
default:
  description += "整数です。"
}
```

`switch`文で次の`case`もそのまま実行する場合、C言語などでは`break`を置かないことで実現できて、意図的にそのようにする場合は慣例的にコメントしたりしていたと思います。

# 関数 (Functions)
## func

基本形：

```swift
func functionName(parameter: #ParameterType) -> #ReturnType {
  return #ReturnValue
}
```

Objective-C風：

```swift
func doSomething(withValue value1: #ValueType andValue value2: #ValueType) -> #ReturnType {
  return #ReturnValue
}

doSomething(withValue:x andValue:y);
```

引数宣言に `= 初期値`をつけると、引数のデフォルト値を指定できる。

引数に`...`を使うと取る引数を可変長にできる (Variadic Paramater って言うんですね)。

```swift
func arithmeticMean(numbers: Double...) -> Double {
  var total: Double = 0
  for number in numbers {
      total += number
  }
  return total / Double(numbers.count)
}
arithmeticMean(1, 2, 3, 4, 5) // 1 + 2 + 3 + 4 + 5
```

引数に`inout`を指定すると、その引数に対して変数を参照渡しすることができる。

```swift
func check(inout a: Int inout b: Int) {
  a = ..... // a の値を変える
  b = ..... // b の値を変える
}
```

`inout`を指定した引数に対しては、呼び出し元で`&`を付けて参照渡しのような形にする。

```swift
check(&a,&b)
```

## クロージャ

基本形:

```swift
{ (引数) -> 戻り型 in
  実行
}
```

例えば

```swift
{ (s1: Int, s2: Int) -> Bool in
  return s1 > s2
}
```


Objective-C の Block よりもわかりやすいかな？

ただ、括弧や型や`return`を省略した書き方もあるようで、

```swift
{ s1, s2 in s1 > s2 }
```

は先のクロージャと同一の内容になるようです (先のクロージャと違って Double で動作するかもしれませんが)。

さらにさらに引数すら省略する書き方もあり、この場合は `$0`、`$1`、`$2`のように `$` + 数字が引数として利用できます。

```swift
{ $0 > $1 }
```

は先のクロージャと同一の内容です。

## 関数を返す関数

`func` には戻り値の型を指定することができます。

`->` の後が戻り値になるので、それが `() -> Bool` という形で記述すると関数を返すことを明示することになります。

この `() -> Bool` は返す関数によって変わります。`Int` を取って `Int` を返す関数だと `Int -> Int`という記述になるようです。

```swift
func getToggler() -> () -> Bool {
  var value = true
  func toggler() -> Bool {
    value = !value
    return value
  }
  return toggler // <= 関数を返している
}
```

返す関数の実体はクロージャの様子。参照されている変数などはスコープに応じてキャプチャされる模様。

# 構造体 (Structures)
## 列挙型 enum

Swiftの`enum`はC言語のように整数で列挙するというものではないようです。

基本は列挙なんですが、アクセスする際に `.` をつける必要があったり、型を指定したりすることができる感じ。

C言語の`enum`というより、`struct`に近い感じ。特殊な`struct`？

## class と struct

Swiftには`class`と`struct`があります。C++みたい。

* 変数を格納するプロパティを定義できる
* メソッドを定義できる
* 添字(subscripts)アクセス `[]` を定義できる
* イニシャライザを定義できる
* デフォルトの実装を拡張できる
* プロトコルに適応した`class`/`structure`を定義できる

は共通ですが、

* 継承を指定できるのは`class`だけ
* インスタンスに対してタイプキャストができるのは`class`だけ
* デイニシャライザが利用できるのは`class`だけ
* リファレンスカウンタがひとつ以上のリファレンスに有効なのは`class`だけ
* `struct`(と`enum`)は常に値で渡される(Value Type)、`class`は常に参照で渡される(Reference Type)


.... とりあえず、ざっくり。後日、追加するか、別途記事を書くかもしれません。

[その2](http://qiita.com/takkyun@github/items/384013e52f404773893b)に続きます。