Kotlinに超入門してみたので続いてSwiftに超入門してみる。
超入門に使用する書籍は以下。
[改定新版]Swift実践入門-直感的な文法と安全性を兼ね備えた言語 WEB+DB PRESS plus
Playgroundsを使って確認しながら各単元の何かを書いてみる。
変数と定数
変数はvar、定数はletで宣言する。Kotlinと同様に宣言時に型情報が決まる必要がある。
つまり、変数(定数)宣言時に型アノテーションを書くか、初期値の型から型推論させるか。
型推論が出来るので、右辺から型が決まる場合には左辺の型定義(型アノテーション)は省略可。
let i: Int = 123
let j = 123
print(type(of:i)) // Int
print(type(of:j)) // Int
nilは代入不可。使用時までに値を入れている必要あり。
let i: Int = nil // Nil cannot initialize specified type \'Int\'
let j: Int
j = nil // Nil cannot be assigned to type \'Int\'
let v: Int
print(v) // Constant \'v\' used before being initialized
スコープ
外側の宣言は内側の宣言で使える。逆はできない。特別な予約語は不要。普通。
let globalint: Int = 100
func hoge() {
lef localint: Int = 200
print(globalint) // 100
print(localint) // 200
}
Bool型,リテラル
Bool型のリテラルはtrue,false。
演算子は論理和、論理積、否定のみ。普通。
let a: Bool = true
let b: Bool = false
print (a && b )// false
print (a || b )// true
print (!a) // false
Int型,リテラル
IntはInt8,Int16,Int32,Int64。
32bitプラットフォームでIntはInt32、64bitだとInt64。普通。
Float型,Double型,リテラル
32bitがFloat、64bitがDouble。
Float,Doubleは無限(isInfinite)と非数値(isNaN)という状態をStaticプロパティとして持つ。
let a: Double = 10.0 / 0.0
a.isInfinite // true
let b: Double = 0.0 / 0.0
b.isNaN // true
異型間の代入
Swiftでは型が異なる変数同士の代入を暗黙的にできない。イニシャライザをかます。
縮小方向の代入は端数処理が行われる。
let a: Int32 = 100
let b: Int64 = a // Cannot convert value of type \'Int32\' to specified type \'Int64\'
let c: Int64 = Int64(a)
let x: Float = 1.0
let y: Int = Int(x) // 1
異型間の比較
Swiftでは型が異なる変数同士の比較ができない。イニシャライザをかます。
結構、型の違いにシビアなのか...。
Int32とInt64は比較できるみたい。FloatとDoubleはできない。
let a: Float = 100.0
let b: Double = 100.0
let c = (a == b) // Binary operator \'==\' cannot be applied to operands of type \'Float\' and \'Double\'
let d = (a == Float(b)) // true
String型,リテラル
文字列リテラルはダブルクォーテーション。エスケープは一般的なやつが使える。
リテラル内での変数展開は()演算子。${}の方がいいのに...。
let x: Int = 100
let v: String = \"hoge(x)fuga\" // hoge100fuga
kotlinでも見かけたスリーダブルクォート。これの発祥はPythonらしい。
面白いのがスリーダブルクォート内において変数自体のインデント分が無視されること。
kotlinのTrimよりも強烈。以下、sとrの出力は同じになる。
let s: String = \"\"\"
Swift入門
Swift入門
Swift入門
\"\"\"
print(s)
let r: String = \"\"\"
Swift入門
Swift入門
Swift入門
\"\"\"
print(r)
String.Index
StringとCharacterの関係も一般的。String内のCharacterを指す方法が用意されている。
String.startIndex(=0),String.endIndex(=文字数)を使ってCharacterを指す例。
let a: String = \"abcde\"
let b: Character = a[a.startIndex] // a
let lastindex = a.index(a.endIndex,offsetBy: -1)
let c: Character = a[lastindex] // e
Int型とString型の変換
イニシャライザを通す。変換できない場合はnilが入る。
let i: Int = 100
let s: String = String(i)
let s2: String = \"hoge\"
let i2 = Int(s2) // nil
文字列の結合
文字列の結合は+演算子。append(_:)も使える。
let s1: String = \"hoge\"
let s2: String = \"fuga\"
let s3: String = s1 + s2
let s4: String = s1.append(s2)
配列,配列リテラル
配列はArray。SyntaxSugarとして[Element]という書き方もできる。
配列リテラルは[]。同一型リテラルの配列から型推論可能。
順序数で要素にアクセス可能。
append(_:)で追加、insert(_at:)で挿入、remote(at:)で削除。
let ary1: Array = [1,2,3,4,5]
let ary2: [Int] = [1,2,3,4,5]
let ary3 = [1,2,3,4,5] // Intの配列
let ary4 = [\"hoge\",\"fuga\"] // Stringの配列
let a = ary1[0] // 1
ary1.append(6) // [1,2,3,4,5,6]
ary1.insert(10,at: 1) // [ 1,10,2,3,4,5,6]
ary1.remove(at: 0) // [10,2,3,4,5,6]
ary1.removeLast() // [10,2,3,4,5]
ary1.removeAll() // []
Dictionary型,リテラル
Key->Value辞書はDictionary、SyntaxSugerとして[Key:Value]という書き方もできる。
辞書リテラルは[\"key1\":\"value1\",\"key2\":\"value2\"]のように書く。
同一型の辞書から型推論可能。
let dic1 : Dictionary = [\"a\":1,\"b\":2]
let dic2 : [String:Int] = [\"a\":1,\"b\":2]
let dic3 = [\"a\":1, \"b\":2]
Keyは一意でないといけないので、Keyとして使える型には制限がつく。
DictionaryはDictionary。Key型はHashableプロトコル(インターフェース?)
に準拠したもの(Keyからハッシュ値を計算できる)のみ使える。
DictionaryへのアクセスはOptional(Value)を返す。つまり無いキーの値はnil。
let dic3 = [\"a\":1, \"b\":2]
let a = dic3[\"a\"] // 1
let b = dic3[\"c\"] // nil
更新,追加は同じ。存在するkeyを指定して値を代入すれば更新、存在しないkeyなら追加。
削除はnilを設定する。
var dic4 = [\"a\":1,\"b\":2]
dic4[\"b\"] = 3 // [\"a:1\",\"b\":3]
dic4[\"c\"] = 4 // [\"a:1\",\"b\":3,\"c\":4]
dic4[\"a\"] = nil // [\"b\":3,\"c\":4]
範囲型
Swiftの範囲型は数学的なモデリングになってる。
1つ目は開区間、半開区間、閉区間。2つ目は順序(計数可能)。
数値以外の範囲についてもforループを回して順番に要素にアクセスできたりする。
範囲型が範囲を定義すると、範囲に収まる値が得られるのではなく、
区間と上限下限をもったオブジェクトのまま保持される。
let range1 = 1..<4 // CountableRange(1..<4) : lower bound=1,uppper bound=4
for value in range1 {
print(value) // 1 2 3
}
let range2 = 1...4 // CountableCloseRange(1..4) : lower bound=1,uppper bound=4
for value in range2 {
print(value) // 1 2 3 4
}
let range3 : Range = 1..<4 // Range<1..<4) :lower bound=1,upper bound=4
let range4 : Rnage = 1...4 // Range<1..4) : lower bound=1,upper bound=4
Optional型
型がnilを許容するか否か。Wrapped型がnilを許容する場合はOptional、許容しない場合はWrapped。
Suger Syntaxとして、OptionalをWrapped?と書くこともできる。
let ival1: Int = 32
let ival2: Int = nil // Nil cannot initialize specified type \'Int\'
let ival3: Optional = 32
let ival4: Optional = nil
let ival5: Int? = nil
ぬるぽ防止(Unwrap)
デフォルトではOptional型同士の四則演算はできない。
明示的なアンラップ(Optional->Wrapped)が必要。
??演算子を使うと、左辺のOptional(Wrapped)がnilの場合に右辺、
nilでない場合にWrappedをアンラップして返す。
!演算子を使うと強制アンラップ。当然nilならぬるぽ。ぬるぽ時のエラーがドキッとする。
当然、強制アンラップは非推奨。
let ival6: Int? = 100
let ival7: Int? = 200
let ival8 = ival6 + ival7
let ival6: Int? = 100
let value1 = ival6 ?? 3 // 100
let ival7: Int? = nil
let value2 = ival7 ?? 3 // 3
let ival8: Int? = 100
let ival9: Int? = 200
let ival10 = ival8! + ival9! // error: Execution was interrupted, reason: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0).
ぬるぽ防止(Optional chain)
Optionalの値を使うために必ずアンラップしないといけないとなると面倒。
?.演算子を使うと、nil、非nilの場合を1行に含めることができる。
左辺がnilである場合はnil、nilでない場合はOptional(Wrapped)を返す。
?.を数珠つなぎに書いていくと、最初のnilで評価が止まってそれ以降のnil参照を行わない。(なのでchain)
let optionalDouble1 = Optional(1.0) // Optional(1.0)
let optionalInfinite1 = optionalDouble1?.isInfinite // Optional(false)
let optionalDouble2 :Double? = nil
let optionalInfinite2 = optionalDouble2?.isInfinite // nil
強制アンラップ構文
ぬるぽを恐れるあまり、nil可能なケースが面倒になっているのを和らげるためか、
何か迷いのようなものを感じるけれども、OptionalをWrapped?ではなくWrapped!と書くと、
型としてOptionalを維持したまま、暗黙的に強制アンラップしてから計算が行われる。
当然、nilが入っていればぬるぽで止まる。
let intval: Int? = 100
print(intval + 200) // Value of optional type \'Int?\' must be unwrapped to a value of type \'Int\'
let intval: Int! = 100
print(intval + 200) // 300
let intval2: Int! = nil
print(intval2 + 200) // error: Execution was interrupted, reason: EXC_BAD_INSTRUCTION (code=EXC_I386_INVOP, subcode=0x0).
アップキャスト
継承関係やプロトコル(インターフェース?)準拠により上位型の存在が確実な場合、
アップキャスト可能。アップキャストはas演算子。
確実な上位関係でない型へのアップキャストは実行時エラー。
アップキャストは暗黙的に実行可能。
let str : String = \"hogehoge\"
let any : Any = str as Any
let int : Int = str as Int // Cannot convert value of type \'String\' to type \'Int\' in coercion
let any2 : Any = str
ダウンキャスト
上位型から下位型へのキャスト。失敗のリスクがある。
失敗のリスクをOptionalで解決するのがas?演算子、リスクをケアしないのがas!演算子。
as?によるダウンキャストはOptionalを返す。as!はWrappedを返す。
as!が失敗した場合、実行時エラーが発生する。
let any = 1 as Any
let int = any as? Int // Optional(1)
let any2 = 1 as Any
let int2 = any2 as! Int // 1
