Patterns パターン

A pattern represents the structure of a single value or a composite value. For example, the structure of a tuple (1, 2) is a comma-separated list of two elements. Because patterns represent the structure of a value rather than any one particular value, you can match them with a variety of values. For instance, the pattern (x, y) matches the tuple (1, 2) and any other two-element tuple. In addition to matching a pattern with a value, you can extract part or all of a composite value and bind each part to a constant or variable name. あるパターンは、ある単一の値または複合の値の構造を表します。例えば、タプル(1, 2)の構造は、コンマで区切られた2つの要素のリストです。パターンがどれかひとつの特定の値ではなく値の構造を表すので、あなたはそれをいろいろな値と照合(マッチング)できます。たとえば、パターン(x, y)はタプル(1, 2)および他のどんな2要素タプルにでもマッチします。パターンを値とマッチングすることに加えて、あなたはある複合値の部分または全てを抽出して、各部分を定数や変数の名前に結び付ける(束縛する)ことができます。

In Swift, there are two basic kinds of patterns: those that successfully match any kind of value, and those that may fail to match a specified value at runtime. スウィフトには、2つの基本的な種類のパターンがあります:あらゆる種類の値に成功裏にマッチするものそれら、そして指定された値にマッチするのを実行時に失敗するものそれら。

The first kind of pattern is used for destructuring values in simple variable, constant, and optional bindings. These include wildcard patterns, identifier patterns, and any value binding or tuple patterns containing them. You can specify a type annotation for these patterns to constrain them to match only values of a certain type. 最初の種類のパターンは、単純な変数、定数、およびオプショナル束縛での非構成の値に使われます。これらはワイルドカード・パターン、識別子パターン、そしてそれらを含むあらゆる値束縛やタプルパターンを含みます。あなたは型注釈をこれらのパターンに指定して、それらがある特定の型の値だけにマッチするように制約を加えることができます。

The second kind of pattern is used for full pattern matching, where the values you’re trying to match against may not be there at runtime. These include enumeration case patterns, optional patterns, expression patterns, and type-casting patterns. You use these patterns in a case label of a switch statement, a catch clause of a do statement, or in the case condition of an if, while, guard, or for-in statement. 2番目の種類のパターンは、完全なパターンマッチングのために使われます、そこにおいてあなたがマッチを試みている対象である値は実行時にそこにないかもしれません。これらは、列挙ケース節パターン、オプショナルパターン、式パターン、および型キャストパターンを含みます。あなたはこれらのパターンをswitch文のケース節ラベル、do文のcatch節において、またはifwhileguard、およびfor-in文のケース節条件において使用します。

Grammar of a pattern パターンの文法

Wildcard Pattern ワイルドカード・パターン

A wildcard pattern matches and ignores any value and consists of an underscore (_). Use a wildcard pattern when you don’t care about the values being matched against. For example, the following code iterates through the closed range 1...3, ignoring the current value of the range on each iteration of the loop: ワイルドカード・パターンは、どんな値にでもマッチして無視します、そしてアンダースコア(_)から成ります。あなたがマッチされている値を気にかけない場合に、ワイルドカード・パターンを使ってください。例えば、完結範囲1...3のすべてに繰り返す以下のコードは、ループの各繰り返しにおいて範囲の現在の値を無視しています:

  1. for _ in 1...3 {
  2. // Do something three times.(3回何かをします。)
  3. }

Grammar of a wildcard pattern ワイルドカード・パターンの文法

wildcard-pattern _

Identifier Pattern 識別子パターン

An identifier pattern matches any value and binds the matched value to a variable or constant name. For example, in the following constant declaration, someValue is an identifier pattern that matches the value 42 of type Int: 識別子パターンは、どんな値にでもマッチして、マッチされた値を変数や定数の名前に縛りつけます。例えば、以下の定数宣言において、someValueは、型Intの値42にマッチする識別子パターンです:

  1. let someValue = 42

When the match succeeds, the value 42 is bound (assigned) to the constant name someValue. マッチが成功するとき、値42は、定数の名前のsomeValueに縛りつけられます(代入されます)。

When the pattern on the left-hand side of a variable or constant declaration is an identifier pattern, the identifier pattern is implicitly a subpattern of a value-binding pattern. 変数や定数宣言の左側のパターンが識別子パターンであるとき、その識別子パターンは暗黙のうちに値束縛パターンの下位パターンです。

Grammar of an identifier pattern 識別子パターンの文法

identifier-pattern identifier

Value-Binding Pattern 値束縛パターン

A value-binding pattern binds matched values to variable or constant names. Value-binding patterns that bind a matched value to the name of a constant begin with the let keyword; those that bind to the name of variable begin with the var keyword. 値束縛パターンは、マッチした値を変数または定数の名前に縛り付けてひとつに束ねます。マッチした値を定数の名前に束縛する値束縛パターンは、letキーワードで始まります;変数の名前と縛りつけるものは、varキーワードで始まります。

Identifiers patterns within a value-binding pattern bind new named variables or constants to their matching values. For example, you can decompose the elements of a tuple and bind the value of each element to a corresponding identifier pattern. ある値束縛パターン内の複数の識別子パターンは、複数の新しい名前をつけられた変数または定数を、それらがマッチしている値に縛りつけます。例えば、あなたはタプルの要素を分解して、各要素の値を対応する識別子パターンへと縛り付けることができます。

  1. let point = (3, 2)
  2. switch point {
  3. // Bind x and y to the elements of point.(xとyをpointの要素へ束縛します。)
  4. case let (x, y):
  5. print("The point is at (\(x), \(y)).")
  6. }
  7. // Prints "The point is at (3, 2)."(「pointは(3, 2)です。」を出力します)

In the example above, let distributes to each identifier pattern in the tuple pattern (x, y). Because of this behavior, the switch cases case let (x, y): and case (let x, let y): match the same values. 上の例で、letは、タプルパターン(x, y)における各識別子パターンに分配されます。この挙動のため、switchケース節case let (x, y):case (let x, let y):は、同じ値にマッチします。

Grammar of a value-binding pattern 値束縛パターンの文法

value-binding-pattern var pattern | let pattern

Tuple Pattern タプルパターン

A tuple pattern is a comma-separated list of zero or more patterns, enclosed in parentheses. Tuple patterns match values of corresponding tuple types. タプルパターンは、丸括弧で囲まれた、0個以上のパターンのコンマ区切りのリストです。タプルパターンは、対応するタプル型の値にマッチします。

You can constrain a tuple pattern to match certain kinds of tuple types by using type annotations. For example, the tuple pattern (x, y): (Int, Int) in the constant declaration let (x, y): (Int, Int) = (1, 2) matches only tuple types in which both elements are of type Int. あなたは、型注釈を使うことによって特定の種類のタプル型にマッチするようにタプルパターンに制約を加えることができます。例えば、定数宣言let (x, y): (Int, Int) = (1, 2)におけるタプルパターン(x, y): (Int, Int)は、両方の要素が型Intであるタプル型だけにマッチします。

When a tuple pattern is used as the pattern in a for-in statement or in a variable or constant declaration, it can contain only wildcard patterns, identifier patterns, optional patterns, or other tuple patterns that contain those. For example, the following code isn’t valid because the element 0 in the tuple pattern (x, 0) is an expression pattern: タプルパターンがfor-in文においてまたは変数や定数宣言においてパターンとして使われるとき、それはワイルドカード・パターン、識別子パターン、オプショナルパターン、またはそれらを含む他のタプルパターンだけを含むことができます。例えば、以下のコードは有効ではありません、タプルパターン(x, 0)の中の要素0が式パターンであるためです:

  1. let points = [(0, 0), (1, 0), (1, 1), (2, 0), (2, 1)]
  2. // This code isn't valid.(このコードは有効ではありません。)
  3. for (x, 0) in points {
  4. /* ... */
  5. }

The parentheses around a tuple pattern that contains a single element have no effect. The pattern matches values of that single element’s type. For example, the following are equivalent: ただ1つだけの要素を含むタプルパターンのまわりの丸括弧には、効果がありません。パターンは、そのただ1つの要素の型の値にマッチします。例えば、以下のものはどれも等しいです:

  1. let a = 2 // a: Int = 2
  2. let (a) = 2 // a: Int = 2
  3. let (a): Int = 2 // a: Int = 2

Grammar of a tuple pattern タプル・パターンの文法

tuple-pattern ( tuple-pattern-element-list opt )

tuple-pattern-element-list tuple-pattern-element | tuple-pattern-element , tuple-pattern-element-list

tuple-pattern-element pattern | identifier : pattern

Enumeration Case Pattern 列挙ケース節パターン

An enumeration case pattern matches a case of an existing enumeration type. Enumeration case patterns appear in switch statement case labels and in the case conditions of if, while, guard, and for-in statements. 列挙ケース節パターンは、既存の列挙型のケース節にマッチします。列挙ケース節パターンは、switch文のケース節ラベル(ケース節表記)において、そしてifwhileguard、およびfor-in文のケース節条件において現れます。

If the enumeration case you’re trying to match has any associated values, the corresponding enumeration case pattern must specify a tuple pattern that contains one element for each associated value. For an example that uses a switch statement to match enumeration cases containing associated values, see Associated Values. あなたがマッチしようとしている列挙ケース節が関連値を持つならば、対応する列挙ケース節パターンは、各関連値に対して1つの要素を含んでいるタプルパターンを指定しなければなりません。関連値を含んでいる列挙ケース節にマッチするためにswitch文を使う例のために、関連値を見てください。

An enumeration case pattern also matches values of that case wrapped in an optional. This simplified syntax lets you omit an optional pattern. Note that, because Optional is implemented as an enumeration, .none and .some can appear in the same switch as the cases of the enumeration type. 列挙ケースパターンはまた、オプショナルの中にラップされたそのケース節の値それらにマッチします。この簡略化された構文は、あなたにあるオプショナルパターンを省略させます。注意することとして、Optionalが列挙として実装されることから、.none.someが同じスイッチ文の中に列挙型のケース節として現れることが可能です。

  1. enum SomeEnum { case left, right }
  2. let x: SomeEnum? = .left
  3. switch x {
  4. case .left:
  5. print("Turn left")
  6. case .right:
  7. print("Turn right")
  8. case nil:
  9. print("Keep going straight")
  10. }
  11. // Prints "Turn left"

Grammar of an enumeration case pattern 列挙ケース節パターンの文法

enum-case-pattern type-identifier opt . enum-case-name tuple-pattern opt

Optional Pattern オプショナルパターン

An optional pattern matches values wrapped in a some(Wrapped) case of an Optional<Wrapped> enumeration. Optional patterns consist of an identifier pattern followed immediately by a question mark and appear in the same places as enumeration case patterns. オプショナルパターンは、Optional<Wrapped>列挙のSome(Wrapped)ケース節でラップされる値にマッチします。オプショナルパターンは、1つの識別子パターンに直接に1つの疑問符が続くものから成ります、そして列挙ケース節パターンと同じ場所に現れます。

Because optional patterns are syntactic sugar for Optional enumeration case patterns, the following are equivalent: オプショナルパターンはOptional列挙ケース節パターンに対する糖衣構文であるので、以下のものは等価です:

  1. let someOptional: Int? = 42
  2. // Match using an enumeration case pattern.(列挙ケース節パターンを使っているマッチ。)
  3. if case .some(let x) = someOptional {
  4. print(x)
  5. }
  6. // Match using an optional pattern.(オプショナルパターンを使っているマッチ。)
  7. if case let x? = someOptional {
  8. print(x)
  9. }

The optional pattern provides a convenient way to iterate over an array of optional values in a for-in statement, executing the body of the loop only for non-nil elements. オプショナルパターンは、for-in文においてオプショナルの値がはいった配列の全体にわたって、ループの本文を非nilの要素のみに実行して、繰り返すための便利な方法を提供します。

  1. let arrayOfOptionalInts: [Int?] = [nil, 2, 3, nil, 5]
  2. // Match only non-nil values.(nilでない値にのみマッチする。)
  3. for case let number? in arrayOfOptionalInts {
  4. print("Found a \(number)")
  5. }
  6. // Found a 2
  7. // Found a 3
  8. // Found a 5

Grammar of an optional pattern オプショナルパターンの文法

optional-pattern identifier-pattern ?

Type-Casting Patterns 型キャスト・パターン

There are two type-casting patterns, the is pattern and the as pattern. The is pattern appears only in switch statement case labels. The is and as patterns have the following form: 2つの型キャスト・パターン、isパターンとasパターンがあります。isパターンは、switch文のケース節ラベルだけで見かけます。isasパターンは以下の形式を持ちます:

  1. is type
  2. pattern as type

The is pattern matches a value if the type of that value at runtime is the same as the type specified in the right-hand side of the is pattern—or a subclass of that type. The is pattern behaves like the is operator in that they both perform a type cast but discard the returned type. isパターンは、ある値にマッチします、もしその値の実行時での型がisパターンの右側で指定される型 ― またはそれの型のサブクラス ― と同じものであるならば。isパターンは、それらが両方とも型キャストを実行するが返された型を捨てるという点において、is演算子のようにふるまいます。

The as pattern matches a value if the type of that value at runtime is the same as the type specified in the right-hand side of the as pattern—or a subclass of that type. If the match succeeds, the type of the matched value is cast to the pattern specified in the right-hand side of the as pattern. asパターンは、ある値にマッチします、もしその値の実行時での型がasパターンの右側で指定される型 ― または、それの型のサブクラス ― と同じものであるならば。マッチが成功するならば、マッチされた値の型は、asパターンの右手側で指定されるパターンにキャストされます。

For an example that uses a switch statement to match values with is and as patterns, see Type Casting for Any and AnyObject. switch文を使用して、さまざまに値をisasパターンとマッチする例のために、AnyおよびAnyObjectに対する型キャストを見てください。

Grammar of a type casting pattern 型キャスト・パターンの文法

type-casting-pattern is-pattern | as-pattern

is-pattern is type

as-pattern pattern as type

Expression Pattern 式パターン

An expression pattern represents the value of an expression. Expression patterns appear only in switch statement case labels. 式パターンは、ある式の値を表します。式パターンは、switch文のケース節ラベルにおいてのみ現れます。

The expression represented by the expression pattern is compared with the value of an input expression using the Swift standard library ~= operator. The matches succeeds if the ~= operator returns true. By default, the ~= operator compares two values of the same type using the == operator. It can also match a value with a range of values, by checking whether the value is contained within the range, as the following example shows. 式パターンによって表される式は、入力された式の値とスウィフト標準ライブラリ~=演算子を使って比較されます。~=演算子がtrueを返すならば、マッチは成功します。初期状態で、~=演算子は、同じ型の2つの値を==演算子を使用して比較します。それはまた、ある値をある範囲の値と照合することが、その値がその範囲に含まれるかどうかを調べることによって可能です、以下の例が示すように。

  1. let point = (1, 2)
  2. switch point {
  3. case (0, 0):
  4. print("(0, 0) is at the origin.")
  5. case (-2...2, -2...2):
  6. print("(\(point.0), \(point.1)) is near the origin.")
  7. default:
  8. print("The point is at (\(point.0), \(point.1)).")
  9. }
  10. // Prints "(1, 2) is near the origin."(「(1, 2)は原点に近いです。」を出力します)

You can overload the ~= operator to provide custom expression matching behavior. For example, you can rewrite the above example to compare the point expression with a string representations of points. あなたは、~=演算子をオーバーロードして、あつらえの式マッチング挙動を提供することができます。例えば、あなたは上記の例を書き直して、point式をpoint(座標)の文字列表現と比較するようにできます。

  1. // Overload the ~= operator to match a string with an integer.(~=演算子をオーバーロードして文字列を整数と照合するようにする。)
  2. func ~= (pattern: String, value: Int) -> Bool {
  3. return pattern == "\(value)"
  4. }
  5. switch point {
  6. case ("0", "0"):
  7. print("(0, 0) is at the origin.")
  8. default:
  9. print("The point is at (\(point.0), \(point.1)).")
  10. }
  11. // Prints "The point is at (1, 2)."(「pointは(1, 2)です」を出力します)

Grammar of an expression pattern 式パターンの文法

expression-pattern expression

Attributes 属性

Generic Parameters and Arguments 総称体パラメータと引数