Swift First Step

step1:「Hello, world」を出力する。

print("Hello, world")

step2:変数を宣言して初期化する。

var implicitInteger = 42 // Integer
implicitInteger = 50

変数の型を明示しない場合は初期値から型推論される。

step3:変数を初期化する。(型を明示的に宣言)

var explicitDouble: Double = 70.0 // Double

step4:定数を宣言して初期化する。

let implicitInteger = 42 //Integer

定数の型を明示しない場合は初期値から型推論される。

step5:定数を宣言して初期化する。(型を明示的に宣言)

let explicitInteger: Int = 42 //Integer

step6:変数は暗黙的に他の型に変換されない。

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

他の型に変換したいときはそのインスタンスをつくる。

step7:変数や定数値を文字列に挿入する。

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

\() の中で計算もできる。

step8:配列、辞書をつくる。

var shoppingList: [String] = ["catfish", "water", "tulips", "blue paint"]
shoppingList[1] = "bottle of water"

var occupations: [String:String] = [
  "Malcom": "Captain",
  "Kaylee": "Mechanic",
]
occupations["Jayne"] = "Public Relations"

配列、辞書をつくるためにはブラケット[]を使用し、その中にインデックスやキーを書くことで要素を参照することができる。

step9:初期化シンタックスを使い空の配列、辞書を作成する。

let emptyArray = [String]()
let emptyDictionay = [String: Float]()

step1:if文

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

step2:オプショナルバインディング

var optionalString: String?
print(optionalString == nil)

var optionalName: String? = "John Appleseed"
var greeting = "Hello!, "
if let name = optionalName { // Optional Binding
  greeting = greeting + name
}
print(greeting)

型の後に?を記述することでオプショナル型を表す。
オプショナル値はnilで初期化されている。
オプショナル値がnilならば条件文はfalseとなり、そうでなければオプショナル値はアンラップされ（この場合はStringに変換）ブロックの中で使用できる。

step3:デフォルト値

let nickName: String? = nil
let fullName: String = "John Appleseed"
let informalGreeting = "Hi \(nickName ?? fullName)"

??を記述することでオプショナル値がnilの場合にデフォルト値を設定できる。

step4:switch文

let fruit = "mikan"
switch fruit {
case "apple":
  print("What color is this apple?")
case "orange", "kiwi":
  print("sour taste")
case let x where x.hasSuffix("n"):
  print("The last character is n")
default:
  print("default statement")
}

default節は省略不可。
case節ではbreak文がなくても次のcase節の処理は行われない。

step5:for-in文

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
    }
  }
}
print(largest)

辞書は順序不同のコレクションなので、イテレートは任意の順番になる。

step6:while文

var n = 2
while n < 100 {
  n = n * 2
}
print(n)

var m = 2
repeat {
  m = m * 2
} while m < 100
print(m)

条件が変化するまで繰り返される。
repeat文は少なくとも1回はブロックが実行される。

step7:for文と範囲演算子

var loop = 0
for i in 0..<4 {
  loop += i
}
print(loop)

この2つは同じ結果を出力する

step1:関数宣言

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

関数を宣言するにはfuncキーワードを使い、()の中に仮引数のリスト、関数の戻り値の型を->の後に記述する。

step2:カスタム引数

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

step3:タプル

func  calculateStatistics(scores: [Int]) -> (min: Int, max: Int, sum: Int) {
  var min = scores[0]
  var max = scores[0]
  var sum = 0

  for score in scores {
    if score > max {
      max = score
    } else if score < min {
      min = score
    }
    sum += score
  }

  return (min, max, sum)
}
let statistics = calculateStatistics([5, 3, 100, 3, 9])
// Swift3.0
let statistics = calculateStatistics(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
print(statistics.2)

関数から複数の値を返すためにタプルを使います。
タプルは配列と違って異なる型の値をまとめることができるが、要素の追加削除はできない。要素は名前または数値で参照できる。

step4:可変長引数をとる関数宣言

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

step5:ネストした関数

func returnFifteen() -> Int {
  var y = 10
  func add() {
    y += 5
  }
  add()
  return y
}
returnFifteen()

ネストされた関数は外側の関数の変数を参照できる。

step6:他の関数を戻り値として返す関数

func makeIncrementer() -> (Int -> Int) {
  func addOne(number: Int) -> Int {
    return 1 + number
  }
  return addOne
}
// Swift3.0
func makeIncrementer() -> ((Int) -> Int) {
  func addOne(number: Int) -> Int {
    return 1 + number
  }
  return addOne
}
var increment = makeIncrementer()
increment(7)

関数は他の関数を戻り値として返せる。

step7:他の関数を引数としてとる関数

func hasAnyMatches(list: [Int], condition: Int -> Bool) -> Bool {
  for item in list {
    if condition(item) {
      return true
    }
  }
  return false
}
// Swift3.0
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, condition: lessThanTen)
// Swift3.0
hasAnyMatches(list: numbers, condition: lessThanTen)

関数は他の関数を引数としてとることができる。

step8:無名関数

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

関数の名前をつけないで関数を定義する。ブレースで囲み、関数型と処理との間にinをおく。

step1:クラス宣言

class Shap {
  var numberOfSides = 0
  func simpleDescription() -> String {
    return "A shape with \(numberOfSides) sides."
  }
}

var shape = Shap()
shape.numberOfSides = 7
var shapeDescription = shape.simpleDescription()

クラスのプロパティは定数、変数宣言と同じ方法で宣言され、メソッドも関数と同じ方法で宣言される。
クラス名の後に括弧をかくことでクラスのインスタンスを作成します。プロパティとインスタンスのメソッドにアクセスするには、ドットシンタックスを使用する。

step2:イニシャライザ

class NamedShape {
  var numberOfSides: Int = 0
  var name: String

  init(name: String) {
    self.name = name
  }

  func simpleDescription() -> String {
    return "A shape width \(numberOfSides) sides."
  }
}

インスタンスがつくられるときに、クラスのプロパティを初期化するためにinitを使用する。
selfは初期化子とプロパティを区別するために使用される。

step3:継承

class Square: NamedShape {
  var sideLength: Double

  init(sideLength: Double, name: String) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 4
  }

  func area() -> Double {
    return sideLength * sideLength
  }

  override func simpleDescription() -> String {
    return "A square width sides of length \(sideLength)."
  }
}

let mySquare = Square(sideLength: 5.2, name: "my square")
mySquare.area()
mySquare.simpleDescription()

サブクラスはクラス名の後に:をつけスパークラスの名前を記述する。
上書きするスパークラスのメソッドにはoverrideをつける。

step4:プロパティにgetterとsetterを設定する。

class EquilateralTriangle: NamedShape {
  var sideLength: Double = 0.0

  init(sideLength: Double, name: String) {
    self.sideLength = sideLength
    super.init(name: name)
    numberOfSides = 3
  }

  var perimeter: Double {
    get {
      return 3.0 * sideLength
    }
    set {
      sideLength = newValue / 3.0
    }
  }

  override func simpleDescription() -> String {
    return "An equilateral triangle with sides of length \(sideLength)."
  }
}
var triangle = EquilateralTriangle(sideLength: 3.1, name: "a triangle")
print(triangle.perimeter)
triangle.perimeter = 9.9
print(triangle.sideLength)

プロパティはgetterとsetterをもつことが可能。setterのnewValueは新たに設定した値が入る。

step5:プロパティにwillSetとdidSetを設定する。

var num: Int = 0

class Person {
  let name: String
  var age: Int = 0 {
    willSet {
      print("\(self.age)歳から\(newValue)歳へ年齢を変更します。")
      num += num + 1
      print(num)
    }
    didSet {
      print("didSet\(oldValue)歳から\(self.age)歳へ年齢を変更しました。")
      num += num + 1
      print(num)
    }
  }
  init(name: String, age: Int) {
    self.name = name
    self.age = age
  }
}

let taro = Person(name: "山田太郎", age: 25)
taro.age = 26

プロパティにwillSetとdidSetを設定することで、プロパティの変更前後に処理を行うことができる。

step1:列挙型

enum Rank: Int {
  case Ace = 1
  case Two, Three, Four, Five, Six, Seven, Eight, Nine, Ten
  case Jack, Queen, King
  func simpleDescription() -> String {
    switch self {
    case .Ace:
      return "ace"
    case .Jack:
      return "jack"
    case .Queen:
      return "queen"
    case .King:
      return "king"
    default:
      return String(self.rawValue)
    }
  }
}

let ace = Rank.Ace
let aceRawValue = ace.rawValue

if let convertedRank = Rank(rawValue: 3) {
  let threeDescription = convertedRank.simpleDescription()
}

列挙型はメソッドをもつことが可能でプロパティrawValueで列挙型の値にアクセスできる。
列挙型の値は整数で、最初の値(Ace)が1であるから続く値は順に1づつ加算されている。

step2:構造体

class ClassAnimal {
  var name: String = ""
  var age: Int = 0
  init(name: String, age: Int) {
    self.name = name
    self.age = age
  }
}

let classALion = ClassAnimal(name: "ライオン", age: 5)
let classBLion = classALion
classBLion.name = "らいおん"
classALion.name // らいおん

struct StructAnimal {
  var name: String = ""
  var age: Int = 0
  init(name: String, age: Int) {
    self.name = name
    self.age = age
  }
}

let structALion = StructAnimal(name: "ライオン", age: 5)
var structBLion = structALion
structBLion.name = "らいおん"
structALion.name //ライオン

構造体はメッソドやイニシャライズなどクラスと多くの振る舞いが同じであるが最も重要な違いは構造体は値渡し、クラスは参照渡しである。

step1:プロトコル

protocol ExampleProtocol {
  var simpleDescription: String {get}
  mutating func adjust()
}

class SimpleClass: ExampleProtocol {
  var simpleDescription: String = "A very simple class."
  var anotherProperty: Int = 69105
  func adjust() {
    simpleDescription += " Now 100% adjusted."
  }
}

let simpleClass = SimpleClass()
let simpleClassInitDescription = simpleClass.simpleDescription
simpleClass.adjust()
let simpleClassChangedDescription = simpleClass.simpleDescription


struct SimpleStructure: ExampleProtocol {
  var simpleDescription: String = "A simple structure"
  mutating func adjust() {
    simpleDescription += "(adjusted)"
  }
}

var simpleStructure = SimpleStructure()
let simpleStructureInitDescription = simpleStructure.simpleDescription
simpleStructure.adjust()
let simpleStructureChangedDescription = simpleStructure.simpleDescription

プロトコルを宣言するためにキーワードprotocolを使用する。クラス、列挙型、構造体はすべてプロトコルに対応している。
構造体のメソッドを変更するためにはmutatingキーワードを使う。

step2:エクステンション

protocol ExampleProtocol {
  var simpleDescription: String {get}
  mutating func adjust()
}

extension Int: ExampleProtocol {
  var simpleDescription: String {
    return "The number \(self)"
  }
  mutating func adjust() {
    self += 42
  }
}

print(7.simpleDescription)

すでにある型に新たなメソッドやコンピューテッド・プロパティなどの機能を追加する際に使用する。

step1:Errorの定義

enum PrinterError: ErrorProtocol {
  case outOfPaper
  case noToner
  case onFire
}

プロトコルErrorProtocolを継承した任意の型を使用してエラーを表す。

step2:Errorを投げる関数

func send(job: Int, toPrinter printerName: String) throws -> String {
  if printerName == "Never Has Toner" {
      throw PrinterError.noToner
  }
  return "Job sent"
}

throwを使ってErrorを投げ、Errorを投げる関数にはthrowsを付ける。

step3:do-catchを使用したErrorハンドリング

do {
  let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
  print(printerResponse)
} catch {
  print(error)
}
// 複数のcatchブロック
do {
  let printerResponse = try send(job: 1440, toPrinter: "Gutenberg")
  print(printerResponse)
} catch PrinterError.onFire {
  print("I'll just put this over here, with the rest of the fire.")
} catch let printerError as PrinterError {
  print("Printer error: \(printerError).")
} catch {
  print(error)
}

doブロックの中のErrorを投げる可能性があるコードの前にtryを付ける。

ブロックの中のerrorに自動的にErrorが入る。

step4:try?を使用したErrorハンドリング

let printerSuccess = try? send(job: 1884, toPrinter: "Mergenthaler")
let printerFailure = try? send(job: 1885, toPrinter: "Never Has Toner")

結果をオプショナル型にして返し、Errorが発生した場合はnilを返す。

step5:defer

var fridgeIsOpen = false
let fridgeContent = ["milk", "eggs", "leftovers"]
func fridgeContains(_ food: String) -> Bool {
  fridgeIsOpen = true
  defer {
      fridgeIsOpen = false
  }
  let result = fridgeContent.contains(food)
  return result
}
fridgeContains("banana")
print(fridgeIsOpen)

Errorが発生するに関わらず実行される。Errorが発生する可能性があるコードの前に記述すること。

step1:ジェネリクス関数

func makeArray<Item>(item: Item, numberOfTimes: Int) -> [Item] {
  var result = [Item]()
  for _ in 0..<numberOfTimes {
    result.append(item)
  }
  return result
}
makeArray("knock", numberOfTimes:4)
// Swift3.0
makeArray(item: "knock", numberOfTimes:4)

step1:ジェネリクス型

enum OptionalValue<T> {
  case None
  case Some(T)
}
var possibleInteger: OptionalValue<Int> = .None
possibleInteger = .Some(100)

クラス、列挙型、構造体もジェネリクス型をとりうる。

Swift First Step

実行環境

Simple Values

Control Flow

Functions and Closures

Objects and Classes

Enumerations and Structures

Protocols and Extensions

Error Handling

Generics