The Swift Programming Language - The Basics をまとめる


[The Swift Programming Language をまとめるトップ](http://qiita.com/kiyotaman/items/052f82e9f93590b79c64)

## The Basics
変数(vairable)と定数(constant)がある
**var** と **let** をつかって宣言できる
**tuple** も追加。tuple によって、異なる型の値を一つにまとめて function 戻り値に設定することができる

もう一つ大きな特徴があって、 **optional types** 不在値？（the absence of a value）というのがあって、nil pointer と似ている
オプションを使うと、"valueが存在して、かつ、 *x* と同等" or "valueが存在しない" を評価できる
クラスだけでなくて、全型に対して使える
nil より安全に使える。Optionals のセクションで後述してある

この **optinals** は、 **type safe** 言語として代表的な例とのこと

### Constants と Variables（定数と変数）
* 定数：一度しか定義できない
* 変数：後に別の値を代入することができる

#### Declearing Contants と Variables (定数と変数の宣言）

* **let** を使って定数を宣言する

```swift
// myAppName という名前の新しい定数を宣言して、"SnapDish" という値を代入
// myAppName は変わらない値
let myAppName = "SnapDish"
```

**var** を使って変数を宣言する

```swift
// counter という名前の新しい変数を宣言して、0 という値を代入
// counter なので値を増やす事ができる
var counter = 0

// ,（カンマ区切りで）一度に定義することもできる
var x = 0.0, y = 0.0, z = 0.0

```

>  **NOTE**
> 代入する値に変更が無い場合は、常に **let** を使って constant（定数）として宣言する
> 値が変わる場合は、 **var** を使う
> **let** で宣言した定数を変更しようとしたら、コンパイル時にエラーになる

### Type Annotations（注釈を入れる）
Annotation（注釈、型説明とでも言うのか）を定数と変数に指定することができる
どんな型の値が代入されるのか明確に分かるようにできる

```swift
// 今宣言した変数 myMessage は String（文字列）
var myMessage: String
...
myMessage = "私のアプリはSnapDish"
```

*myMessage* に自由に文字列を代入することができるようになる

> **NOTE**
> 初期値を代入する時点で型が定義されるので、初期値を代入するときは type annotation をしなくてもよい
> 初期値が無い場合、type annotation を使う時がある

### Contstants と Variables の命名規則

```swift
// unicode charactr を使う事ができる
let π = 3.14159
let アプリの名前 = "SnapDish"
```

使えないものもある。説明は割愛。

### Printing Contants と Variables (定数と変数の宣言）
**println** 関数を使って値を出力する事が出来る

```swift
let myAppName = "SnapDish"
println(myAppName)
// prints "SnapDish"
// Xcode を使っている場合、Console に出力される
// print()関数は、改行無しで出力
```

### Comments（コメント）
Cとほとんど同じ

```swift
// これはコメントだよ
/* これもコメントだよ
これもコメントだよ */
```

### Semicolons（セミコロン）
; セミコロンも一応使える。ただ、あまり使う必要はないかも
以下のようのステートメントを一行にしたい時などに使う事が可能

```swift
let cat = "ねこ"; println(cat)
// prints "ねこ"
```

### Integer（整数）
unsigned だったり 8, 16, 32, 64 bit によっても型がある。Cの命名規則に近い
例えば 8-bit unsigned と *UInt8*　、32-bit signed だと Int32
整数タイプの名前は大文字で始まる

#### Integer Bounds（整数の境界）

```swift
// 8-bit unsigned の整数最小値 0 を代入
let mixValue = UInt8.min
// 8-bit unsigned の整数最大値 255 を代入
let maxValue = UInt8.max
```

#### Int型
普段は基本的に、サイズを気にする必要はない
サイズを指定する必要がある場合を除き **Int** を使えうとよい
32-bit platform でも、-2,147,483,648 〜 2,147,483,647 と十分なサイズ

* 32-bit platform の時 **Int** は **Int32** と同じ
* 64-bit platform の時 **Int** は **Int64** と同じ

#### UInt型
UInt型もある
unsigned を指定したいときに使う

* 32-bit platform の時 **UInt** は **UInt32** と同じ
* 64-bit platform の時 **UInt** は **UInt64** と同じ

#### Floating-Point 数
Swift は、二種類の **Floating-Point** を提供する

* **Double** は 64-bit floating-point number
* **Float** は 32-bit floating-poing number

#### Type Safety と Type inference
Swift は type safe の言語で、型を明確にすることでコードを精度を高める
String に Int を代入するだの間違いを未然に防げる

type safe はコンパイル時に type のチェックをして compile time error を投げる
開発時に問題を特定して見つける事ができるようになる

とは言え、必ず型を指定する必要は無く、type inference（型推論）を使って適切な型を選んでくれる
代入する値を調べて適切な型をコンパイル時に選ぶ

```swift
let 整数 = 42 // Int 型と推論する

let pi = 3.14159 // Double と推論する

let anotherPi = 3 + 0.14159 // Doublue と推論する
// "3" は特定の型自体をもっていないので、最終的なアウトプットが Double と推論される
```

### Numeric Literals（数字リテラル）

* 十進数 プリフィックスなし
* バイナリ（binary） 0b で始まる
* 八進数（octal） 0o で始まる
* 十六進数（hexademcimal）0x で始まる

```swift
// 値が十進数（decimal）17 の時
let decimalInteger = 17 // 十進数
let binaryInteger = 0b10001 // バイナリ
let octalInteger = 0o21 // 八進数
let hexadecimalInteger = 0x11 // 十六進数
```

大文字もしくは小文字の **e** と **p** も使える
* 1.25e2 は 1.25 x 10<sup>2</sup>, or 125.0
* 1.25e-2 は 1.25 x 10<sup>-2</sup>, or 0.0125
* 0xFp2 は 15 x 2<sup>2</sup>, or 60.0
* 0xFp-2 は 15 x 2<sup>-2</sup>, or 3.75

などなど

### Numeric Type Conversion（数値型の変換）
基本的には、 **Int** を使うが、厳密にサイズを操作したい時などに必要。

#### 例えば

```swift
let ネガティブはだめよ: UInt8 = -1
// エラーを返す

let 大きすぎるよ: Int8 = Int8.max + 1
// こちらもエラーを返す
```

```swift
let 二千: UInt16 = 2000
let 一: Uint8 = 1
let 二千と一 = 二千 + UInt16(一)
// 定数 "二千と一" は、UInt16 の定数を足したので、UInt16 と推論される
```

_数値型(値）で型を初期化して新たに定義をし直す為の手法_

#### その他の例
```swift
let three = 3
let pointOneFourOneFiveNice = 0.14159
let pi = Double(three) + pointOneFourOneFiveNice
// pi は Double と推論される

let integerPi = Int(pi)
// integerPi == 3 になる
// Int(4.75) は 4、Int(-3.9) は、-3
```

> **NOTE**
> リテラルと定数や変数で型の変換は多少違う
> let pi = 3 + 0.14159 とした場合、Double になる
> リテラルは明確な型指定が無いので、type inference （型推論）を作動して適切な型を推論し定義する

### Type Aliases （エイリアス型指定）
型エイリアスを使うと自分で型名をつくることができ、可読性を高めるのに便利
また、外部の決まったサイズのデータなど扱う時など便利
※モデル部分で使うと良いのかな？

```swift
typealias AudioSample = UInt16
var maxAmplitudeFond = AudoSample.min
// maxAmplitudeFound は 0
```

### Booleans （ブーリアン型）

```swift
let イチゴは赤い = true
let イチゴは青い = false

if イチゴは赤い {
   println("イチゴは赤いよ！")
}

if イチゴは青い {
   println("イチゴは青くない！")
}
```

```swift
let i = 1
if i {
    // エラーになるよ！
}

let i = 1
if i == 1 {
    // エラーにならないよ！
}
```

### Tuples（タプル）
Tuples（タプル）は複数の値を一つの混合値として扱う事ができる
タプルの値には、異なる型の値を代入することが出来る

```swift
let http404Error = (404, "Not Found!")
// http404Error は (Int, String) の型を格納していて、値は、(404, "Not Found!")
```

上記は、 **(Int, String)型のタプル** と説明できる

#### 例えば

* 分解してそれぞれに代入することができる

```swift
let (statusCode, statusMessage = http404Error
println("ステータスコードは \(statusCode)")
println("ステータスメッセージは \(statusMessage)")
```

* _ (アンダースコア）を使うと、その部分を無視して値を代入できる

```swift
let (ステータスコードだけ, _) = http404Error
println("ステータスコードは、\(ステータスコードだけ)")
```

* index 番号を使うこともできる
```swift
println("ステータスコードは、\(http404Error.0)")
println("ステータスメッセージは、\(http404Error.1)")
```

* それぞれのエレメントに命名も出来る

```swift
let http200Status = (statusCode: 200, description: "OK")
println("ステータスコードは、 \(http200Status.statusCode)")
println("ステータスメッセージは、 \(http200Status.description)")
```

* 関数の戻り値としても使える。()を使って戻り値のエレメントを分解して代入することができ便利。

> **NOTE**
> タプルは一次てきにデータをグルーピングするのには向いているが、複雑なデータ構造を扱うのには向いていない
> その場合、クラスや構造体を使ってモデルをつくるほうが望ましい

### Optionals（オプショナル）
値が存在しているかしていないかを判断したりするもの（例をみたほうが良いかも）

#### 例えば

以下のように、"123" 数字の文字列が入っているかもしれない、"数字が入っているかも" 定数を toInt メソッドを使って整数に変換する処理をした場合、 "123" 数字が入っていない場合がある

```swift
let 数字が入っているかも = "123"
let 整数に変換した値 = 数字が入っているかも.toInt()
// "整数に変換した値" は Int型と推論されるが、何も無い場合もあり、それが "Optional Int"
```

* toInt()メソッドが、数字以外の場合だったら失敗する事もあるので、 **optional Int** として **Int** の変わりに返す
* **optional Int** は、 **Int?** と記述することができる
* **"?"** クエスチョンマークを使うと、上記の場合 **Int** か"何も無い"かのどちらか

#### If Statement and Fourced Unwarpping
If文を使って、オプショナルが値を持っているか、値があれば、 **true** と評価し、値が存在しない場合、 **false** を返す

オプショナルが値を保持している場合、 **!** エクスクラメーションマークをオプショナルの名前の最後につけると、値があると見なし強制的に解除する
_!_ を使う側で安全性を担保する必要がある

```swift
let 数字が入っているかも = "123"
let 整数に変換した値 = 数字が入っているかも.toInt()
if 整数に変換した値 {
    printlne("\(数字が入っているかも) は、\(整数に変換した値!) である")

} else {
    printlne("\(数字が入っているかも) の変換に失敗")

}
```

> **NOTE**
> **!** を使う時は、必ず optional に値が入っている事を確認するべき
> 値が無いとものに **!** を付けるとエラーになる

#### Optional Binding
Optional Binding はオプショナルが値がある無いかを評価して、ある場合、Constant or Vairable 値を定義する
if や while 文で利用する事ができ、オプショナルがあれば、定数や変数を一時的に定義をする

```swift
if let constantName = someOptional {
   // statements
}
```

```swift
let possibleNumber = "123"
if let actualNumber = possibleNumber.toInt() {
    // possbleNumber は actualNumber 整数を持っている 
} else {
    // possbleNumber は整数に変換できなかった

}
```

_この辺りの詳細は別のセクションで行いたい_

#### nil
nilという特殊な値無しを設定する時

```swifg
var serverResponseCode: Int? = 404
// serverResponseCode は 404整数を保持している
serverResponseCode = nil
// serverResponseCode は値無しなる
```

> **NOTE**
> nil はオプショナルでない定数 or 変数に利用できない
> 存在しない値を利用する場合、適切な型のオプショナルバリューとして宣言する必要がある

以下のように、宣言だけした場合、自動的に nil がセットされる

```swift
var surveyAnswer: String?
// surveyAnswer に nil が自動的にセットされる
```

> **NOTE**
> Swift の **nil** は、ObjC の **nil** とは違い、nil はポインターではなく、ある型の存在しない値
> どんな型でも **nil** をセットすることができる

### Implicitly Unwrapped Optionals
ここまで説明したように、オプショナルは "no value" を保持することができる
if文で存在を評価することもできる、などなど

* 詳しくは別のセクションで

#### 例えば

```swift
let possibleString: String? = "A optional string"
println(possibleString!) // (!) を使ってその値にアクセスする
// prints "An optional string."

let assumedString: String! = "An implicitly unwrapped optinal strings."
println(assumedString) // (!) を使わず、値にアクセスできる
// prints "An implicitly unwrapped optional string."
```

> **NOTE**
> Implicitly Unwrapped optional を使い、値を保持していない場合 runtime error が起こるの注意が必要

* この辺りも別のセクションで、(!)が必要な理由なども含めて別途まとめる、結構重要な個所

### Assertions（アサーション）
アサーションを使ってデバッグを効率的に行う事ができる
**assert** 関数を用いて、true or false と メッセージを使って表示させることができる

```swift
let age = -3
assert(age >= 0, "年齢は必ず0歳以上")
// assert(age >= 0) とも書く事ができる
```