Swiftツアー

伝統的に、新しい言語で最初に書くプログラムは画面に「Hello, world!」と表示するものです。Swiftでは、これを1行で実現できます：

print("Hello, world!")
// "Hello, world!"と出力

他の言語を知っていれば、この構文は見慣れたものでしょう。Swiftでは、この1行のコードが完全なプログラムです。テキスト出力や文字列処理などの機能のために別のライブラリをインポートする必要はありません。グローバルスコープで書かれたコードがプログラムのエントリポイントとして使用されるため、main()関数も必要ありません。また、各文の末尾にセミコロンを書く必要もありません。

このツアーでは、さまざまなプログラミングタスクの実現方法を示しながら、Swiftでコードを書き始めるのに十分な情報を提供します。理解できない部分があっても心配しないでください。このツアーで紹介するすべての内容は、本書の残りの部分で詳しく説明されます。

シンプルな値

定数を作成するにはletを、変数を作成するにはvarを使用します。定数の値はコンパイル時に分かっている必要はありませんが、値を割り当てるのは1回だけでなければなりません。これは、一度決定して多くの場所で使用する値に名前を付けるために定数を使用できることを意味します。

var myVariable = 42
myVariable = 50
let myConstant = 42

定数や変数は、割り当てたい値と同じ型でなければなりません。ただし、型を常に明示的に書く必要はありません。定数や変数を作成するときに値を提供すると、コンパイラがその型を推論できます。上の例では、コンパイラはmyVariableの初期値が整数であるため、整数型であると推論します。

初期値が十分な情報を提供しない場合（または初期値がない場合）、変数の後にコロンで区切って型を記述します。

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

実験明示的にFloat型で、値が4の定数を作成してください。

値が別の型に暗黙的に変換されることはありません。値を別の型に変換する必要がある場合は、目的の型のインスタンスを明示的に作成してください。

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

実験最後の行からStringへの変換を削除してみてください。どのようなエラーが発生しますか？

文字列に値を含めるさらに簡単な方法があります：値を括弧で囲み、括弧の前にバックスラッシュ（\）を書きます。例えば：

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

実験 \()を使用して、文字列に浮動小数点計算を含め、また挨拶に誰かの名前を含めてください。

複数行にわたる文字列には、3つの二重引用符（"""）を使用します。引用符で囲まれた各行の先頭のインデントは、閉じ引用符のインデントと一致している限り削除されます。例えば：

let quotation = """
        Even though there's whitespace to the left,
        the actual lines aren't indented.
            Except for this line.
        Double quotes (") can appear without being escaped.

        I still have \(apples + oranges) pieces of fruit.
        """

配列と辞書は角括弧（[]）を使用して作成し、角括弧内にインデックスまたはキーを書いて要素にアクセスします。最後の要素の後にカンマを付けることもできます。

var fruits = ["strawberries", "limes", "tangerines"]
fruits[1] = "grapes"

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

配列は要素を追加すると自動的に大きくなります。

fruits.append("blueberries")
print(fruits)
// "["strawberries", "grapes", "tangerines", "blueberries"]"と出力。

空の配列や辞書を書くときも角括弧を使用します。配列の場合は[]、辞書の場合は[:]と書きます。

fruits = []
occupations = [:]

空の配列や辞書を新しい変数に代入する場合、または型情報がない場所に代入する場合は、型を指定する必要があります。

let emptyArray: [String] = []
let emptyDictionary: [String: Float] = [:]

制御フロー

条件分岐にはifとswitchを、ループにはfor-in、while、repeat-whileを使用します。条件やループ変数を囲む括弧は省略可能ですが、本体を囲む波括弧は必須です。

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

if文では、条件はブール式でなければなりません。つまり、if score { ... }のようなコードはエラーであり、ゼロとの暗黙的な比較ではありません。

代入の等号（=）の後やreturnの後にifやswitchを書いて、条件に基づいて値を選択できます。

let scoreDecoration = if teamScore > 10 {
    "🎉"
} else {
    ""
}
print("Score:", teamScore, scoreDecoration)
// "Score: 11 🎉"と出力。

ifとletを一緒に使用して、欠けている可能性のある値を扱うことができます。これらの値はオプショナルとして表されます。オプショナル値は値を含むか、値が欠けていることを示すnilを含みます。型の後に疑問符（?）を書いて、値をオプショナルとしてマークします。

var optionalString: String? = "Hello"
print(optionalString == nil)
// "false"と出力。

var optionalName: String? = "John Appleseed"
var greeting = "Hello!"
if let name = optionalName {
    greeting = "Hello, \(name)"
}

実験 optionalNameをnilに変更してください。どのような挨拶が得られますか？optionalNameがnilの場合に異なる挨拶を設定するelse句を追加してください。

オプショナル値がnilの場合、条件はfalseとなり、波括弧内のコードはスキップされます。それ以外の場合、オプショナル値はアンラップされ、letの後の定数に代入され、アンラップされた値がコードブロック内で利用可能になります。

オプショナル値を扱う別の方法は、??演算子を使用してデフォルト値を提供することです。オプショナル値が欠けている場合、デフォルト値が代わりに使用されます。

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

より短い書き方で値をアンラップし、アンラップされた値に同じ名前を使用できます。

if let nickname {
    print("Hey, \(nickname)")
}
// nicknameがnilなので何も出力されない。

switchはあらゆる種類のデータと幅広い比較操作をサポートしています。整数や等価性テストに限定されません。

let vegetable = "red pepper"
switch vegetable {
case "celery":
    print("Add some raisins and make ants on a log.")
case "cucumber", "watercress":
    print("That would make a good tea sandwich.")
case let x where x.hasSuffix("pepper"):
    print("Is it a spicy \(x)?")
default:
    print("Everything tastes good in soup.")
}
// "Is it a spicy red pepper?"と出力

実験 defaultケースを削除してみてください。どのようなエラーが発生しますか？

パターンにマッチした値を定数に代入するためにletがどのように使用されているかに注目してください。

マッチしたswitchケース内のコードを実行した後、プログラムはswitch文から抜けます。次のケースへ実行が続くことはないため、各ケースのコードの最後で明示的にbreakする必要はありません。

辞書内の項目を反復処理するには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 (_, numbers) in interestingNumbers {
    for number in numbers {
        if number > largest {
            largest = number
        }
    }
}
print(largest)
// "25"と出力。

実験 _を変数名に置き換えて、最大の数がどの種類のものだったかを追跡してください。

条件が変わるまでコードブロックを繰り返すにはwhileを使用します。ループの条件を最後に置くこともでき、ループが少なくとも1回実行されることを保証できます。

var n = 2
while n < 100 {
    n *= 2
}
print(n)
// "128"と出力。

var m = 2
repeat {
    m *= 2
} while m < 100
print(m)
// "128"と出力。

実験条件をm < 100からm < 0に変更して、ループ条件が最初からfalseの場合にwhileとrepeat-whileがどのように異なる動作をするか確認してください。

..<を使用してインデックスの範囲を作成し、ループ内でインデックスを保持できます。

var total = 0
for i in 0..<4 {
    total += i
}
print(total)
// "6"と出力。

..<を使用すると上限値を含まない範囲を作成し、...を使用すると両端の値を含む範囲を作成します。

関数とクロージャ

関数を宣言するにはfuncを使用します。関数名の後に括弧で引数リストを書いて関数を呼び出します。->を使用してパラメータ名と型を関数の戻り値の型から分離します。

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

実験 dayパラメータを削除してください。挨拶に今日のランチスペシャルを含めるパラメータを追加してください。

デフォルトでは、関数はパラメータ名を引数のラベルとして使用します。パラメータ名の前にカスタム引数ラベルを書くか、引数ラベルを使用しない場合は_を書きます。

func greet(_ person: String, on day: String) -> String {
    return "Hello \(person), today is \(day)."
}
greet("John", on: "Wednesday")

タプルを使用して複合値を作成します。例えば、関数から複数の値を返すために使用できます。タプルの要素は名前または番号で参照できます。

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(scores: [5, 3, 100, 3, 9])
print(statistics.sum)
// "120"と出力。
print(statistics.2)
// "120"と出力。

関数はネストできます。ネストされた関数は、外側の関数で宣言された変数にアクセスできます。長いまたは複雑な関数内のコードを整理するためにネストされた関数を使用できます。

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)

関数は別の関数を引数の1つとして受け取ることができます。

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(list: numbers, condition: lessThanTen)

関数は実際にはクロージャの特殊なケースです：後で呼び出すことができるコードブロックです。クロージャ内のコードは、クロージャが作成されたスコープで利用可能だった変数や関数にアクセスできます。クロージャが実行されるときに異なるスコープにある場合でもです。これはすでにネストされた関数で見た例です。名前のないクロージャを書くには、コードを波括弧（{}）で囲みます。inを使用して引数と戻り値の型を本体から分離します。

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

実験クロージャを書き換えて、すべての奇数に対してゼロを返すようにしてください。

クロージャをより簡潔に書くためのオプションがいくつかあります。デリゲートのコールバックなど、クロージャの型がすでに分かっている場合は、パラメータの型、戻り値の型、またはその両方を省略できます。単一文のクロージャは、その唯一の文の値を暗黙的に返します。

let mappedNumbers = numbers.map({ number in 3 * number })
print(mappedNumbers)
// "[60, 57, 21, 36]"と出力。

名前の代わりに番号でパラメータを参照できます。このアプローチは非常に短いクロージャで特に有用です。関数の最後の引数として渡されるクロージャは、括弧の直後に書くことができます。クロージャが関数の唯一の引数である場合、括弧を完全に省略できます。

let sortedNumbers = numbers.sorted { $0 > $1 }
print(sortedNumbers)
// "[20, 19, 12, 7]"と出力。

オブジェクトとクラス

classの後にクラス名を書いてクラスを作成します。クラス内のプロパティ宣言は、クラスのコンテキスト内にあることを除けば、定数や変数の宣言と同じ方法で書きます。同様に、メソッドと関数の宣言も同じ方法で書きます。

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

実験 letを使用して定数プロパティを追加し、引数を取る別のメソッドを追加してください。

クラス名の後に括弧を付けてクラスのインスタンスを作成します。ドット構文を使用してインスタンスのプロパティとメソッドにアクセスします。

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

このShapeクラスのバージョンには重要なものが欠けています：インスタンスが作成されたときにクラスを設定するイニシャライザです。initを使用して作成します。

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

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

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

nameプロパティとイニシャライザのname引数を区別するためにselfがどのように使用されているかに注目してください。クラスのインスタンスを作成するとき、イニシャライザの引数は関数呼び出しのように渡されます。すべてのプロパティには値が代入される必要があります。宣言内（numberOfSidesのように）またはイニシャライザ内（nameのように）のいずれかで。

オブジェクトが解放される前にクリーンアップを実行する必要がある場合は、deinitを使用してデイニシャライザを作成します。

サブクラスはクラス名の後にスーパークラス名をコロンで区切って書きます。クラスが標準的なルートクラスをサブクラス化する必要はないため、必要に応じてスーパークラスを含めたり省略したりできます。

スーパークラスの実装をオーバーライドするサブクラスのメソッドにはoverrideを付けます。overrideなしで誤ってメソッドをオーバーライドすると、コンパイラがエラーとして検出します。コンパイラは、実際にはスーパークラスのどのメソッドもオーバーライドしていないのにoverrideが付いているメソッドも検出します。

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 with sides of length \(sideLength)."
    }
}
let test = Square(sideLength: 5.2, name: "my test square")
test.area()
test.simpleDescription()

実験 NamedShapeの別のサブクラスCircleを作成してください。イニシャライザの引数として半径と名前を取ります。Circleクラスにarea()とsimpleDescription()メソッドを実装してください。

単純な格納プロパティに加えて、プロパティにはゲッターとセッターを持たせることができます。

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)
// "9.3"と出力。
triangle.perimeter = 9.9
print(triangle.sideLength)
// "3.3000000000000003"と出力。

perimeterのセッターでは、新しい値には暗黙の名前newValueがあります。setの後の括弧内で明示的な名前を指定できます。

EquilateralTriangleクラスのイニシャライザには3つの異なるステップがあることに注目してください：

サブクラスが宣言するプロパティの値を設定する。
スーパークラスのイニシャライザを呼び出す。
スーパークラスで定義されたプロパティの値を変更する。メソッド、ゲッター、またはセッターを使用する追加のセットアップ作業もこの時点で行えます。

プロパティを計算する必要はないが、新しい値を設定する前後に実行されるコードを提供する必要がある場合は、willSetとdidSetを使用します。提供したコードは、イニシャライザの外部で値が変更されるたびに実行されます。例えば、以下のクラスは三角形の辺の長さが常に正方形の辺の長さと同じであることを保証します。

class TriangleAndSquare {
    var triangle: EquilateralTriangle {
        willSet {
            square.sideLength = newValue.sideLength
        }
    }
    var square: Square {
        willSet {
            triangle.sideLength = newValue.sideLength
        }
    }
    init(size: Double, name: String) {
        square = Square(sideLength: size, name: name)
        triangle = EquilateralTriangle(sideLength: size, name: name)
    }
}
var triangleAndSquare = TriangleAndSquare(size: 10, name: "another test shape")
print(triangleAndSquare.square.sideLength)
// "10.0"と出力。
print(triangleAndSquare.triangle.sideLength)
// "10.0"と出力。
triangleAndSquare.square = Square(sideLength: 50, name: "larger square")
print(triangleAndSquare.triangle.sideLength)
// "50.0"と出力。

オプショナル値を扱うとき、メソッド、プロパティ、添字などの操作の前に?を書くことができます。?の前の値がnilの場合、?の後のすべてが無視され、式全体の値はnilになります。それ以外の場合、オプショナル値はアンラップされ、?の後のすべてはアンラップされた値に対して動作します。どちらの場合も、式全体の値はオプショナル値です。

let optionalSquare: Square? = Square(sideLength: 2.5, name: "optional square")
let sideLength = optionalSquare?.sideLength

列挙型と構造体

enumを使用して列挙型を作成します。クラスや他のすべての名前付き型と同様に、列挙型にはメソッドを関連付けることができます。

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

実験 2つのRank値をその生の値を比較することで比較する関数を書いてください。

デフォルトでは、Swiftは生の値をゼロから始めて毎回1ずつ増加させて割り当てますが、明示的に値を指定することでこの動作を変更できます。上の例では、Aceに明示的に生の値1が与えられ、残りの生の値は順番に割り当てられます。列挙型の生の型として文字列や浮動小数点数を使用することもできます。列挙ケースの生の値にアクセスするにはrawValueプロパティを使用します。

生の値から列挙型のインスタンスを作成するにはinit?(rawValue:)イニシャライザを使用します。生の値に一致する列挙ケース、または一致するRankがない場合はnilを返します。

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

列挙のケース値は実際の値であり、単に生の値を書く別の方法ではありません。実際、意味のある生の値がない場合は、提供する必要はありません。

enum Suit {
    case spades, hearts, diamonds, clubs

    func simpleDescription() -> String {
        switch self {
        case .spades:
            return "spades"
        case .hearts:
            return "hearts"
        case .diamonds:
            return "diamonds"
        case .clubs:
            return "clubs"
        }
    }
}
let hearts = Suit.hearts
let heartsDescription = hearts.simpleDescription()

実験 Suitにcolor()メソッドを追加してください。スペードとクラブには”black”を、ハートとダイヤには”red”を返すようにしてください。

上記で列挙のheartsケースが2つの方法で参照されていることに注目してください：hearts定数に値を代入するとき、定数に明示的な型が指定されていないため、列挙ケースはフルネームSuit.heartsで参照されます。switch内では、selfの値がすでにスーツであることが分かっているため、列挙ケースは省略形.heartsで参照されます。値の型がすでに分かっている場合はいつでも省略形を使用できます。

列挙型に生の値がある場合、それらの値は宣言の一部として決定されます。つまり、特定の列挙ケースのすべてのインスタンスは常に同じ生の値を持ちます。列挙ケースのもう1つの選択肢は、ケースに関連付けられた値を持つことです。これらの値はインスタンスを作成するときに決定され、列挙ケースのインスタンスごとに異なる値を持つことができます。関連値は列挙ケースインスタンスの格納プロパティのように振る舞うと考えることができます。例えば、サーバーから日の出と日没の時刻を要求するケースを考えてみましょう。サーバーは要求された情報で応答するか、何が問題だったかの説明で応答します。

enum ServerResponse {
    case result(String, String)
    case failure(String)
}

let success = ServerResponse.result("6:00 am", "8:09 pm")
let failure = ServerResponse.failure("Out of cheese.")

switch success {
case let .result(sunrise, sunset):
    print("Sunrise is at \(sunrise) and sunset is at \(sunset).")
case let .failure(message):
    print("Failure...  \(message)")
}
// "Sunrise is at 6:00 am and sunset is at 8:09 pm."と出力

実験 ServerResponseとswitchに3番目のケースを追加してください。

日の出と日没の時刻がswitchケースとの一致の一部としてServerResponse値からどのように抽出されているかに注目してください。

構造体を作成するにはstructを使用します。構造体はメソッドやイニシャライザを含め、クラスと同じ動作の多くをサポートします。構造体とクラスの最も重要な違いの1つは、構造体はコード内で渡されるときに常にコピーされますが、クラスは参照で渡されることです。

struct Card {
    var rank: Rank
    var suit: Suit
    func simpleDescription() -> String {
        return "The \(rank.simpleDescription()) of \(suit.simpleDescription())"
    }
}
let threeOfSpades = Card(rank: .three, suit: .spades)
let threeOfSpadesDescription = threeOfSpades.simpleDescription()

実験ランクとスーツの各組み合わせのカードを1枚ずつ含む、完全なカードデッキを含む配列を返す関数を書いてください。

並行処理

非同期で実行される関数をマークするにはasyncを使用します。

func fetchUserID(from server: String) async -> Int {
    if server == "primary" {
        return 97
    }
    return 501
}

非同期関数の呼び出しをマークするには、その前にawaitを書きます。

func fetchUsername(from server: String) async -> String {
    let userID = await fetchUserID(from: server)
    if userID == 501 {
        return "John Appleseed"
    }
    return "Guest"
}

async letを使用して非同期関数を呼び出し、他の非同期コードと並行して実行させます。返された値を使用するときは、awaitを書きます。

func connectUser(to server: String) async {
    async let userID = fetchUserID(from: server)
    async let username = fetchUsername(from: server)
    let greeting = await "Hello \(username), user ID \(userID)"
    print(greeting)
}

同期コードから非同期関数を呼び出すには、Taskを使用します。戻りを待つ必要はありません。

Task {
    await connectUser(to: "primary")
}
// "Hello Guest, user ID 97"と出力。

タスクグループを使用して並行コードを構造化します。

let userIDs = await withTaskGroup(of: Int.self) { group in
    for server in ["primary", "secondary", "development"] {
        group.addTask {
            return await fetchUserID(from: server)
        }
    }

    var results: [Int] = []
    for await result in group {
        results.append(result)
    }
    return results
}

アクターはクラスに似ていますが、異なる非同期関数が同じアクターのインスタンスと同時に安全にやり取りできることを保証します。

actor ServerConnection {
    var server: String = "primary"
    private var activeUsers: [Int] = []
    func connect() async -> Int {
        let userID = await fetchUserID(from: server)
        // ... サーバーと通信 ...
        activeUsers.append(userID)
        return userID
    }
}

アクターのメソッドを呼び出したり、そのプロパティにアクセスしたりするときは、awaitでそのコードをマークして、すでにそのアクターで実行中の他のコードが完了するのを待つ必要があることを示します。

let server = ServerConnection()
let userID = await server.connect()

プロトコルと拡張

プロトコルを宣言するにはprotocolを使用します。

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."
     }
}
var a = SimpleClass()
a.adjust()
let aDescription = a.simpleDescription

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

実験 ExampleProtocolに別の要件を追加してください。SimpleClassとSimpleStructureがまだプロトコルに準拠するようにするには、どのような変更が必要ですか？

SimpleStructureの宣言で、構造体を変更するメソッドをマークするためにmutatingキーワードが使用されていることに注目してください。SimpleClassの宣言では、クラスのメソッドは常にクラスを変更できるため、mutatingとしてマークする必要はありません。

既存の型に新しいメソッドや計算プロパティなどの機能を追加するにはextensionを使用します。拡張を使用して、他の場所で宣言された型、またはライブラリやフレームワークからインポートした型にプロトコル準拠を追加できます。

extension Int: ExampleProtocol {
    var simpleDescription: String {
        return "The number \(self)"
    }
    mutating func adjust() {
        self += 42
    }
 }
print(7.simpleDescription)
// "The number 7"と出力。

実験 absoluteValueプロパティを追加するDouble型の拡張を書いてください。

プロトコル名は他の名前付き型と同様に使用できます。例えば、異なる型を持つがすべて同じプロトコルに準拠するオブジェクトのコレクションを作成できます。ボックス化されたプロトコル型の値を扱うとき、プロトコル定義の外部で定義されたメソッドは使用できません。

let protocolValue: any ExampleProtocol = a
print(protocolValue.simpleDescription)
// "A very simple class.  Now 100% adjusted."と出力
// print(protocolValue.anotherProperty)  // コメントを外すとエラーが表示されます

変数protocolValueのランタイム型はSimpleClassですが、コンパイラはそれを指定された型ExampleProtocolとして扱います。これは、クラスがプロトコル準拠に加えて実装するメソッドやプロパティに誤ってアクセスすることができないことを意味します。

エラーハンドリング

Errorプロトコルを採用する任意の型を使用してエラーを表現します。

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

エラーをスローするにはthrowを使用し、エラーをスローできる関数をマークするにはthrowsを使用します。関数内でエラーをスローすると、関数は即座に戻り、その関数を呼び出したコードがエラーを処理します。

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

エラーを処理するいくつかの方法があります。1つの方法はdo-catchを使用することです。doブロック内で、エラーをスローできるコードの前にtryを書いてマークします。catchブロック内では、別の名前を付けない限り、エラーには自動的にerrorという名前が付けられます。

do {
    let printerResponse = try send(job: 1040, toPrinter: "Bi Sheng")
    print(printerResponse)
} catch {
    print(error)
}
// "Job sent"と出力。

実験プリンター名を"Never Has Toner"に変更して、send(job:toPrinter:)関数がエラーをスローするようにしてください。

特定のエラーを処理する複数のcatchブロックを提供できます。switchのcaseの後と同様に、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)
}
// "Job sent"と出力。

実験 doブロック内にエラーをスローするコードを追加してください。最初のcatchブロックで処理されるには、どのようなエラーをスローする必要がありますか？2番目と3番目のブロックではどうですか？

エラーを処理する別の方法は、try?を使用して結果をオプショナルに変換することです。関数がエラーをスローした場合、具体的なエラーは破棄され、結果はnilになります。それ以外の場合、結果は関数が返した値を含むオプショナルになります。

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

deferを使用して、関数内の他のすべてのコードの後、関数が戻る直前に実行されるコードブロックを書きます。このコードは関数がエラーをスローするかどうかに関係なく実行されます。異なる時間に実行する必要がある場合でも、セットアップコードとクリーンアップコードを隣り合わせに書くために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
}
if fridgeContains("banana") {
    print("Found a banana")
}
print(fridgeIsOpen)
// "false"と出力。

ジェネリクス

山括弧の中に名前を書いて、ジェネリック関数や型を作成します。

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

関数やメソッド、およびクラス、列挙型、構造体のジェネリック形式を作成できます。

// Swift標準ライブラリのオプショナル型を再実装
enum OptionalValue<Wrapped> {
    case none
    case some(Wrapped)
}
var possibleInteger: OptionalValue<Int> = .none
possibleInteger = .some(100)

本体の直前にwhereを使用して、要件のリストを指定します。例えば、型がプロトコルを実装すること、2つの型が同じであること、またはクラスが特定のスーパークラスを持つことを要求します。

func anyCommonElements<T: Sequence, U: Sequence>(_ lhs: T, _ rhs: U) -> Bool
    where T.Element: Equatable, T.Element == U.Element
{
    for lhsItem in lhs {
        for rhsItem in rhs {
            if lhsItem == rhsItem {
                return true
            }
        }
    }
   return false
}
anyCommonElements([1, 2, 3], [3])

実験 anyCommonElements(_:_:)関数を変更して、2つのシーケンスが共通して持つ要素の配列を返す関数にしてください。

<T: Equatable>と書くことは、<T> ... where T: Equatableと書くことと同じです。