Swift 5.8 日本語化計画　: Swift 5.8

フロー制御

分岐、ループ、および早期終了を含む構造コード。

Swift は様々なフロー制御文を提供しています。これらはタスクを複数回実行できる while ループを含み、 if、guard と switch 文は、一定の条件に基づいてコードの異なる分岐を実行し、そして break や continue のような文は、コード内の別のポイントに実行のフローを転送します。

Swift は for-in ループも提供し、それによって簡単に、配列、dictionary、範囲、文字列、および他のシーケンスを反復処理できます。

Swift の switch 文も、対応する多くの C に似た言語よりもとても強力と考えられます。Case は、間隔の一致、タプル、特定の型へのキャストなどを含む、さまざまなパターンに一致する事ができます。switch のケース内の一致した値は、case の本体内で使用するための一時的な定数または変数に結合することができ、複雑な一致条件は、それぞれの case について where 句で表すことができます。

For-In ループ

配列内の項目、数字の範囲、または文字列内の文字のような、シーケンスを反復処理するため for-in ループを使用して下さい。

以下の例では for-in ループを使用して、配列内の項目を反復処理します。

let names = ["Anna", "Alex", "Brian", "Jack"]

for name in names {

print("Hello, \(name)!")

}

// Hello, Anna!

// Hello, Alex!

// Hello, Brian!

// Hello, Jack!

また、dictionary を繰り返し処理して、そのキー値のペアにアクセスすることもできます。dictionary が反復処理されるときに dictionary の各項目は (key, value) タプルとして返され、for-in ループの本体内で使用する明示的に名前が付けられた定数として (key, value) タプルのメンバーを分解できます。以下のコード例では、dictionary のキーは animalName という定数に分解され、dictionary の値は legCount という定数に分解されます。

let numberOfLegs = ["spider": 8, "ant": 6, "cat": 4]

for (animalName, legCount) in numberOfLegs {

print("\(animalName)s have \(legCount) legs")

}

// cats have 4 legs

// ants have 6 legs

// spiders have 8 legs

Dictionary の内容は本質的に順序付けされておらず、それらを反復処理しても、それらが取得される順序は保証されません。特に、Dictionary に項目を挿入する順序は、それらが反復処理される順序を定義しません。配列と dictionary の詳細については、コレクション型を参照してください。

数値範囲で for-in ループを使用することもできます。以下の例では、５倍の表の最初のいくつかのエントリを印刷します。

for index in 1...5 {

print("\(index) times 5 is \(index * 5)")

}

// 1 times 5 is 5

// 2 times 5 is 10

// 3 times 5 is 15

// 4 times 5 is 20

// 5 times 5 is 25

閉鎖範囲演算子(...)の使用によって示される、反復処理されるシーケンスは、1 から 5 の数値の範囲です。index の値は、範囲内の最初の数(1)に設定され、ループ内の文が実行されます。この場合、ループは、index の現在値の５倍の表からエントリを印刷する、一つの文だけを含んでいます。文が実行された後、index の値は範囲の 2 番目の値(2)を含むように更新され、print(_:separator:terminator:) 関数が再び呼び出されます。範囲の最後に到達するまで、このプロセスが続きます。

上記の例では、index は、その値がそれぞれのループの繰り返しの開始時に自動的に設定される定数です。このように、index は使用される前に宣言する必要はありません。これは、let 宣言キーワードを必要とせずに、ループ宣言内でそれを含むことにより、簡単に暗黙的に宣言されます。

シーケンスからの各々の値を必要としない場合は、変数名の代わりにアンダースコアを使用して、値を無視できます。

let base = 3

let power = 10

var answer = 1

for _ in 1...power {

answer *= base

}

print("\(base) to the power of \(power) is \(answer)")

// prints "3 to the power of 10 is 59049"

上記の例では、1つの数値に別の数を累乗した値を計算(この場合は 3 の10 乗)します。これは、1(すなわち 3 の 0 乗) から始まり、１０回、1 から始まり 10 で終わる閉鎖範囲を使用して 3 を乗算します。この計算では、個々のカウンタ値は各々の回のループ中には必要はなく、コードは単にループを正しい回数実行する必要があります。アンダースコア文字 (_)はループ変数の代わりに使用され、個々の値は無視され、ループの各繰り返し中に現在値へのアクセスを提供しません。

状況によっては、両方の端を含む閉じた範囲を使用したくない場合もあります。時計盤上に 1 分ごとに目盛りを描くことを考えてください。0 分から開始して 60 目盛りを描きたいとします。下限を含めるが上限は含まない半開放範囲演算子(..<) を使用して下さい。範囲の詳細については、範囲演算子を参照してください。

let minutes = 60

for tickMark in 0..<minutes {

// render the tick mark each minute (60 times)

}

一部のユーザーは、彼らの UI で目盛りの数を減らしたいと思うかも知れません。代わりに 5 分ごとに 1 つのマークを好むかも知れません。stride(from:to:by:) 関数を使用して、不要なマークをスキップしましょう。

let minuteInterval = 5

for tickMark in stride(from: 0, to: minutes, by: minuteInterval) {

// render the tick mark every 5 minutes (0, 5, 10, 15 ... 45, 50, 55)

}

stride(from:through:by:) を代わりに使用すると、閉じた範囲も使用できます。

let hours = 12

let hourInterval = 3

for tickMark in stride(from: 3, through: hours, by: hourInterval) {

// render the tick mark every 3 hours (3, 6, 9, 12)

}

上記の例では、for-in ループを使用して、範囲、配列、辞書、および文字列を反復処理しています。ただし、この構文を使用して、独自のクラスやコレクション型を含む 任意の コレクションを反復処理できますが、それらの型が Sequence プロトコルに準拠している場合に限ります。

While ループ

while ループは条件が false になるまで一連の文を実行します。これらの種類のループは、最初の繰り返しが始まる前に繰り返しの回数が知られていないときに一番よく使用されます。Swift は、２種類の while ループを提供しています。

while は、ループを通る各パスの開始時に、その条件を評価します。
repeat-while は、ループを通る各パスの終わりに、その条件を評価します。

While

while ループは、単一の条件を評価することによって始まります。条件が true の場合、条件が false になるまで、一連の文が繰り返されます。

while ループの一般的な形式は以下のとおりです。

while {

}

この例では、蛇と梯子 (雨どいと梯子 としても知られています) の簡単なゲームを遊びます：

このゲームのルールは以下のとおりです：

ボードには 25 の正方形があり、その目的は、25 番目の正方形に着陸するか超えることです。

プレイヤーの開始する正方形はボードの左下隅にある "ゼロ番目の正方形" です。

各々の順番では、６面体のサイコロを振り、その正方形の数によって動き、上記の点線の矢印で示した水平の道を辿ります。

自分の順番が梯子の下で終了した場合は、その梯子を登って移動します。

自分の順番がヘビの頭で終了した場合は、その蛇の下に移動します。

このゲームボードは、Int 値の配列によって表されます。そのサイズは、この例の後の方では勝利条件をチェックすることにも使いますが、配列を初期化するために使用される finalSquare という定数に基づいています。プレイヤーはボードを "ゼロ番目の正方形" で開始するので、ボードは２５個でなく、２６個のゼロの Int 値で初期化されます：

let finalSquare = 25

var board = [Int](repeating: 0, count: finalSquare + 1)

その後、いくつかの正方形は、ヘビとはしごの、より特殊な値に設定されます。梯子の下のある正方形には、ボードを上に移動するように正の数を持たせ、ヘビの頭がある正方形には、ボードを下に移動するように負の数を持たせます：

board[03] = +08; board[06] = + 11; board[09] = +09; board[10] = +02

board[14] = -10; board [19 ] = - 11; board[22] = -02; board [24] = - 08

正方形 3 は、正方形 11 まで上に移動する、梯子の下を含んでいます。これを表すために、board[03] は +08 に等しく、整数値 8 (3 と 11 の差)と同等です。値と文が合うように、単項プラス演算子(+i)は単項マイナス演算子(-i)とバランスを取るため、また 10 より少ない数字は、ゼロで埋められます。(どちらの書式のテクニックとも、厳密には必要でありませんが、それらにより、コードがすっきりします。)

var square = 0

var diceRoll = 0

while square < finalSquare {

// roll the dice

diceRoll += 1

if diceRoll == 7 { diceRoll = 1 }

// move by the rolled amount

square += diceRoll

if square < board.count {

// if we're still on the board, move up or down for a snake or a ladder

square += board[square]

}

print("Game over!")

上記の例では、サイコロを振るために、非常に簡単なアプローチを使用しています。乱数発生の代わりに、 0 の diceRoll 値で始まります。while ループを通るごとに、diceRoll は、ひとつ増分された後、大きくなりすぎていないかどうかがチェックされます。この戻り値が 7 に等しいときはいつでも、サイコロは大きくなりすぎたので、1 の値にリセットされます。こうして、diceRoll 値の続き方は常に 1、2、3、4、5、6、1、2 というように続きます。

サイコロを振った後、プレイヤーは diceRoll の正方形へと前進します。サイコロの目が正方形の 25 を超えてプレイヤーを移動している可能性があり、その場合ゲームは終わっています。このシナリオに対処するために、コードは square が board 配列の count プロパティ未満であることをチェックします。square が有効な場合、現在の square 値が board[square] に格納された値に追加され、どれかのはしごやヘビを上下してプレイヤーを移動します。

注意： このチェックが行われないと、board[square] は、board 配列の範囲の外の値にアクセスしようとするかも知れず、実行時エラーを引き起こすでしょう。

そして現在の while ループの実行は終了し、ループの条件は、ループが再び実行されるべきかどうかをチェックします。プレーヤーが正方形 25 番に達するか超えた場合、ループの条件は false と評価され、ゲームは終了します。

ゲームの長さは、while ループの開始時には明らかでないので、while ループは、この場合適切です。その代わり、特定の条件が満たされるまで、ループが実行されます。

Repeat-While

repeat-while ループとして知られている while ループの他の変種は、ループの条件を検討する前に、最初にループブロックを一回実行します。その後、条件が false になるまでループを繰り返し続けます。

注意： Swift における repeat-while ループは、他の言語の do-while ループに似ています。

repeat-while ループの一般的な形式は次のとおりです。

repeat {

} while

ここで再び、while ループではなく、repeat-while ループとして書かれた 蛇と梯子 の例を挙げます。finalSquare、board、square および diceRoll の値は、while ループとまったく同じ方法で初期化されます。

let finalSquare = 25

var board = [Int](repeating: 0, count: finalSquare + 1)

board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02

board[14] = -10; board [19] = - 11; board[22] = - 02; board[24] = - 08

var square = 0

var diceRoll = 0

ゲームのこのバージョンでは、ループ内の最初のアクションは梯子やヘビをチェックすることです。ボードでは梯子はまっすぐに正方形 25 にプレーヤーを送らないので、梯子を登って移動してもゲームに勝つことはできません。したがって、ループの最初のアクションで蛇や梯子をチェックするのは安全です。

ゲーム開始時、プレイヤーは "正方形ゼロ" にいます。board[0] は常に 0 に等しく、効果はありません。

repeat {

// move up or down for a snake or ladder

square += board[square]

// roll the dice

diceRoll += 1

if diceRoll == 7 { diceRoll = 1 }

// move by the rolled amount

square += diceRoll

} while square < finalSquare

print("Game over!")

コードが蛇や梯子をチェックした後、ダイスは振られ、プレーヤーは diceRoll の数だけ正方形を前方に移動されます。現在のループの実行はそして終了します。

ループの条件(while square < finalSquare)は以前と同じですが、今回は、ループを通る最初の実行の終了までそれは評価されません。repeat-while ループの構造は、前の例の、while ループよりも、このゲームに適しています。上記の repeat-while ループでは、square += board[square] は、square がまだボード上にある事をループの while 条件が確認した直後に実行されます。この動作は、前に説明したゲームの while ループのバージョンで見られる配列境界チェックの必要性を取り除きます。

条件文

一定の条件に基づいて、異なるコードの部分を実行するとこれはしばしば便利です。値が高すぎたり低すぎたりしたときメッセージを表示したい場合や、エラーが発生したときにコードの特別な部分を実行したい時があります。これを行うには、コードの一部を 条件付き にします。

Swift は、if 文と switch 文の、コードに条件分岐を追加する２つの方法を提供します。一般的には、いくつかのありうる結果のみが出る単純な条件を評価する if 文を使用して下さい。switch 文は、複数のありうる順列の、より複雑な条件に適していて、パターンマッチングが、実行するための適切なコード分岐を選択する時に便利です。

if 文

最も単純な形式では、if 文には、単一の if 条件があります。それは、その条件が true の場合にのみ一連の文を実行します。

var temperatureInFahrenheit = 30

if temperatureInFahrenheit <= 32 {

print("It's very cold. Consider wearing a scarf.")

}

// prints "It's very cold. Consider wearing a scarf."

上記の例では、温度が華氏 32 度(水の凍結点)以下かをチェックします。その場合、メッセージが印刷されます。そうでない場合は、メッセージは印刷されず、コードの実行は、if 文の閉じ括弧以後を続けます。

if 文は、if の条件が false であるときの else 句 として知られる一連の代替文を提供します。これらの文は、else のキーワードで示されます。

temperatureInFahrenheit = 40

if temperatureInFahrenheit <= 32 {

print("It's very cold. Consider wearing a scarf.")

} else {

print("It's not that cold. Wear a t-shirt.")

}

// prints "It's not that cold. Wear a t-shirt."

これら２つの分岐のうち一つが常に実行されます。温度が華氏 40 度に上がっているので、もはやスカーフを着用するよう助言するほど寒くなく、したがって、else の分岐が代わりに引き起こされます。

追加の句を検討する場合は、複数の if 文を連鎖させることができます。

temperatureInFahrenheit = 90

if temperatureInFahrenheit <= 32 {

print("It's very cold. Consider wearing a scarf.")

} else if temperatureInFahrenheit >= 86 {

print("It's really warm. Don't forget to wear sunscreen.")

} else {

print("It's not that cold. Wear a t-shirt.")

}

// prints "It's really warm. Don't forget to wear sunscreen."

ここでは、追加の if 文は特に暖かい温度に対応するために追加されました。最後の else 句が残り、暖かすぎもせず寒すぎもしないすべての温度に対する応答を印刷します。

最後の else 句はしかし、任意であり、一連の条件が完全である必要がない場合は、除外することができます：

temperatureInFahrenheit = 72

if temperatureInFahrenheit <= 32 {

print("It's very cold. Consider wearing a scarf.")

} else if temperatureInFahrenheit >= 86 {

print("It's really warm. Don't forget to wear sunscreen.")

}

温度は暖かすぎもせず寒すぎもせず、if や else if の条件を引き起こさず、メッセージは印刷されません。

Switch

switch 文は、値を考慮し、いくつかの一致する可能性のあるパターンとそれを比較します。その後、成功裏に一致する最初のパターンに基づいて適切なコードのブロックを実行します。switch 文は、複数の潜在的な状態に対応するための if 文の代替手段を提供します。

その最も単純な形態では、switch 文は、同じ型の１つ以上の値に対して値を比較します。

switch {

case :

case ,

default:

}

すべての switch 文は、それぞれ case キーワードで始まる、複数の可能性のある case で構成されています。特定の値と比較することに加えて、Swift はそれぞれの case で、より複雑な一致パターンを指定するための方法をいくつか提供しています。これらのオプションは、この章の後の方で説明します。

if 文の本体と同様に、それぞれの case は、コード実行の別れた分岐です。switch 文は、どの分岐を選択すべきかを決定します。この手順は、検討されている値への 切り替え(switching) として知られています。

すべての switch 文は、網羅的 でなければなりません。つまり、型の全ての可能性のある値は switch の case のいずれか１つに一致しなければなりません。もしすべての可能性のある値に case を提供するのが適切でない場合は、明示的に対処されていないすべての値をカバーするために、デフォルトの case を定義できます。このデフォルトの case は、キーワード default で示され、常に最後に表示しなければなりません。

以下の例では、someCharacter と呼ばれる一つの小文字を考える switch 文を使用しています。

let someCharacter: Character = "z"

switch someCharacter {

case "a":

print("The first letter of the alphabet")

case "z":

print("The last letter of the alphabet")

default:

print("Some other character")

}

// Prints "The last letter of the alphabet"

switch 文の最初の case は、英語のアルファベットの最初の文字 a に一致し、第二の case は、最後の文字の z に一致します。switch は、全てのアルファベット文字だけではなくすべての可能性のある文字の case を持たなければならないので、この switch 文は、a や z 以外の、すべての文字に一致するように default の case を使用します。この規定が、switch 文は網羅的であることを保証します。

暗黙の Fallthrough はなし

C や Objective-C の switch 文とは対照的に、Swift の switch 文は、各 case の底部を通って、デフォルトで次のものへとは通って(fall through) 行きません。その代わりに、全体の switch 文は、明示的な break 文を必要とせずに、最初に一致した switch の case が完了するやいなや、その実行を終了します。これは switch 文を、C のそれより安全で、より使いやすくし、誤って複数の switch の case を実行する事を防ぎます。

注意： break は Swift に必須ではありませんが、特定の case に一致して無視するように、break 文を使用でき、あるいは、その case が実行を完了する前に一致した case から break するために使って下さい。詳細については、Switch 文内の Break を参照してください。

各 case の本体は、少なくとも一つの実行可能文を含まなければなりません。最初の case が空であるため、以下のコードを書くのは有効ではありません。

let anotherCharacter: Character = "a"

switch anotherCharacter {

case "a": // Invalid, the case has an empty body

case "A":

print("The letter A")

default:

print("Not the letter A")

}

// this will report a compile-time error

C 言語での switch 文とは異なり、この switch 文は、"a" と "A" 両方ともに一致しません。むしろ、それは case "a": が実行可能な文を含んでいないというコンパイル時エラーを報告します。このアプローチは、一つの case から別の case への偶発的な fallthrough を回避し、かつその意図を明確にし、より安全なコードにします。

"a" と "A" の両方に単一の case に switch を一致するようにするには、値をコンマで区切って、複合した case に２つの値を組み合わせます。

let anotherCharacter: Character = "a"

switch anotherCharacter {

case "a", "A":

print("The letter A")

default:

print("Not the letter A")

}

// Prints "The letter A"

読みやすくするために、複合した case も複数行に書くことができます。複合した case の詳細については、複合した case を参照してください。

注意： Fallthrough で説明したように、特定の switch case の最後で明示的に fallthrough するには、fallthrough キーワードを使用してください。

範囲の一致

switch の case の値は、それが範囲内に含まれるかどうかチェックできます。この例では、全てのサイズの数字について自然言語のカウントを提供するために、数字の範囲を使用しています。

let approximateCount = 62

let countedThings = "moon orbiting Saturn"

var naturalCount: String

switch approximateCount {

case 0:

naturalCount = "no"

case 1..<5:

naturalCount = "a few"

case 5..<12:

naturalCount = "several"

case 12..<100:

naturalCount = "dozens of"

case 100..<1000:

naturalCount = "hundreds of"

default:

naturalCount = "many"

}

print("There are \(naturalCount) \(countedThings).")

// prints "There are dozens of moons orbiting Saturn."

上記の例では、approximateCount が、switch 文で評価されます。各 case は数や間隔とその値を比較します。 approximateCount の値が 12 と 100 の間に入るので、naturalCount は "dozens of" の値を割り当てられ、実行は switch 文の外に転送されます。

タプル(Tuples)

同じ switch 文で複数の値をテストするためにタプルを使用できます。タプルの各要素は、異なる値又は値の間隔に対してテストできます。代わりに、すべての可能な値と一致するように、ワイルドカードパターンとしても知られるアンダースコア(_)の文字を使ってください。

以下の例は、(x,y)の点をとり、(Int,Int) 型の単純なタプルで表し、例の後に表すグラフ上に分類します。

let somePoint = (1, 1)

switch somePoint {

case (0, 0):

print("\(somePoint) is at the origin")

case (_, 0):

print("\(somePoint) is on the x-axis")

case (0, _):

print("\(somePoint) is on the y-axis")

case (-2...2, -2...2):

print("\(somePoint) is inside the box")

default:

print("\(somePoint) is outside of the box")

}

// prints "(1, 1) is inside the box"

点が原点 (0,0) にあるかどうか switch 文が決定し、赤色の x 軸上か、緑色の y 軸上か、原点を中心にした青の 4×4 の青い箱の内側か、または箱の外側か、switch 文は決定します。

C 言語とは異なり、Swift では、複数の switch の case が同じ値または複数の値と考えることを許可します。実際に、点 (0,0) は、この例の case の４つすべてに一致します。しかし、複数の一致が可能な場合には、最初に一致した case が常に使用されます。点 (0,0) は、最初に case (0,0) と一致するので、他のすべての一致する case は無視されます。

値の結合

switch の case は、case の本体内で使用するための一時的な定数や変数に一致する値または複数の値を名付けられます。この動作は値の結合として知られ、値が case の本体内の一時的な定数や変数に"結合"されるためです。

以下の例は、(x,y)の点を取り、(Int,Int) 型のタプルとして表現され、以下のグラフの上に分類されます。

let anotherPoint = (2, 0)

switch anotherPoint {

case (let x, 0):

print("on the x-axis with an x value of \(x)")

case (0, let y):

print("on the y-axis with a y value of \(y)")

case let (x, y):

print("somewhere else at (\(x), \(y))")

}

// prints "on the x-axis with an x value of 2"

switch 文は、点が赤色の x 軸上にあるか、緑色の y 軸上にあるか、(どちらの軸上でもない)他の場所にあるかを決定します。

3 つの switch の case は一時的に anotherPoint から一つまたは両方のタプルの値をとるプレースホルダの定数 x と y を宣言します。最初の case では、case (let x,0) であり、0 の値を持つ y と一時的な定数 x に点の x 値を割り当てる任意の点に一致します。同様に、第二の case、case(0,let y) では、0 の値を持つ x と一時的な定数 y に点の y 値を割り当てる任意の点に一致します。

一時的な定数が宣言されると、それらは case のコードブロック内で使用できます。ここで、それらは点の分類を印刷する為に使用されています。

この switch 文は、default の case を持っていません。最後の case、case let(x、y) は、任意の値に一致する２つのプレースホルダ定数のタプルを宣言しています。anotherPoint は、常に 2 つの値のタプルであるため、この case は、すべての可能な残りの値と一致し、default の case は、switch 文が網羅するためには必要とされていません。

Where

switch の case は、追加の条件をチェックするのに where 句を使用できます。

以下の例は、以下のグラフ上の点(x、y)を分類します：

let yetAnotherPoint = (1, -1)

switch yetAnotherPoint {

case let (x, y) where x == y:

print("(\(x), \(y)) is on the line x == y")

case let (x, y) where x == -y:

print("(\(x), \(y)) is on the line x == -y")

case let (x, y):

print("(\(x), \(y)) is just some arbitrary point")

}

// prints "(1, -1) is on the line x == -y"

点が緑色の対角線の where x == y 上か、紫色の対角線上の where x == -y か、またはどちらでもないかを、switch 文が決定します。

switch の３つの case は yetAnotherPoint から２つのタプル値を一時的にとり、プレースホルダ定数の x と y を宣言します。これらの定数は、動的フィルタを作成するために、where 句の一部として使用されています。 switch の case は、where 句の条件が、その値が true と評価された場合にのみ point の現在の値と一致します。

前の例のように、最後の case は、残りのすべての可能な値と一致し、これで default case は、switch 文を網羅するために必要とされません。

複合した case

同じ本体を共有する複数の switch case は、case の後にいくつかのパターンを書き、それぞれのパターンの間にコンマを書く事で組み合わせることができます。パターンのいずれかが一致する場合、case は一致すると考えられます。リストが長い場合、パターンは複数行に書く事ができます。例えば：

let someCharacter: Character = "e"

switch someCharacter {

case "a", "e", "i", "o", "u":

print("\(someCharacter) is a vowel")

case "b", "c", "d", "f", "g", "h", "j", "k", "l", "m",

"n", "p", "q", "r", "s", "t", "v", "w", "x", "y", "z":

print("\(someCharacter) is a consonant")

default:

print("\(someCharacter) is not a vowel or a consonant")

}

// Prints "e is a vowel"

switch 文の最初の case は、英語の５つすべての小文字の母音と一致します。同様に、第二の case は、すべての小文字の英語の子音と一致します。最後に、default の case は、他の文字と一致します。

また複合した case は、値の結合を含むこともできます。複合した case のすべてのパターンが値の結合の同じセットを含まなければならず、各々の結合は復合した case のすべてのパターンから同じ型の値を取得しなければなりません。これは復合した case のどの部分が一致したかによらず、case の本体のコードは常に結合した値にアクセスでき、値が常に同じ型を持っていることを保証します。

let stillAnotherPoint = (9, 0)

switch stillAnotherPoint {

case (let distance, 0), (0, let distance):

print("On an axis, \(distance) from the origin")

default:

print("Not on an axis")

}

// Prints "On an axis, 9 from the origin"

上記の case には、二つのパターンがあります：x 軸上の点に一致する (let distance,0) と、y 軸上の点と一致する (0,let distance) です。両方のパターンは、distance の結合を含んでおり、両方のパターンで distance は整数です–これは、case の本体内のコードは常に distance の値にアクセスできることを意味します。

制御転送文

制御転送文 は、コードが実行される順序を変更し、一つのコードの部分から別の部分へと、制御を転送します。Swift には５つの制御転送文があります。

continue

break

fallthrough

return

throw

continue, break, そして fallthrough 文は以下に説明します。return 文は、関数で説明し、throw 文は throw 関数を使用したエラーの伝播で説明します。

Continue

continue 文は、ループを通じて、次の反復の開始時に、何をしようとし再び開始しようとしているのを停止するよう、ループに伝えます。それは、完全にループを離れることなく、"私は現在のループの繰り返しを終わりました" と言う事です。

以下の例では、秘密のパズルの句を作るために小文字の文字列からすべての母音とスペースを削除します。

let puzzleInput = "great minds think alike"

var puzzleOutput = ""

let charactersToRemove: [Character] = ["a", "e", "i", "o", "u", " "]

for character in puzzleInput {

if charactersToRemove.contains(character) {

continue

} else {

puzzleOutput.append(character)

}

print(puzzleOutput)

// Prints "grtmndsthnklk"

上記のコードでは、母音またはスペースと一致するたびに、continue キーワードを呼び出し、ループの現在の繰り返しを生じてすぐに終了して次の繰り返しの先頭にまっすぐ進みます。

Break

break 文は、フロー制御文全体の実行をすぐに終了します。break 文は、switch 文やループ文の内部で使用することができ、そうでない case よりも、switch 文やループ文の実行を速く終了したいときに使用します。

ループ文内の Break

ループ文の中で使用された場合、break はすぐにループの実行を終了し、ループの閉じ括弧 (})の後のコードに制御を移します。ループの現在の繰り返しから、それ以上のコードは実行されず、ループのさらなる繰り返しは開始されません。

Switch 文内の Break

switch 文の中で使用された場合、break はその switch の実行をすぐに終了し、switch 文の閉じ括弧 (})の後のコードに制御を移します。

この動作は、switch 文内の 1 つ以上の case に一致し無視する時に使用できます。Swift の switch 文は網羅的であり、空の case を許可していないので、意図を明示するために case に故意に一致し無視する必要がある場合があります。無視したい case の本体全体として break 文を書くことでこれを行います。その case が switch 文で一致している場合、case 内の break 文は、switch 文の実行を直ちに終了します。

注意： コメントのみを含む switch の case は、コンパイル時にエラーとして報告されます。コメントは文ではなく、switch の case が無視されることはありません。switch の case を無視するには break 文を常に使用して下さい。

以下の例は、Character の値で switch し、それが４つの言語のいずれかで数記号を表しているかを決定します。簡単のために、複数の値を、一つの switch の case でカバーしています。

let numberSymbol: Character = "三" // Chinese symbol for the number 3

var possibleIntegerValue: Int?

switch numberSymbol {

case "1", "١", "一", "๑":

possibleIntegerValue = 1

case "2", "٢", "二", "๒":

possibleIntegerValue = 2

case "3", "٣", "三", "๓":

possibleIntegerValue = 3

case "4", "٤", "四", "๔":

possibleIntegerValue = 4

default:

break

}

if let integerValue = possibleIntegerValue {

print("The integer value of \(numberSymbol) is \(integerValue).")

} else {

print("An integer value could not be found for \(numberSymbol).")

}

// prints "The integer value of 三 is 3."

この例では、numberSymbol が、ラテン語、アラビア語、中国語、またはタイ語の 1 から 4 までの数字のシンボルかどうかを決定します。一致する物が見つかると、switch 文の case の一つが、optional の possibleIntegerValue と呼ばれる optional の Int? 変数を、適切な整数値に設定します。

switch 文がその実行を完了した後、例は、値が見つかったかどうかを判断するために、optional の結合を使用します。possibleIntegerValue 変数は、optional の型であるおかげで、nil の暗黙の初期値を持っており、optional の結合は possibleIntegerValue が、switch 文の最初の４つの case の一つにより実際の値に設定された場合にのみ成功します。

上記の例ではすべての可能な Character の値を列挙することは現実的ではないので、default の case が、一致しない全ての文字を処理します。この default の case は、アクションを全く実行する必要がないので、その本体として一つの break 文が書かれています。default の case が一致するやいなや、break 文は、switch 文の実行を終了し、コードの実行は、if let 文から継続されます。

Fallthrough

Swift では、switch 文は各 case の底を通って、次の case に落ちては行きません。すなわち、全体の switch 文は最初に一致した case が完了するやいなや、その実行を完了します。これとは対照的に、C では、fallthrough を防ぐために全ての switch case の最後に明示的な break 文を挿入する必要があります。デフォルトの fallthrough を回避することは Swift の switch 文の方が C 言語の相当する部分よりはるかに簡潔かつ予測可能であり、したがって、それらは誤って複数の switch の case を実行する事を防ぐ事を意味します。

C 言語スタイルの fallthrough の動作を必要とする場合は、fallthrough キーワードで、ケースバイケースの基本でこの動作を選ぶことができます。以下の例では、数字のテキスト記述を作成するのに fallthrough を使用しています。

let integerToDescribe = 5

var description = "The number \(integerToDescribe) is"

switch integerToDescribe {

case 2, 3, 5, 7, 11, 13, 17, 19:

description += " a prime number, and also"

fallthrough

default:

description += " an integer."

}

print(description)

// prints "The number 5 is a prime number, and also an integer."

この例では、description と呼ばれる新しい String 変数を宣言し、それに初期値を代入しています。関数はその後、switch 文を使用して integerToDescribe の値を考慮します。integerToDescribe の値が、リスト内の素数のいずれかである場合、関数は、数値が素数であることに注意させるため、description の後にテキストを追加します。その後、同様に、default の case に"落ちる"ために fallthrough キーワードを使用します。default の case は、説明(description)の後にいくつか余分なテキストを追加し、switch 文は終わります。

integerToDescribe の値が既知の素数のリストにない場合、それは第一の switch の case に全く一致しません。そこには他の特定の case はありませんので、 integerToDescribe は default の case に一致します。

switch 文が実行を終了した後は、数字の説明(description)が print(_:separator:terminator:) 関数を使用して印刷されます。この例では、数字 5 は正しく素数として識別されます。

注意： fallthrough キーワードは、その実行が陥る switch case の条件をチェックしません。fallthrough キーワードは単に、C の標準の switch 文の動作のように、コードの実行を次の case(または default の case)のブロック内の文に直接移動します。

ラベル付きの文

Swift では、他のループや条件文の内側のループや条件文を、複雑な制御フロー構造を作成する為に入れ子にすることができます。しかし、ループや条件文の両方とも途中でその実行を終了する break 文を使用できます。したがって、あなたが終了すべき break 文が欲しいループや条件文を明示することが時には便利です。同様に、複数の入れ子にされたループがある場合も、continue 文が影響を与えるべきループがどれかを明示する事が便利です。

これらの目的を達成するためには、ループ文や条件文を 文のラベル でマークできます。条件文で使用すると、ラベル付きの文の実行を終了する break 文で文ラベルを使用できます。ループ文で使用すると、break 文や continue 文で文ラベルを使用でき、ラベル付きの文の実行を終了したり、継続したりできます。

ラベル付き文は、文の導入キーワードと同じ行に、ラベルを配置して示され、コロンが続きます。原則はすべてのループや switch 文と同じですが、ここでは、while ループでこの構文の例を挙げます。

: while {

}

以下の例では、break 文と continue 文を使用して、この章の初めで見た 蛇と梯子 ゲームの改造バージョンでラベル付きの while ループを使っています。今回は、ゲームは特別のルールがあります：

勝つには、正方形の 25 上に 正確に 着陸しなければなりません。

特定のサイコロを振って正方形の 25 を超えた場合には、正方形の 25 に着陸するために必要な正確な数を振るまで振り続けなければなりません。

ゲームボードは以前と同じです。

finalSquare、board、square、および diceRoll の値は以前と同じように初期化されます。

let finalSquare = 25

var board = [Int](repeating: 0, count: finalSquare + 1)

board[03] = +08; board[06] = +11; board[09] = +09; board[10] = +02

board[14] = -10; board[19] = - 11; board[22] = -02; board[24] = -08

var square = 0

var diceRoll = 0

ゲームのこのバージョンは、ゲームの論理を実装する while ループと switch 文を使用します。while ループには、gameloop と呼ばれる文のラベルがあり、それが蛇と梯子ゲームの主なゲームループであることを示します。

while ループの条件は、while square != finalSquare で、正方形 25 上に正確に着陸しなければならないことを反映しています。

gameLoop: while square != finalSquare {

diceRoll += 1

if diceRoll == 7 { diceRoll = 1 }

switch square + diceRoll {

case finalSquare:

// diceRoll will move us to the final square, so the game is over

break gameLoop

case let newSquare where newSquare > finalSquare:

// diceRoll will move us beyond the final square, so roll again

continue gameLoop

default:

// this is a valid move, so find out its effect

square += diceRoll

square += board[square]

}

print("Game over!")

サイコロは、各ループの最初に振られます。すぐにプレイヤーを移動するよりも、むしろループは移動の結果を考慮し、移動が許可されているかどうかを決定する為 switch 文を使用します。

サイコロを振って、最後の正方形の上にプレーヤーが移動すると、ゲームオーバーです。break gameLoop 文は、while ループの外のコードの最初の行に制御を移し、ゲームを終了します。

サイコロを振って、最後の正方形を 超えて プレーヤーが移動した場合、移動は無効であり、プレイヤーは再びサイコロを振る必要があります。continue gameLoop 文は、現在の while ループの繰り返しを終了し、ループの次の繰り返しを始めます。

他のすべての場合、サイコロの目は有効な動きです。プレイヤーは diceRoll だけ四角を前進し、ゲームの論理は全ての蛇と梯子をチェックします。そしてループは終了し、制御は while の条件に戻って、順番がもう一度必要かどうかを決定します。

注意：

上記の break 文が、gameLoop ラベルを使用しなかった場合、while 文ではなく、switch 文を抜け出すでしょう。gameLoop ラベルを使用すると、どの制御文を終了すべきかが明らかになります。

ループの次の繰り返しにジャンプする continue gameLoop を呼び出すときには gameLoop ラベルを使用する必要は厳密にはありません。ゲーム内には唯一つしかループがなく、したがってどのループに continue 文が影響を与えるのかに関して、曖昧さはありません。しかし、continue 文で gameLoop ラベルを使用しても害はありません。そうすることで、break 文と一緒にあるラベルの使用と首尾一貫し、ゲームの論理を読みやすく理解しやすくなります。

早期終了

guard 文は、if 文のように、式のブール値に応じて文を実行します。guard 文が実行された後にはコードの条件が真でなければならないことを要求するように guard 文を使用して下さい。if 文とは異なり、guard 文は条件が真でない場合実行される、else 節内のコードである、else 節が常にあります。

func greet(person: [String: String]) {

guard let name = person["name"] else {

return

}

print("Hello \(name)!")

guard let location = person["location"] else {

print("I hope the weather is nice near you.")

return

}

print("I hope the weather is nice in \(location).")

}

greet(person: ["name": "John"])

// Prints "Hello John!"

// Prints "I hope the weather is nice near you."

greet(person: ["name": "Jane", "location": "Cupertino"])

// Prints "Hello Jane!"

// Prints "I hope the weather is nice in Cupertino."

guard 文の条件が満たされた場合、コードの実行は guard 文の閉じ括弧の後に続きます。条件の一部として、optuinal の結合を使用して値を代入されたすべての変数または定数は guard 文が表示された、コードブロックの残りで利用可能です。

その条件が満たされない場合、else 分岐内のコードが実行されます。その分枝は guard 文が表示されるコードブロックを終了するため制御を転送しなければなりません。それは、return,break,continue、または throw のような制御転送文でこれを行うことができ、あるいは fatalError(_:file:line:) のように返さない関数やメソッドを呼び出すことができます。

要件について、guard 文を使用すると、if 文で同じチェックをするのと比較すると、コードの可読性を向上します。これにより、通常実行されるコードを else ブロックで包みこまずに記述でき、違反した要件を処理するコードを要件の隣に保持できます。

遅延したアクション

あなたのコードの一部を実行するかどうか、または実行回数を制御できる if や while などの制御フロー構造とは異なり、コードの一部が実行される ときに 制御を defer (延期) します。defer ブロックを使用して、後であなたのプログラムが現在のスコープの終わりに到達したときに実行されるコードを作成します。例えば：

var score = 1
if score < 10 {
defer {
print(score)
}
score += 5
}
// Prints "6"

上記の例では、if 文の本体を終了する前に、defer ブロック内のコードが実行されます。まず、if 文内のコードが実行され、score が 5 つずつ増加します。次に、if 文のスコープを終了する前に、遅延したコードが実行され、score が出力されます。

プログラムがそのスコープをどのように終了するかに関係なく、defer 内のコードは常に実行されます。これには、関数の早期終了、for ループの抜け出し、エラーの throw などのコードが含まれます。この動作により、defer は、手動でのメモリの割り当てと解放、低レベルのファイル記述子のオープンとクローズ、データベースでの処理の開始と終了など、ペアのアクションの発生を保証する必要がある操作に役立ちます。これは、両方のアクションを隣に記述できるためです。たとえば、以下のコードは、コードの塊内で 100 を加算および減算することにより、スコアに一時的なボーナスを与えます。

var score = 3
if score < 100 {
score += 100
defer {
score -= 100
}
// Other code that uses the score with its bonus goes here.
print(score)
}
// Prints "103"

同じスコープ内に複数の defer ブロックを作成した場合、最初に指定した defer ブロックが最後に実行されます。

if score < 10 {
defer {
print(score)
}
defer {
print("The score is:")
}
score += 5
}
// Prints "The score is:"
// Prints "6"

例えば、実行時エラーやクラッシュが原因でプログラムの実行が停止した場合、遅延したコードは実行されません。ただし、遅延したコードはエラーが throw された後に実行されます。エラー処理での defer の使用については、クリーンアップアクションの指定を参照してください。

API 利用可能性の確認

Swift には API の利用可能性を確認するためのサポートが組み込まれていますが、与えられた展開ターゲットでは使用できない API を誤って使用しないことをそれは保証します。

コンパイラは、コード内で使用される全ての API が、プロジェクトで指定された展開ターゲット上で使用可能であることを確認するために SDK の利用情報を使用します。利用できない API を使用しようとした時、Swift は、コンパイル時にエラーを報告します。

使用したい API が実行時に利用可能かどうかに応じて、コードのブロックを条件付きで実行する、if または guard 文で 利用可能性の条件 を使用して下さい。コードのそのブロック内の API が利用可能であることを確認したときにコンパイラは利用可能の条件からの情報を使用します。

if #available(iOS 10, macOS 10.12, *) {

// Use iOS 10 APIs on iOS, and use macOS 10.12 APIs on macOS

} else {

// Fall back to earlier iOS and macOS APIs

}

上記の利用可能性の条件は、iOS 内のそれを指定し、if 文の本体は iOS 10 以降のみで、macOS では macOS 10.12 以降でのみ実行します。最後の引数、* は、他の任意のプラットフォーム上で必要で指定しており、if の本体はあなたのターゲットによって指定された最小展開ターゲット上で実行します。

その一般的な形式では、利用可能性の条件は、プラットフォームの名前とバージョンのリストを取ります。iOS、macOS、watchOS や tvOS のようなプラットフォームの名前を使用しますが、その完全なリストは、宣言の属性を参照してください。iOS 8 や macOS 10.10 のようにメジャーなバージョン番号を指定するのに加え、iOS 11.2.6 や macOS 10.13.3 のようなマイナーなバージョン番号を指定できます。

if #available( , , *) {

} else {

}

guard で利用可能性条件を使用すると、そのコードブロックの残りのコードに使用される利用可能情報が洗練されます。

@available(macOS 10.12, *)

struct ColorPreference {

var bestColor = "blue"

}

func chooseBestColor() -> String {

guard #available(macOS 10.12, *) else {

return "gray"

}

let colors = ColorPreference()

return colors.bestColor

}

上記の例では、ColorPreference 構造体には macOS 10.12 以降が必要です。chooseBestColor() 関数は、利用可能性の guard で始まります。プラットフォームのバージョンが古すぎて ColorPreference を使用できない場合は、常に利用可能な動作になります。guard 文の後、macOS 10.12 以降を必要とする API を使用できます。

#available に加えて、Swift は利用不可条件を使用した反対のチェックもサポートしています。たとえば、以下の 2 つのチェックは同じことを行います。

if #available(iOS 10, *) {

} else {

// Fallback code

}

if #unavailable(iOS 10) {

// Fallback code

}

#unavailable 形式を使用すると、チェックにフォールバックコードのみが含まれている場合に、コードがより読みやすくなります。

前：コレクション型次：関数

トップへ

トップへ

トップへ

トップへ

Swift 5.8 日本語化計画 : Swift 5.8

For-In ループ

While ループ

While

Repeat-While

条件文

if 文

Switch

暗黙の Fallthrough はなし

範囲の一致

タプル(Tuples)

値の結合

Where

複合した case

制御転送文

Continue

Break

ループ文内の Break

Switch 文内の Break

Fallthrough

ラベル付きの文

早期終了

遅延したアクション

API 利用可能性の確認

Swift 5.8 全メニュー

Swift 5.8 日本語化計画　: Swift 5.8