ページビューの合計

2026年10月2日金曜日

iOSアプリの開発(100 Days of SwiftUI) Day 15 – Swift review

100 Days of SwiftUIのDay15です。
たった14日間でSwiftについて多くのことを学びましたのが、先に進む前に、学んだことを振り返ることが重要です。

Day15の内容は以下の通りです。

おめでとうございます!
あなたはSwiftプログラミング言語の基礎をすべて習得しました。
各日は、トピックをしっかりと理解してもらうために意図的に短く設定されていましたが、今日はこれまで学習したほぼすべてを復習するので、少し違います。
皆さんが何を考えているかは分かります。「なぜわざわざ?もう学習した内容なのに、なぜもう一度復習する必要があるの?」と思っているでしょう。
しかし、それにはいくつかの理由があります。

  • 繰り返し練習することで、物事をより深く理解することができます。これらの基礎知識は、これから書くSwiftコードすべてにおいて非常に重要なので、しっかりと理解するために、繰り返し練習する価値があります。
  • 概念によっては、他の概念を理解して初めて完全に理解できるものもあります。このように立ち戻って復習することで、Swiftの核心となる概念を頭の中で整理しやすくなります。
  • 何か見落としているかもしれません。正直に言って、あなたは今、Swiftの最も重要な部分に関する膨大な数のビデオを見たばかりです。本当にすべてを覚えている自信がありますか?
  • 自分がどれだけ進歩したか実感できるでしょう。配列やループなど、以前は難しく感じていた内容も、今では簡単に理解できるようになり、着実に進歩していることを実感できるはずです。

もし今日の作業が簡単だと感じたとしても、それはそれで構いません。
この後すぐにSwiftUIプロジェクトが始まり、難易度が上がっていきます。
今の静かな時間を楽しんでください!

今日はチュートリアルを1つだけご覧いただきますが、内容はかなり充実しています。
このチュートリアルでは、これまで取り上げてきたほぼすべてのトピックを、各日のコードサンプルを用いて正確に復習します。
1時間の動画版と、長文のテキスト記事版の2種類をご用意しています。

今日あなたが従うべきチュートリアルはこちらです:1時間でSwiftの基礎を学びましょう。

オプション:記事のレビューが終わったら、レビューページに戻って、上記のトピックに関連するテストを好きなだけ受けることができます。それはあなたの自由です。

ボーナス:Swiftyの単語を見つけよう!

Swift開発者にとって最も役立つ用語の知識をテストするための単語検索問題を作成しました。こちらからPDFファイルをダウンロードできます。もしお困りの場合は、私のSwift用語集をご覧ください。

探すべき単語は数十個あり、単語はあらゆる方向に広がっていく可能性があります。頑張ってください!

この日をより良いものにするにはどうすればよいでしょうか?

今日も一日お疲れ様でした!学習内容についてまだご質問がある場合は、こちらのフォームからお送りください。次回のコースアップデートで、よくあるご質問にお答えできるよう最善を尽くします。ありがとうございました!

それでは、あなたの進捗状況を共有してください…

Twitterをご利用の場合は、下のボタンをクリックすると、本日チャレンジを完了したことを知らせるツイートが作成されます。ツイートには、お祝いの画像、このページのURL、チャレンジのハッシュタグが含まれます。ご安心ください。Twitterで確認するまでツイートは送信されません。


1時間でSwiftの基礎を学ぼう

この記事では、約1時間でSwiftプログラミング言語の基礎をご紹介します。
この記事は、私の「100 Days of SwiftUI」コースの入門編を修了し、簡単な復習を求めている方と、他の言語の経験があり、そのスキルをSwiftに活かしたいと考えている方を対象としています。
これは入門編として設計されているため、速いペースで進めていきます。
もし理解に苦しむ点があれば、「100 Days of SwiftUI」にアクセスして、より長く詳細な入門編をご覧ください。
さあ、始めましょう!

定数と変数の作成

Swiftでは定数と変数を作成できますが、一般的には定数の方が推奨されます。変数文字列を作成して変更するには、以下を使用します。
var name = "Ted"
name = "Rebecca"

値を変更したくない場合は、代わりに定数を使用してください。
let user = "Daphne"

print() 関数は学習やデバッグに役立ち、変数に関する情報を表示します。
print(user)


Strings

Swiftの文字列は二重引用符で始まり、二重引用符で終わります。
let actor = "Tom Cruise"

絵文字との相性も抜群です
let actor = "Tom Cruise 🏃‍♂️"

文字列の中に二重引用符を入れたい場合は、引用符の前にバックスラッシュを付けてください。
let quote = "He tapped a sign saying \"Believe\" and walked away."

複数行にわたる文字列が必要な場合は、次のように、文字列の最初と最後に二重引用符を3つずつ付けます。

let movie = """
A day in
the life of an
Apple engineer
"""

Swiftには、文字列の文字数を読み取るための`.count`など、文字列に関する多くの便利なプロパティとメソッドが用意されています。

print(actor.count)

文字列が特定の文字で始まるか終わるかを知るには、hasPrefix() と hasSuffix() という関数もあります。

print(quote.hasPrefix("He"))
print(quote.hasSuffix("Away."))

重要:Swiftでは文字列は大文字と小文字を区別するため、2番目のチェックはfalseを返します。


Integers

Swiftでは、整数はInt型を使用して格納され、この型はさまざまな標準的な数学演算子をサポートしています。

let score = 10
let higherScore = score + 10
let halvedScore = score / 2

また、変数をその場で変更する複合代入演算子もサポートしています。

var counter = 10
counter += 5

整数には、isMultiple(of:) メソッドなど、独自の便利な機能が備わっています。

let number = 120
print(number.isMultiple(of: 3))

特定の範囲内のランダムな整数を生成することもできます。例えば、次のようにします。

let id = Int.random(in: 1...1000)


Decimals

小数点を含む数値を作成すると、Swift はそれを Double 型とみなします。

let score = 3.0

Swiftでは、Double型はInt型とは全く異なるデータ型とみなされ、両者を混在させることはできません。


Booleans

Swiftでは、真偽値を格納するためにBool型を使用します。

let goodDogs = true
let gameOver = false

ブール値をtrueからfalseに切り替えるには、toggle()メソッドを呼び出します。

var isSaved = false
isSaved.toggle()


Stringの結合

文字列補間を使用すると、他のデータから文字列を作成できます。文字列の中にバックスラッシュを書き込み、括弧の中に変数名または定数名を記述します。

let name = "Taylor"
let age = 26
let message = "I'm \(name) and I'm \(age) years old."
print(message)

そのコードを実行すると、「I'm Taylor and I'm 26 years old.」と表示されます。


Arrays

アイテムを配列にグループ化するには、次のようにします。

var colors = ["Red", "Green", "Blue"]
let numbers = [4, 8, 15, 16]
var readings = [0.1, 0.5, 0.8]

それぞれの配列には、文字列、整数、小数といった異なる種類のデータが格納されています。配列からデータを読み取ると、文字列、整数、倍精度浮動小数点数といった適切な型が返されます。

print(colors[0])
print(readings[2])

ヒント:要求しているインデックスにアイテムが存在することを確認してください。そうでない場合、コードがクラッシュし、アプリが動作しなくなります。

配列が可変の場合は、append() を使用して新しい項目を追加できます。

colors.append("Tartan")

追加するデータの種類は、既にそこに格納されているデータの種類と一致していなければなりません。
配列には、配列内の要素数を読み取る`.count`や、特定のインデックスにある要素を削除する`remove(at:)`など、便利な機能があります。
colors.remove(at: 0)
print(colors.count)
配列に特定の項目が含まれているかどうかは、次のように contains() 関数を使って確認できます。
print(colors.contains("Octarine"))


Dictionaries

辞書は、指定したキーに基づいて複数の値を格納します。例えば、人物に関する情報を格納する辞書を作成できます。
let employee = [
    "name": "Taylor",
    "job": "Singer"
]

辞書からデータを読み取るには、辞書を作成したときに使用したのと同じキーを使用します。
print(employee["name", default: "Unknown"])
print(employee["job", default: "Unknown"])

要求したキーが存在しない場合は、デフォルト値("Unknown")が使用されます。


Sets

セットは配列に似ていますが、重複する要素を追加できない点と、要素を特定の順序で格納しない点が異なります。
これにより、一連の数値が生成されます。
var numbers = Set([1, 1, 3, 5, 7])
print(numbers)
セットは重複する値を無視し、配列で使用された順序を記憶しないことに注意してください。
上記でnumbersに格納するのは、[1, 3, 5, 7]です。またこの順序は記憶しません。

セットにアイテムを追加するには、次のようにinsert()メソッドを呼び出します。
numbers.insert(10)

セットには配列に比べて大きな利点が1つあります。それは、セットに対してcontains()を使用すると、セットに含まれるアイテムの数に関係なく、実質的に瞬時に処理が完了することです。10,000,000個のアイテムを含むセットでも、瞬時に応答します。

追記

  • 重複を許さず、順序も保持しない。
  • データの追加には、insert()を使用する。
  • contains()による処理が瞬時に応答する。
RDBの挙動に似ていますね。
Set は内部でハッシュテーブル(Hash Table)という仕組みを使っています。
そのため、10,000,000個のアイテムからでも一瞬で対象のデータを見つけることができます。


Enums

列挙型(enum)とは、コードの効率性と安全性を高めるために作成・使用できる、名前付きの値の集合です。
例えば、曜日を表す列挙型を次のように作成できます。
enum Weekday {
    case monday, tuesday, wednesday, thursday, friday
}
これは新しい列挙型「Weekday」を呼び出し、5つの曜日を処理するための5つのケースを提供します
これで、その列挙型のインスタンスを作成し、他の可能なケースを割り当てることができます。
var day = Weekday.monday
day = .friday


型注釈

次のような型注釈を使用することで、新しい変数や定数に特定の型を強制的に指定することができます。
var score: Double = 0
: Double の部分がないと Swift はそれを Int だと推測しますが、それを上書きして Double だと指定しています。

これまでに説明した型に基づいた型注釈をいくつか紹介します。
let player: String = "Roy"
var luckyNumber: Int = 13
let pi: Double = 3.141
var isEnabled: Bool = true
var albums: Array<String> = ["Red", "Fearless"]
var user: Dictionary<String, String> = ["id": "@twostraws"]
var books: Set<String> = Set(["The Bluest Eye", "Foundation"])

配列と辞書は非常に一般的であるため、記述を容易にするための特別な構文が用意されています。
var albums: [String] = ["Red", "Fearless"]
var user: [String: String] = ["id": "@twostraws"]

空のコレクションを作成するには、オブジェクトの正確な型を知ることが重要です。
たとえば、次の2つはどちらも空の文字列配列を作成します。
var teams: [String] = [String]()
var clues = [String]()

列挙型の値は列挙型自体と同じ型なので、次のように記述できます。
enum UIStyle {
    case light, dark, system
}

var style: UIStyle = .light


Conditions

if、else、else if 文を使用して条件をチェックし、必要に応じてコードを実行します。
let age = 16

if age < 12 {
    print("You can't vote")
} else if age < 18 {
    print("You can vote soon.")
} else {
    print("You can vote now.")
}

&& を使用すると、2 つの条件を組み合わせることができ、全体の条件は、内部の 2 つの条件が両方とも真である場合にのみ真となります。
let temp = 26

if temp > 20 && temp < 30 {
    print("It's a nice day.")
}
あるいは、|| は、いずれかのサブ条件が真であれば条件を真とします。


Switch文

Swiftでは、次のようにswitch/case構文を使用して、複数の条件に対して値をチェックできます。
enum Weather {
    case sun, rain, wind
}

let forecast = Weather.sun

switch forecast {
case .sun:
    print("A nice day.")
case .rain:
    print("Pack an umbrella.")
default:
    print("Should be okay.")
}
switch文は網羅的でなければなりません。
考えられるすべての値を処理しなければ、うっかり見落とすことはありません。

追記
Swiftのswitch文にはbreak文がありません。
条件にマッチした case の処理が終わったら自動で switch を抜けます。
もし他言語の break を書かない挙動(フォールスルー)を再現したい場合は、明示的に fallthrough キーワードを書きます。


三項条件演算子

三項演算子を使うと、条件をチェックして、条件が真の場合は何らかの値、偽の場合は何らかの値を返すことができます。
let age = 18
let canVote = age >= 18 ? "Yes" : "No"
このコードが実行されると、年齢が18歳に設定されているため、canVoteは「Yes」に設定されます。


ループ

Swiftのforループは、コレクション内の各項目、またはカスタム範囲内の各項目に対してコードを実行します。
let platforms = ["iOS", "macOS", "tvOS", "watchOS"]

for os in platforms {
    print("Swift works on \(os).")
}
数値の範囲をループ処理することもできます。
for i in 1...12 {
    print("5 x \(i) is \(5 * i)")
}
1...12 には 1 から 12 までの値が含まれます。最後の数値を除外したい場合は、代わりに ..< を使用してください。
var lyric = "Haters gonna"

for _ in 1...5 {
    lyric += " hate"
}

print(lyric)
また、条件が偽になるまでループ本体を実行するwhileループもあります。例えば、次のようになります。
var count = 10

while count > 0 {
    print("\(count)…")
    count -= 1
}

print("Go!")
continue を使用すると、現在のループの反復処理をスキップして、次の反復処理に進むことができます。
let files = ["me.jpg", "work.txt", "sophie.jpg"]

for file in files {
    if file.hasSuffix(".jpg") == false {
        continue
    }

    print("Found picture: \(file)")
}
あるいは、break を使用してループを終了し、残りのすべての反復処理をスキップすることもできます。


関数

新しい関数を作成するには、`func` の後に関数名を記述し、括弧内にパラメータを追加します。
func printTimesTables(number: Int) {
    for i in 1...12 {
        print("\(i) x \(number) is \(i * number)")
    }
}

printTimesTables(number: 5)
パラメータ名は関数呼び出しの一部であるため、呼び出し箇所に番号「5」を記述する必要があります。

関数からデータを返すには、Swiftにその関数の型を伝え、returnキーワードを使って返します。例えば、これはサイコロの出目を返します。
func rollDice() -> Int {
    return Int.random(in: 1...6)
}

let result = rollDice()
print(result)

関数にコードが1行しかない場合は、returnキーワードを削除できます。
func rollDice() -> Int {
    Int.random(in: 1...6)
}


関数から複数の値を返す

タプルは特定の型の値を固定数格納するもので、関数から複数の値を返すのに便利な方法です。
func getUser() -> (firstName: String, lastName: String) {
    (firstName: "Taylor", lastName: "Swift")
}

let user = getUser()
print("Name: \(user.firstName) \(user.lastName)")
タプルのすべての値が必要ない場合は、タプルを分割代入して個々の値に分け、その後 _ を付けて Swift に一部の値を無視するように指示します。
let (firstName, _) = getUser()
print("Name: \(firstName)")


パラメータラベルのカスタマイズ

関数呼び出し時に引数名を渡したくない場合は、引数名の前にアンダースコアを付けます。
func isUppercase(_ string: String) -> Bool {
    string == string.uppercased()
}

let string = "HELLO, WORLD"
let result = isUppercase(string)

別の方法としては、最初の名前の前に2番目の名前を書くという方法があります。
1つは外部で使用するため、もう1つは内部で使用するためです。
func printTimesTables(for number: Int) {
    for i in 1...12 {
        print("\(i) x \(number) is \(i * number)")
    }
}

printTimesTables(for: 5)
このコードでは、for は外部で使用され、number は内部で使用されます。


パラメータにデフォルト値を設定する

デフォルトのパラメータ値を指定するには、型の後に等号を記述し、次に値を指定します。
func greet(_ person: String, formal: Bool = false) {
    if formal {
        print("Welcome, \(person)!")
    } else {
        print("Hi, \(person)!")
    }
}

greet() 関数は、次の2つの方法で呼び出すことができます。
greet("Tim", formal: true)
greet("Taylor")


関数のエラー処理

関数内のエラーを処理するには、Swiftにどのようなエラーが発生する可能性があるかを伝え、エラーをスローする関数を作成し、それを呼び出して問題を処理する必要があります。
まず、発生する可能性のあるエラーを定義します。
enum PasswordError: Error {
    case short, obvious
}

次に、エラーをスローできる関数を作成します。
これは、関数の型にthrowsを記述し、throw を使って特定のエラーを発生(スロー)することで実現できます。
func checkPassword(_ password: String) throws -> String {
    if password.count < 5 {
        throw PasswordError.short
    }

    if password == "12345" {
        throw PasswordError.obvious
    }

    if password.count < 10 {
        return "OK"
    } else {
        return "Good"
    }
}

次に、doブロックを開始し、tryを使用して関数を呼び出し、発生したエラーをキャッチすることで、スローする関数を呼び出します。
let string = "12345"

do {
    let result = try checkPassword(string)
    print("Rating: \(result)")
} catch PasswordError.obvious {
    print("I have the same combination on my luggage!")
} catch {
    print("There was an error.")
}

エラーを捕捉する際には、あらゆる種類のエラーを処理できるcatchブロックを必ず用意する必要があります。


クロージャ

定数や変数に機能を直接割り当てるには、次のようにします。
let sayHello = {
    print("Hi there!")
}

sayHello()

このコードでは、sayHello はクロージャです。
クロージャとは、受け渡ししていつでも呼び出すことができるコードの塊です。
クロージャがパラメータを受け取るようにするには、パラメータを中括弧の中に記述する必要があります。
let sayHello = { (name: String) -> String in
    "Hi \(name)!"
}
「in」は、パラメータと戻り値の型の終わりを示すために使用されます。それ以降のすべてがクロージャ本体です。

Swiftではクロージャが広く使われています。
例えば、filter()という配列メソッドは、配列のすべての要素に対してテストを実行し、テストでtrueを返した要素を新しい配列に格納して返します。

クロージャを使用してそのテストを実行できるため、配列をフィルタリングして、Tで始まる名前のみを含めることができます。
let team = ["Gloria", "Suzanne", "Tiffany", "Tasha"]

let onlyT = team.filter({ (name: String) -> Bool in
    return name.hasPrefix("T")
})

クロージャ内部では、filter() 関数から渡されるパラメータ(配列からの文字列)をリストします。また、クロージャがブール値を返すことを指定し、in を使用してクロージャのコードの開始を示します。
その後は、通常の関数コードになります。


末尾クロージャと省略構文

Swiftには、クロージャを読みやすくするためのいくつかの工夫があります。
以下は、配列から「T」で始まる名前のみを抽出するコードです。
let team = ["Gloria", "Suzanne", "Tiffany", "Tasha"]

let onlyT = team.filter({ (name: String) -> Bool in
    return name.hasPrefix("T")
})

print(onlyT)

すぐに分かるように、クロージャの本体にはコードが1行しかないので、returnを削除できます。
let onlyT = team.filter({ (name: String) -> Bool in
    name.hasPrefix("T")
})

filter() には、配列から 1 つの項目を受け取り、返される配列に含めるべき項目であれば true を返す関数を指定する必要があります。

渡す関数はそのような動作をしなければならないため、クロージャ内で型を指定する必要はありません。したがって、コードは次のように書き換えることができます。
let onlyT = team.filter({ name in
    name.hasPrefix("T")
})

さらに、末尾クロージャ構文と呼ばれる特殊な構文を使うと、より詳細な説明が可能になります。末尾クロージャ構文は次のようになります。
let onlyT = team.filter { name in
    name.hasPrefix("T")
}

最後に、Swift は短いパラメータ名を提供してくれるので、名前を記述する必要がなくなり、代わりに特別に名前が付けられた値 $0 に頼ることができます。
let onlyT = team.filter {
    $0.hasPrefix("T")
}


構造体

構造体を使うと、独自のプロパティとメソッドを備えた独自のカスタムデータ型を作成できます。
struct Album {
    let title: String
    let artist: String
    var isReleased = true

    func printSummary() {
        print("\(title) by \(artist)")
    }
}

let red = Album(title: "Red", artist: "Taylor Swift")
print(red.title)
red.printSummary()

構造体のインスタンスを作成する際には、イニシャライザを使用します。
Swiftでは、構造体を関数のように扱い、各プロパティに対応するパラメータを渡すことができます。
Swiftは、構造体のプロパティに基づいて、メンバーごとのイニシャライザを自動的に生成します。

構造体のメソッドでそのプロパティのいずれかを変更したい場合は、そのメソッドをミューテーション(変更可能)として、"mutating"でマークします。
mutating func removeFromSale() {
    isReleased = false
}


計算プロパティ

計算プロパティは、アクセスされるたびにその値を計算します。
たとえば、従業員の残りの休暇日数を追跡する Employee 構造体を作成できます。
struct Employee {
    let name: String
    var vacationAllocated = 14
    var vacationTaken = 0

    var vacationRemaining: Int {
        vacationAllocated - vacationTaken
    }
}

vacationRemainingに書き込むためには、ゲッターとセッターの両方を提供する必要があります。
var vacationRemaining: Int {
    get {
        vacationAllocated - vacationTaken
    }

    set {
        vacationAllocated = vacationTaken + newValue
    }
}

newValueはSwiftによって提供され、ユーザーがプロパティに割り当てていた値を格納します。


プロパティオブサーバ

プロパティオブザーバーとは、プロパティが変更されたときに実行されるコードのことです。didSetはプロパティが変更された直後に実行され、willSetはプロパティが変更される前に実行されます。
スコアが変更されたときにGame構造体がメッセージを出力するようにすることで、didSetの動作を実証できます。
struct Game {
    var score = 0 {
        didSet {
            print("Score is now \(score)")
        }
    }
}

var game = Game()
game.score += 10
game.score -= 3


カスタムイニシャライザ

イニシャライザは、新しい構造体インスタンスを使用するための準備を行う特別な関数であり、すべてのプロパティに初期値が設定されていることを保証します。
Swiftは構造体のプロパティに基づいて生成しますが、独自の構造体を作成することもできます。
struct Player {
    let name: String
    let number: Int

    init(name: String) {
        self.name = name
        number = Int.random(in: 1...99)
    }
}

重要:イニシャライザには'func'が前に付いておらず、明示的に値を返しません。



アクセスコントロール

Swiftには構造体内部のアクセス制御に関していくつかの選択肢がありますが、最も一般的なのは次の4つです。

  • 「構造体外部の何物にもこれを使用させない」場合は、private を使用してください。
  • 「構造体の外部からでも読み取れるが、変更はできない」という場合は、private(set)を使用してください。
  • fileprivate は、「現在のファイル以外のものにはこのファイルを使用させない」ために使用します。
  • 「誰でも、どこからでも使えるようにする」という意味で「public」を使用します。
struct BankAccount {
    private(set) var funds = 0

    mutating func deposit(amount: Int) {
        funds += amount
    }

    mutating func withdraw(amount: Int) -> Bool {
        if funds > amount {
            funds -= amount
            return true
        } else {
            return false
        }
    }
}
private(set)を使用しているため、構造体の外からfundsを読み取ることはできますが、書き込みはできません。


静的なプロパティとメソッド

Swiftは静的プロパティとメソッドをサポートしており、構造体のインスタンスではなく、構造体自体にプロパティやメソッドを直接追加できます。
struct AppData {
    static let version = "1.3 beta 2"
    static let settings = "settings.json"
}

この方法を使えば、アプリのバージョン番号などを確認したり表示したりする必要がある場所ならどこでも、AppData.version を読み取ることができます。


クラス

クラスを使うとカスタムデータ型を作成でき、構造体とは以下の5つの点で異なります。
まず第一の違いは、他のクラスから機能を継承することでクラスを作成できる点です。
class Employee {
    let hours: Int

    init(hours: Int) {
        self.hours = hours
    }

    func printSummary() {
        print("I work \(hours) hours a day.")
    }
}

class Developer: Employee {
    func work() {
        print("I'm coding for \(hours) hours.")
    }
}

let novall = Developer(hours: 8)
novall.work()
novall.printSummary()

子クラスが親クラスのメソッドを変更したい場合は、override を使用する必要があります。
override func printSummary() {
    print("I spend \(hours) hours a day searching Stack Overflow.")
}

2つ目の違いは、クラスの場合、イニシャライザがより複雑になるということです。
ここには多くの複雑さがありますが、重要なポイントは3つあります。
  1. Swiftはクラスに対してメンバーごとのイニシャライザを生成しません。
  2. 子クラスが独自のイニシャライザを持つ場合、子クラスは自身のプロパティの設定が完了した後、必ず親クラスのイニシャライザを呼び出す必要があります。
  3. サブクラスにイニシャライザがない場合、親クラスのいにを自動的に継承します。
class Vehicle {
    let isElectric: Bool

    init(isElectric: Bool) {
        self.isElectric = isElectric
    }
}

class Car: Vehicle {
    let isConvertible: Bool

    init(isElectric: Bool, isConvertible: Bool) {
        self.isConvertible = isConvertible
        super.init(isElectric: isElectric)
    }
}
superを使うと、親クラスのいになど、親クラスに属するメソッドを呼び出すことができます。
3つ目の違いは、クラスインスタンスのすべてのコピーがデータを共有するということです。つまり、1つのコピーに変更を加えると、他のコピーも自動的に変更されます。
class Singer {
    var name = "Adele"
}

var singer1 = Singer()
var singer2 = singer1
singer2.name = "Justin"
print(singer1.name)  
print(singer2.name)
これにより、両方とも「Justin」と表示されます。片方だけを変更した場合でも、もう片方も変更されているからです。
これに対し、構造体のコピーはデータを共有しません。

4つ目の違いは、クラスにはオブジェクトへの最後の参照が破棄されたときに呼び出されるデイニシャライザを持つことができる点です。
そこで、作成時と破棄時にメッセージを表示するクラスを作成することができます。
class User {
    let id: Int

    init(id: Int) {
        self.id = id
        print("User \(id): I'm alive!")
    }

    deinit {
        print("User \(id): I'm dead!")
    }
}

for i in 1...3 {
    let user = User(id: i)
    print("User \(user.id): I'm in control!")
}

最後の違いは、クラス自体が定数であっても、クラスでは変数のプロパティを変更できる点です。
class User {
    var name = "Paul"
}

let user = User()
user.name = "Taylor"
print(user.name)
その結果、クラスはデータを変更するメソッドを持つ場合でも、mutatingキーワードを必要としません


プロトコル

プロトコルは、データ型がサポートすることを期待される機能を定義し、Swiftはコードがそれらのルールに従うことを保証します。
例えば、車両プロトコルを次のように定義できます。
protocol Vehicle {
    func estimateTime(for distance: Int) -> Int
    func travel(distance: Int)
}

これは、このプロトコルが機能するために必要なメソッドを一覧にしたものですが、コードは含まれていません。メソッド名、パラメータ、および戻り値の型のみを指定しています。
プロトコルが確立されたら、必要な機能を実装することで、データ型をそのプロトコルに準拠させることができます。
例えば、Vehicle に準拠する Car 構造体を作成できます。
struct Car: Vehicle {
    func estimateTime(for distance: Int) -> Int {
        distance / 50
    }

    func travel(distance: Int) {
        print("I'm driving \(distance)km.")
    }
}
Vehicle に記載されているすべてのメソッドは、Car にも全く同じ名前、パラメータ、および戻り値の型で存在しなければなりません。

これで、Vehicleに準拠するあらゆる型を受け入れる関数を作成できるようになりました。なぜなら、SwiftはそれがestimateTime()とtravel()の両方を実装していることを認識しているからです。
func commute(distance: Int, using vehicle: Vehicle) {
    if vehicle.estimateTime(for: distance) > 100 {
        print("Too slow!")
    } else {
        vehicle.travel(distance: distance)
    }
}

let car = Car()
commute(distance: 100, using: car)

プロトコルではプロパティを要求することもできるため、車両の座席数や現在の乗客数に関するプロパティを要求することも可能です。
protocol Vehicle {
    var name: String { get }
    var currentPassengers: Int { get set }
    func estimateTime(for distance: Int) -> Int
    func travel(distance: Int)
}

これにより、2つのプロパティが追加されます。1つはgetでマークされたプロパティで、定数または計算プロパティである可能性があります。
もう1つはget setでマークされたプロパティで、変数またはゲッターとセッターを持つ計算プロパティである可能性があります。

これで、すべての準拠型は、Car の場合のように、これら 2 つのプロパティの実装を追加する必要があります。
let name = "Car"
var currentPassengers = 1

ヒント:必要なプロトコルはいくつでも、カンマで区切って列挙するだけで準拠できます。


拡張機能

拡張機能を使うと、あらゆる型に機能を追加できます。
例えば、Swiftの文字列には空白や改行を削除するメソッドがありますが、かなり長いため、これを拡張機能にすることができます。
extension String {
    func trimmed() -> String {
        self.trimmingCharacters(in: .whitespacesAndNewlines)
    }
}

var quote = "   The truth is rarely pure and never simple   "
let trimmed = quote.trimmed()

新しい値を返すのではなく、値を直接変更したい場合は、次のようにメソッドをミューテーションメソッドとしてマークします。
extension String {
    mutating func trim() {
        self = self.trimmed()
    }
}

quote.trim()

拡張機能は、次のような計算プロパティを型に追加することもできます。
extension String {
    var lines: [String] {
        self.components(separatedBy: .newlines)
    }
}
components(separatedBy:) メソッドは、指定した境界(この場合は改行)を使用して文字列を文字列の配列に分割します。

これで、そのプロパティをすべての文字列で使用できるようになりました。
let lyrics = """
But I keep cruising
Can't stop, won't stop moving
"""

print(lyrics.lines.count)


プロトコル拡張

プロトコル拡張は、プロトコル全体を拡張して計算プロパティとメソッドの実装を追加するものであり、そのプロトコルに準拠するすべての型がそれらを利用できるようになります。

例えば、配列、辞書、セットはすべてコレクションプロトコルに準拠しているため、次のようにして3つすべてに計算プロパティを追加できます。
extension Collection {
    var isNotEmpty: Bool {
        isEmpty == false
    }
}

さあ、これで活用できます。
let guests = ["Mario", "Luigi", "Peach"]

if guests.isNotEmpty {
    print("Guest count: \(guests.count)")
}

このアプローチでは、プロトコルで必須メソッドを列挙し、プロトコル拡張内でそれらのデフォルト実装を追加できます。準拠するすべての型は、これらのデフォルト実装を使用するか、必要に応じて独自の実装を提供できます。


オプショナル

オプショナル型はデータの欠如を表します。例えば、値が0の整数と、値がまったくない整数を区別します。
オプショナル型が実際にどのように機能するかを確認するには、次のコードを考えてみてください。
let opposites = [
    "Mario": "Wario",
    "Luigi": "Waluigi"
]

let peachOpposite = opposites["Peach"]

これは「Peach」というキーに紐づけられた値を読み取ろうとしていますが、そのような値は存在しないため、通常の文字列として扱うことはできません。
Swiftでは、この問題を解決するためにオプショナル型と呼ばれる仕組みを採用しています。オプショナル型とは、存在する場合と存在しない場合があるデータを扱うことを意味します。

オプショナル文字列には、内部に文字列が格納されている場合もあれば、何も格納されていない場合もあります。後者は「値なし」を意味するnilと呼ばれる特殊な値です。
Int、Double、Boolなどの型、および列挙型、構造体、クラスのインスタンスなど、あらゆる種類のデータがオプショナルになります。

Swiftでは、オプショナルデータを直接使用することはできません。
なぜなら、オプショナルデータは空である可能性があるからです。
つまり、オプショナルを使用するには、それをアンラップする必要があります。つまり、内部を調べて値があるかどうかを確認し、値があれば取​​り出して使用する必要があります。

Swiftではオプショナル型をアンラップする方法がいくつかありますが、最もよく見かけるのは次のようになります。
if let marioOpposite = opposites["Mario"] {
    print("Mario's opposite is \(marioOpposite)")
}

これは辞書からオプショナルの値を読み取り、その中に文字列が含まれている場合は、その文字列をアンラップします。
つまり、文字列はmarioOpposite定数に格納され、もはやオプションではなくなります。オプションをアンラップできたため、条件は成功となり、print()コードが実行されます。


ガード付きオプショナルのアンラップ

Swiftには、オプショナルをアンラップする2つ目の方法であるguard letがあります。
これはif letと非常によく似ていますが、動作が逆になっています。
if letはオプショナルに値がある場合に中括弧内のコードを実行し、guard letはオプショナルに値がない場合に中括弧内のコードを実行します。
func printSquare(of number: Int?) {
    guard let number = number else {
        print("Missing input")
        return
    }

    print("\(number) x \(number) is \(number * number)")
}
関数の入力値が有効かどうかをチェックするためにガードを使用する場合、チェックが失敗した場合は Swift では return を使用する必要があります。
ただし、アンラップするオプショナル型に値が含まれている場合は、ガードコードの実行後にその値を使用できます。

ヒント:guard は、オプショナルをアンラップしない条件を含め、あらゆる条件で使用できます。


nil合体演算子

Swiftには、オプショナルをアンラップする3つ目の方法があり、それはnil合体演算子と呼ばれています。これはオプショナルをアンラップし、オプショナルが空だった場合にデフォルト値を提供します。
let tvShows = ["Archer", "Babylon 5", "Ted Lasso"]
let favorite = tvShows.randomElement() ?? "None"

nil合体演算子は、オプショナル型が作成される多くの場面で役立ちます。
例えば、文字列から整数型を作成すると、変換が失敗する可能性があるため、オプショナル型のInt?が返されます。
ここでnil合体演算子を使用してデフォルト値を指定できます。
let input = ""
let number = Int(input) ?? 0
print(number)


オプショナルチェイニング

オプショナルチェイニングは、オプショナルの中にオプショナルを読み込むことで、次のように動作します。
let names = ["Arya", "Bran", "Robb", "Sansa"]
let chosen = names.randomElement()?.uppercased()
print("Next in line: \(chosen ?? "No one")")
2行目にはオプショナルチェイニングがあります。
疑問符の後にコードが続きます。オプショナルチェイニングを使うと、「オプショナルに値が入っている場合は、それを展開してから…」と指定して、さらにコードを追加できます。この例では、「配列からランダムに要素を取得した場合は、それを大文字にする」と指定しています。


オプショナルtry?

エラーが発生する可能性のある関数を呼び出す場合、try? を使用して、成功した場合は値を含むオプショナル型に、そうでない場合は nil に変換できます。
enum UserError: Error {
    case badID, networkFailed
}

func getUser(id: Int) throws -> String {
    throw UserError.networkFailed
}

if let user = try? getUser(id: 23) {
    print("User: \(user)")
}

getUser() 関数は常に networkFailed をスローしますが、何がスローされたかは重要ではありません。重要なのは、呼び出しがユーザーを返したかどうかだけです。


まとめ

ここではSwift言語の基本事項のほとんどを網羅しましたが、実際にはこの言語の機能のごく一部に触れたに過ぎません。
幸いなことに、これまでに学んだ知識があれば、SwiftとSwiftUIを使って素晴らしいソフトウェアを開発するのに十分な知識を既に身につけているはずです。

学習を続けたい方は、私が提供する「100 Days of SwiftUI」コースをぜひ受講してみてください。
このコースでは、Swiftを使ってiOS向けの素晴らしいアプリを開発する方法を学ぶことができます。
すべて無料で、数百もの動画も用意されています。



0 件のコメント:

コメントを投稿

iOSアプリの開発(100 Days of SwiftUI) Day 26 – Project 4, part one

100 Days of SwiftUIの Day26 です。 今日から新しいプロジェクトを始めます。SwiftUIのスキルをさらに磨きながら、プログラミングの魅力的な分野である機械学習にも挑戦していきます。 オックスフォード大学で教鞭を執るスウェーデン人教授、ニック・ボストロムは...