Guides and Sample Code

Developer

The Swift Programming Language (Swift 4.1)

iBooks
On This Page

Declarations
宣言

A declaration introduces a new name or construct into your program. For example, you use declarations to introduce functions and methods, to introduce variables and constants, and to define enumeration, structure, class, and protocol types. You can also use a declaration to extend the behavior of an existing named type and to import symbols into your program that are declared elsewhere.
宣言は、新しい名前または構造物をあなたのプログラムに導入します。例えば、あなたは宣言を使うことで、関数やメソッドを導入したり、変数や定数を導入したり、そして列挙、構造体、クラス、そしてプロトコル型を定義します。あなたは、また、ある宣言を使うことで、既存の名前付きの型の振るまいを拡張することや、どこか他で宣言されるシンボルをあなたのプログラムへインポートすることができます。

In Swift, most declarations are also definitions in the sense that they are implemented or initialized at the same time they are declared. That said, because protocols don’t implement their members, most protocol members are declarations only. For convenience and because the distinction isn’t that important in Swift, the term declaration covers both declarations and definitions.
スウィフトにおいて、大部分の宣言はまた、それらが宣言されるのと同時にそれらが実装または初期化されるという意味で定義されます。とは言え、プロトコルがそれらのメンバーを実装しないので、大部分のプロトコル・メンバーは宣言だけです。便利さとその区別がスウィフトにおいてそんなに重要でないことから、用語宣言は、宣言と定義を含みます。

Grammar of a declaration
宣言の文法

declaration → import-declaration­

declaration → constant-declaration­

declaration → variable-declaration­

declaration → typealias-declaration­

declaration → function-declaration­

declaration → enum-declaration­

declaration → struct-declaration­

declaration → class-declaration­

declaration → protocol-declaration­

declaration → initializer-declaration­

declaration → deinitializer-declaration­

declaration → extension-declaration­

declaration → subscript-declaration­

declaration → operator-declaration­

declaration → precedence-group-declaration­

declarations → declaration­declarations­opt­

Top-Level Code
トップレベル・コード

The top-level code in a Swift source file consists of zero or more statements, declarations, and expressions. By default, variables, constants, and other named declarations that are declared at the top-level of a source file are accessible to code in every source file that is part of the same module. You can override this default behavior by marking the declaration with an access-level modifier, as described in Access Control Levels.
あるスウィフトソースコードにおけるトップレベル・コードは、０個以上の文、宣言、そして式から成ります。初期状態では、あるソースファイルのトップレベルで宣言される変数、定数、そして他の名前をつけられる宣言は、同じモジュールの一部であるすべてのソースファイルの中のコードにアクセス可能です。あなたは、アクセス制御ラベルで記述されるように、この初期状態のふるまいをその宣言をアクセス水準修飾子で印することによってオーバーライドすることができます。

Grammar of a top-level declaration
トップレベル宣言の文法

top-level-declaration → statements­opt­

Code Blocks
コード・ブロック

A code block is used by a variety of declarations and control structures to group statements together. It has the following form:
コード・ブロックは、いくつかの文をまとめるために、いろいろな宣言や制御構造で使われます。それは、以下の形式を持ちます： 

  • {
  •     statements
  • }

The statements inside a code block include declarations, expressions, and other kinds of statements and are executed in order of their appearance in source code.
コード・ブロックの内側の文は、宣言、式、そして他の種類の文を含みます、そしてソース・コードにおいてそれらの現れる順に実行されます。

Grammar of a code block
コードブロックの文法

code-block → {­statements­opt­}­

Import Declaration
インポート宣言

An import declaration lets you access symbols that are declared outside the current file. The basic form imports the entire module; it consists of the import keyword followed by a module name:
インポート宣言は、あなたに現在のファイルの外側で宣言されるシンボルにアクセスさせます。基本の形式は、そのモジュール全体をインポートします；それは、importキーワードとそれに続くモジュール名から成ります： 

  • import module

Providing more detail limits which symbols are imported—you can specify a specific submodule or a specific declaration within a module or submodule. When this detailed form is used, only the imported symbol (and not the module that declares it) is made available in the current scope.
より詳細な記述を提供することは、どのシンボルがインポートされるかを制限します ― あなたは、あるモジュールまたはサブモジュール内で、特定のサブモジュールまたは特定の宣言を指定することができます。この詳細な書式が使われるとき、インポートされたシンボルだけが（そしてそれを宣言するモジュールでなく）、現在のスコープにおいて利用可能にされます。 

  • import import kind module.symbol name
  • import module.submodule

Grammar of an import declaration
インポート宣言の文法

import-declaration → attributes­opt­import­import-kind­opt­import-path­

import-kind → typealias­ struct­ class­ enum­ protocol­ let­ var­ func­

import-path → import-path-identifier­ import-path-identifier­.­import-path­

import-path-identifier → identifier­ operator­

Constant Declaration
定数宣言

A constant declaration introduces a constant named value into your program. Constant declarations are declared using the let keyword and have the following form:
定数宣言は、名前をつけられた一定不変の値をあなたのプログラムにもたらします。定数宣言は、letキーワードを使用して宣言され、以下の形式を持ちます： 

  • let constant name: type = expression

A constant declaration defines an immutable binding between the constant name and the value of the initializer expression; after the value of a constant is set, it cannot be changed. That said, if a constant is initialized with a class object, the object itself can change, but the binding between the constant name and the object it refers to can’t.
定数宣言は、定数名とイニシャライザ式の値の間の不変の束縛を定義します；定数の値が設定されたあと、それは変わることができません。そうは言っても、定数がクラスオブジェクトで初期化されるならば、そのオブジェクト自体は変わることができます、しかし、定数名とそれが言及するオブジェクトの間の束縛はそうすることができません。

When a constant is declared at global scope, it must be initialized with a value. When a constant declaration occurs in the context of a function or method, it can be initialized later, as long as it is guaranteed to have a value set before the first time its value is read. When a constant declaration occurs in the context of a class or structure declaration, it is considered a constant property. Constant declarations are not computed properties and therefore do not have getters or setters.
定数がグローバルなスコープで宣言されるとき、それはひとつの値で初期化されなければなりません。定数宣言が関数またはメソッドの文脈において現れるとき、それは後で初期化されることができます、それがある値をその値が読み出される最初の時の前に設定されてしまっているよう保証する限りは。定数宣言がクラスまたは構造体宣言の文脈において起こるとき、それは定数プロパティとみなされます。定数宣言は、計算プロパティではなく、したがって、ゲッターまたはセッターを持ちません。

If the constant name of a constant declaration is a tuple pattern, the name of each item in the tuple is bound to the corresponding value in the initializer expression.
定数宣言の定数名がタプルパターンであるならば、タプルの中の各項目の名前は、イニシャライザ式の中の対応する値に縛りつけられます。

  1. let (firstNumber, secondNumber) = (10, 42)

In this example, firstNumber is a named constant for the value 10, and secondNumber is a named constant for the value 42. Both constants can now be used independently:
この例では、firstNumberは、値10のための名前をつけられた定数です、そして、secondNumberは値42のための名前をつけられた定数です。両方の定数は、今や独立して使われることができます：

  1. print("The first number is \(firstNumber).")
  2. // Prints "The first number is 10." （「最初の数は、10です。」を出力します）
  3. print("The second number is \(secondNumber).")
  4. // Prints "The second number is 42." （２番目の数は、42です。」を出力します）

The type annotation (: type) is optional in a constant declaration when the type of the constant name can be inferred, as described in Type Inference.
定数名の型が推論されることができるとき、型推論で記述されるように、型注釈（: type）は定数宣言において任意です。

To declare a constant type property, mark the declaration with the static declaration modifier. Type properties are discussed in Type Properties.
定数型プロパティを宣言するために、宣言にstatic宣言修飾子で印をつけてください。型プロパティは、型プロパティで議論されます。

For more information about constants and for guidance about when to use them, see Constants and Variables and Stored Properties.
定数の詳細について、そしていつそれらを使うべきかの手引きとして、定数と変数および格納プロパティを見てください。

Grammar of a constant declaration
定数宣言の文法

constant-declaration → attributes­opt­declaration-modifiers­opt­let­pattern-initializer-list­

pattern-initializer-list → pattern-initializer­ pattern-initializer­,­pattern-initializer-list­

pattern-initializer → pattern­initializer­opt­

initializer → =­expression­

Variable Declaration
変数の宣言

A variable declaration introduces a variable named value into your program and is declared using the var keyword.
変数宣言は、名前をつけられた変えられる値をあなたのプログラムにもたらします、そしてキーワードvarを使って宣言されます。

Variable declarations have several forms that declare different kinds of named, mutable values, including stored and computed variables and properties, stored variable and property observers, and static variable properties. The appropriate form to use depends on the scope at which the variable is declared and the kind of variable you intend to declare.
変数宣言はいくつかの形式を持ちます、それらは、格納および計算の変数およびプロパティ、格納である変数およびプロパティのオブザーバー、そして静的変数プロパティを含む、異なる種類の名前をつけられた可変の値を宣言します。使用するのに適切な形式は、その変数が宣言されるスコープとあなたが宣言するつもりである変数の種類に依存します。

You can override a property in a subclass by marking the subclass’s property declaration with the override declaration modifier, as described in Overriding.
あなたは、オーバーライドで記述されるように、、サブクラスのプロパティ宣言をoverride宣言修飾子で印することによってサブクラスの中のプロパティをオーバーライドすることができます。

Stored Variables and Stored Variable Properties
格納変数と格納変数プロパティ

The following form declares a stored variable or stored variable property:
以下の形式は、格納変数または格納変数プロパティを宣言します： 

  • var variable name: type = expression

You define this form of a variable declaration at global scope, the local scope of a function, or in the context of a class or structure declaration. When a variable declaration of this form is declared at global scope or the local scope of a function, it is referred to as a stored variable. When it is declared in the context of a class or structure declaration, it is referred to as a stored variable property.
あなたは、変数宣言のこの形式を、グローバルなスコープ、関数のローカルなスコープで、またはクラスおよび構造体宣言の文脈において定義します。この形式の変数の宣言がグローバルなスコープまたは関数のローカルなスコープで宣言されるとき、それは格納変数と呼ばれます。それがクラスまたは構造体宣言の文脈において宣言されるとき、それは格納変数プロパティと呼ばれます。

The initializer expression can’t be present in a protocol declaration, but in all other contexts, the initializer expression is optional. That said, if no initializer expression is present, the variable declaration must include an explicit type annotation (: type).
イニシャライザ式はプロトコル宣言に含まれることはできません、しかし全ての他の文脈ではそうではありません、イニシャライザ式は任意です。とは言え、イニシャライザ式が存在しないならば、変数の宣言は明確な型注釈（: type）を含まなければなりません。

As with constant declarations, if the variable name is a tuple pattern, the name of each item in the tuple is bound to the corresponding value in the initializer expression.
定数宣言と同様に、変数名がタプルパターンであるならば、タプルの中の各項目の名前はイニシャライザ式の対応する値に縛りつけられます。

As their names suggest, the value of a stored variable or a stored variable property is stored in memory.
それらの名前が示すように、格納変数または格納変数プロパティの値はメモリに格納されます。

Computed Variables and Computed Properties
計算変数と計算プロパティ

The following form declares a computed variable or computed property:
以下の形式は、計算変数または計算プロパティを宣言します： 

  • var variable name: type {
  •     get {
  •         statements
  •     }
  •     set(setter name) {
  •         statements
  •     }
  • }

You define this form of a variable declaration at global scope, the local scope of a function, or in the context of a class, structure, enumeration, or extension declaration. When a variable declaration of this form is declared at global scope or the local scope of a function, it is referred to as a computed variable. When it is declared in the context of a class, structure, or extension declaration, it is referred to as a computed property.
あなたは、変数宣言のこの形式を、グローバルなスコープ、関数のローカルなスコープで、またはクラス、構造体、列挙、および拡張宣言の文脈において定義します。この形式の変数の宣言がグローバルなスコープまたは関数のローカルなスコープで宣言されるとき、それは計算変数と呼ばれます。それがクラス、構造体、または拡張宣言の文脈において宣言されるとき、それは計算プロパティと呼ばれます。

The getter is used to read the value, and the setter is used to write the value. The setter clause is optional, and when only a getter is needed, you can omit both clauses and simply return the requested value directly, as described in Read-Only Computed Properties. But if you provide a setter clause, you must also provide a getter clause.
ゲッターが値を読むために使われます、そしてセッターが値を書くために使われます。セッター節は任意です、そして、ゲッターだけが必要なとき、あなたは両方の節を省略することができます、そして読み出し専用の計算プロパティで記述されるように、単に直接に要請された値を返すことができます。しかしあなたがセッター節を提供するならば、あなた同様にゲッター節を提供しなければなりません。

The setter name and enclosing parentheses is optional. If you provide a setter name, it is used as the name of the parameter to the setter. If you do not provide a setter name, the default parameter name to the setter is newValue, as described in Shorthand Setter Declaration.
セッター名、そして囲んでいる丸括弧は任意です。あなたがセッター名を提供するならば、それがセッターにパラメータの名前として使われます。あなたがセッター名を提供しないならば、短縮形セッター宣言で記述されるように、セッターへの省略時のパラメータ名はnewValueです。

Unlike stored named values and stored variable properties, the value of a computed named value or a computed property is not stored in memory.
格納される名前を付けられた値および格納変数プロパティと違って、計算される名前を付けられた値または計算プロパティの値は、メモリに格納されません。

For more information and to see examples of computed properties, see Computed Properties.
より多くの情報のために、そして、計算プロパティの例を見るために、計算プロパティを見てください。

Stored Variable Observers and Property Observers
格納された変数オブザーバーとプロパティオブザーバー

You can also declare a stored variable or property with willSet and didSet observers. A stored variable or property declared with observers has the following form:
あなたは、また、willSetとdidSetオブザーバーをもつ格納変数やプロパティを宣言することができます。オブザーバーとともに宣言される格納変数やプロパティは、以下の形式を持ちます： 

  • var variable name: type = expression {
  •     willSet(setter name) {
  •         statements
  •     }
  •     didSet(setter name) {
  •         statements
  •     }
  • }

You define this form of a variable declaration at global scope, the local scope of a function, or in the context of a class or structure declaration. When a variable declaration of this form is declared at global scope or the local scope of a function, the observers are referred to as stored variable observers. When it is declared in the context of a class or structure declaration, the observers are referred to as property observers.
あなたは、変数宣言のこの形式を、グローバルなスコープ、関数のローカルなスコープで、またはクラスおよび構造体宣言の文脈において定義します。この形式の変数の宣言がグローバルなスコープまたは関数のローカルスコープで宣言されるとき、オブザーバーは格納変数オブザーバーと呼ばれます。それがクラスまたは構造体宣言の文脈において宣言されるとき、オブザーバーはプロパティオブザーバーと呼ばれます。

You can add property observers to any stored property. You can also add property observers to any inherited property (whether stored or computed) by overriding the property within a subclass, as described in Overriding Property Observers.
あなたは、プロパティオブザーバーをどんな格納プロパティにでも加えることができます。あなたは、また、プロパティオブザーバーをあらゆる継承されたプロパティ（格納されるか、計算されるかに関係なく）にでも加えることが、サブクラスの内部でプロパティをオーバーライドすることによって、プロパティオブザーバーのオーバーライドで記述されるように、可能です。

The initializer expression is optional in the context of a class or structure declaration, but required elsewhere. The type annotation is optional when the type can be inferred from the initializer expression.
イニシャライザ式は、クラスまたは構造体宣言の文脈では任意です、しかしその他では必須です。型注釈は、その型が初期化式から推論されることができる場合は随意です。

The willSet and didSet observers provide a way to observe (and to respond appropriately) when the value of a variable or property is being set. The observers are not called when the variable or property is first initialized. Instead, they are called only when the value is set outside of an initialization context.
willSetとdidSetオブザーバーは、変数またはプロパティの値が設定されている時に監視する（そして適切に応答する）方法を提供します。オブザーバーは、変数またはプロパティが最初に初期化されるときには呼ばれません。そうではなく、値が初期化の文脈の外で設定されるときにだけ、それらは呼ばれます。

A willSet observer is called just before the value of the variable or property is set. The new value is passed to the willSet observer as a constant, and therefore it can’t be changed in the implementation of the willSet clause. The didSet observer is called immediately after the new value is set. In contrast to the willSet observer, the old value of the variable or property is passed to the didSet observer in case you still need access to it. That said, if you assign a value to a variable or property within its own didSet observer clause, that new value that you assign will replace the one that was just set and passed to the willSet observer.
willSetオブザーバーは、変数またはプロパティの値が設定される直前に呼ばれます。新しい値は、定数としてwillSetオブザーバーに渡されます、したがって、それはwillSet節の実装の中で変更されることができません。didSetオブザーバーは、新しい値が設定された直後に呼ばれます。willSetオブザーバーと対照的に、変数またはプロパティの古い値が、あなたがまだそれへのアクセスを必要とする場合に備えてdidSetオブザーバーに渡されます。とは言え、あなたがdidSetオブザーバー節自身の内部である値を変数またはプロパティに代入するならば、あなたが代入するその新しい値は、ちょうど設定されたばかりのwillSetオブザーバーに渡されたものを置き換えることになります。

The setter name and enclosing parentheses in the willSet and didSet clauses are optional. If you provide setter names, they are used as the parameter names to the willSet and didSet observers. If you do not provide setter names, the default parameter name to the willSet observer is newValue and the default parameter name to the didSet observer is oldValue.
willSetとdidSet節の中のセッター名と囲んでいる丸括弧は任意です。あなたがセッター名を提供するならば、それらがwillSetとdidSetオブザーバーへのパラメータ名として使われます。あなたがセッター名を提供しないならば、willSetオブザーバーへの初期状態でのパラメータ名はnewValueです、そして、didSetオブザーバーへの初期状態でのパラメータ名はoldValueです。

The didSet clause is optional when you provide a willSet clause. Likewise, the willSet clause is optional when you provide a didSet clause.
あなたがwillSet節を提供するとき、didSet節は任意です。同様に、あなたがdidSet節を提供するとき、willSet節は任意です。

For more information and to see an example of how to use property observers, see Property Observers.
より多くの情報のために、そして、プロパティオブザーバーを使う方法の例を見るために、プロパティオブザーバーを見てください。

Type Variable Properties
型変数プロパティ

To declare a type variable property, mark the declaration with the static declaration modifier. Classes may mark type computed properties with the class declaration modifier instead to allow subclasses to override the superclass’s implementation. Type properties are discussed in Type Properties.
型変数プロパティを宣言するために、宣言にstatic宣言修飾子で印をつけてください。クラスは型計算プロパティを代わりにclass宣言修飾子で印をつけて、サブクラスがスーパークラスの実装をオーバーライドすることを許可することができます。型プロパティは、型プロパティで議論されます。

Grammar of a variable declaration
変数宣言の文法

variable-declaration → variable-declaration-head­pattern-initializer-list­

variable-declaration → variable-declaration-head­variable-name­type-annotation­code-block­

variable-declaration → variable-declaration-head­variable-name­type-annotation­getter-setter-block­

variable-declaration → variable-declaration-head­variable-name­type-annotation­getter-setter-keyword-block­

variable-declaration → variable-declaration-head­variable-name­initializer­willSet-didSet-block­

variable-declaration → variable-declaration-head­variable-name­type-annotation­initializer­opt­willSet-didSet-block­

variable-declaration-head → attributes­opt­declaration-modifiers­opt­var­

variable-name → identifier­

getter-setter-block → code-block­

getter-setter-block → {­getter-clause­setter-clause­opt­}­

getter-setter-block → {­setter-clause­getter-clause­}­

getter-clause → attributes­opt­mutation-modifier­opt­get­code-block­

setter-clause → attributes­opt­mutation-modifier­opt­set­setter-name­opt­code-block­

setter-name → (­identifier­)­

getter-setter-keyword-block → {­getter-keyword-clause­setter-keyword-clause­opt­}­

getter-setter-keyword-block → {­setter-keyword-clause­getter-keyword-clause­}­

getter-keyword-clause → attributes­opt­mutation-modifier­opt­get­

setter-keyword-clause → attributes­opt­mutation-modifier­opt­set­

willSet-didSet-block → {­willSet-clause­didSet-clause­opt­}­

willSet-didSet-block → {­didSet-clause­willSet-clause­opt­}­

willSet-clause → attributes­opt­willSet­setter-name­opt­code-block­

didSet-clause → attributes­opt­didSet­setter-name­opt­code-block­

Type Alias Declaration
型エイリアス宣言

A type alias declaration introduces a named alias of an existing type into your program. Type alias declarations are declared using the typealias keyword and have the following form:
型エイリアス宣言は、あなたのプログラムに既存の型の名前をつけられたエイリアスを導入します。型エイリアス宣言は、キーワードtypealiasを使って宣言されます、そして以下の形式を持ちます： 

  • typealias name = existing type

After a type alias is declared, the aliased name can be used instead of the existing type everywhere in your program. The existing type can be a named type or a compound type. Type aliases do not create new types; they simply allow a name to refer to an existing type.
型エイリアスが宣言されたあと、エイリアス（別名）にされた名前は、あなたのプログラムの至る所で既存の型の代わりに使われることができます。既存の型は、名前付きの型または複合の型でありえます。型エイリアスは、新しい型を作成しません；それらは、単にある名前が既存の型に言及できるようにします。

A type alias declaration can use generic parameters to give a name to an existing generic type. The type alias can provide concrete types for some or all of the generic parameters of the existing type. For example:
型エイリアス宣言は、総称体パラメータを使ってある名前を既存の総称体型に与えることができます。型エイリアスは、既存の型の総称体パラメータの一部またはすべてに具象型を提供できます。例えば：

  1. typealias StringDictionary<Value> = Dictionary<String, Value>
  3. // The following dictionaries have the same type. （以下の宣言は同じ型を持ちます。）
  4. var dictionary1: StringDictionary<Int> = [:]
  5. var dictionary2: Dictionary<String, Int> = [:]

When a type alias is declared with generic parameters, the constraints on those parameters must match exactly the constraints on the existing type’s generic parameters. For example:
ある型エイリアスが総称体パラメータで宣言されるとき、それらのパラメータ上の制約は厳密に既存の型の持つ総称体パラメータ上の制約に一致しなければなりません。例えば：

  1. typealias DictionaryOfInts<Key: Hashable> = Dictionary<Key, Int>

Because the type alias and the existing type can be used interchangeably, the type alias can’t introduce additional generic constraints.
型エイリアスと既存の型は交換可能に使われることができるので、型エイリアスは追加的な総称体制約を導入することはできません。

Inside a protocol declaration, a type alias can give a shorter and more convenient name to a type that is used frequently. For example:
プロトコル宣言の内部で、型エイリアスはより短くより便利な名前を頻繁に使われる型に提供できます。例えば：

  1. protocol Sequence {
  2. associatedtype Iterator: IteratorProtocol
  3. typealias Element = Iterator.Element
  4. }
  6. func sum<T: Sequence>(_ sequence: T) -> Int where T.Element == Int {
  7. // ...
  8. }

Without this type alias, the sum function would have to refer to the associated type as T.Iterator.Element instead of T.Element.
この型エイリアスな時では、sum関数は関連値をT.Iterator.Elementのように参照しなければならないでしょう、T.Elementではなく。

See also Protocol Associated Type Declaration.
また、プロトコル関連型宣言を見てください。

Grammar of a type alias declaration
型エイリアス宣言の文法

typealias-declaration → attributes­opt­access-level-modifier­opt­typealias­typealias-name­generic-parameter-clause­opt­typealias-assignment­

typealias-name → identifier­

typealias-assignment → =­type­

Function Declaration
関数宣言

A function declaration introduces a function or method into your program. A function declared in the context of class, structure, enumeration, or protocol is referred to as a method. Function declarations are declared using the func keyword and have the following form:
関数宣言は、あなたのプログラムに関数またはメソッドをもたらします。クラス、構造体、列挙、またはプロトコルの文脈において宣言される関数は、メソッドとして言及されることができます。関数宣言は、キーワードfuncを使って宣言されます、そして以下の形式を持ちます： 

  • func function name(parameters) -> return type {
  •     statements
  • }

If the function has a return type of Void, the return type can be omitted as follows:
関数がVoidの戻り型を持つならば、次のように戻り型は省略されることができます： 

  • func function name(parameters) {
  •     statements
  • }

The type of each parameter must be included—it can’t be inferred. If you write inout in front of a parameter’s type, the parameter can be modified inside the scope of the function. In-out parameters are discussed in detail in In-Out Parameters, below.
各パラメータの型は、含められなければなりません ― それは、推論されることができません。あなたがinoutをパラメータの型のすぐ前に書くならば、そのパラメータは関数のスコープ内部において修正されることができます。in-outパラメータは詳細に、下で、in-outパラメータにおいて議論されます。

Functions can return multiple values using a tuple type as the return type of the function.
関数は、関数の戻り型としてタプル型を使って、複数の値を返すことができます。

A function definition can appear inside another function declaration. This kind of function is known as a nested function.
関数定義は、別の関数宣言の内部に現れることができます。この種類の関数は、入れ子にされた関数として知られています。

A nested function is nonescaping if it captures a value that is guaranteed to never escape—such as an in-out parameter—or passed as a nonescaping function argument. Otherwise, the nested function is an escaping function.
入れ子にされた関数は、決して脱出しないことを保証される値 — 例えばin-outパラメータ — を、または非脱出関数引数として渡される値を、もしそれがキャプチャするならば非脱出です。それ以外では、入れ子にされた関数は脱出関数です。

For a discussion of nested functions, see Nested Functions.
入れ子にされた関数の議論のために、入れ子にされた関数を見てください。

Parameter Names
パラメータ名

Function parameters are a comma-separated list where each parameter has one of several forms. The order of arguments in a function call must match the order of parameters in the function’s declaration. The simplest entry in a parameter list has the following form:
関数パラメータはひとつの「コンマ区切り」のリストです、そこにおいて各パラメータはいくつかの書式のうちの１つを持ちます。関数呼び出しにおける引数の順序は、関数の宣言におけるパラメータの順番と一致しなければなりません。パラメータ・リストの中の最も単純な項目は、以下の形式を持ちます： 

  • parameter name: parameter type

A parameter has a name, which is used within the function body, as well as an argument label, which is used when calling the function or method. By default, parameter names are also used as argument labels. For example:
パラメータは名前を持ちます、それは関数本文内部で使われます、それだけでなく引数ラベルも、それは関数やメソッドが呼ばれる時に使われます。特に何もしなければ、パラメータ名はまた引数ラベルとしても使われます。例えば：

  1. func f(x: Int, y: Int) -> Int { return x + y }
  2. f(x: 1, y: 2) // both x and y are labeled （xとyの両方ともラベルをつけられます）

You can override the default behavior for argument labels with one of the following forms:
あなたは引数ラベルに対する初期状態の挙動をオーバーライドすることが以下の形式の１つで可能です： 

  • argument label parameter name: parameter type
  • _ parameter name: parameter type

A name before the parameter name gives the parameter an explicit argument label, which can be different from the parameter name. The corresponding argument must use the given argument label in function or method calls.
パラメータ名の前の名前は、そのパラメータに明示的な引数ラベルを与えます、それはパラメーター名と異なるものにできます。対応する引数は、この引数ラベルを関数またはメソッドの呼び出しにおいて使わなければなりません。

An underscore (_) before a parameter name suppresses the argument label. The corresponding argument must have no label in function or method calls.
パラメーター名の前のアンダースコア（_）は、引数ラベルを抑制します。対応する引数には、関数またはメソッドの呼び出しにおいてラベルがあってはなりません。

  1. func repeatGreeting(_ greeting: String, count n: Int) { /* Greet n times  （n回あいさつします）*/ }
  2. repeatGreeting("Hello, world!", count: 2) // count is labeled, greeting is not （countはラベルを付けられます、greetingは違います）

In-Out Parameters
In-Outパラメータ

In-out parameters are passed as follows:
in-outパラメータは、以下のように渡されます：

  1. When the function is called, the value of the argument is copied.
    関数が呼ばれる時、その引数の値はコピー（複製）をつくられます。

  2. In the body of the function, the copy is modified.
    関数の本体において、そのコピーが修正されます。

  3. When the function returns, the copy’s value is assigned to the original argument.
    関数が戻る時、コピーの値はそのオリジナルの（元の）引数に代入されます。

This behavior is known as copy-in copy-out or call by value result. For example, when a computed property or a property with observers is passed as an in-out parameter, its getter is called as part of the function call and its setter is called as part of the function return.
この挙動は、コピーイン・コピーアウトまたは結果値による呼び出しとして知られます。例えば、計算プロパティまたはオブザーバを持つプロパティがin-outパラメータとして渡される時、それのゲッターは関数呼び出しの一部として呼び出され、それのセッターは関数の戻りの一部として呼び出されます。

As an optimization, when the argument is a value stored at a physical address in memory, the same memory location is used both inside and outside the function body. The optimized behavior is known as call by reference; it satisfies all of the requirements of the copy-in copy-out model while removing the overhead of copying. Write your code using the model given by copy-in copy-out, without depending on the call-by-reference optimization, so that it behaves correctly with or without the optimization.
ひとつの最適化として、引数がメモリにおいて物理的番地に格納される値である時、同じメモリ位置は関数本体の内側と外側の両方で使われます。この最適化挙動は、参照呼び出しとして知られます；それはコピーイン・コピーアウトモデルの要件の全てを満足させる一方でコピーすることのオーバーヘッド（間接的経費）を取り除きます。あなたのコードをコピーイン・コピーアウトによって与えられるモデルを使って描いてください、参照呼び出し最適化に依存することなしに、そうすることでそれは最適化があってもなくても正しく振舞います。

Within a function, don’t access a value that was passed as an in-out argument, even if the original value is available in the current scope. Accessing the original is a simultaneous access of the value, which violates Swift’s memory exclusivity guarantee. For the same reason, you can’t pass the same value to multiple in-out parameters.
関数内部で、in-out引数として渡された値にアクセスしないでください、たとえその元の値が現在のスコープにおいて利用可能であるとしてもです。元のものにアクセスすることは、その値に対する同時的なアクセスです、それはスウィフトのメモリ排他保証を破ります。同じ理由のために、あなたは複数のin-outパラメータに対して同じ値を渡すことができません。

For more information about memory safety and memory exclusivity, see Memory Safety.
メモリ安全とメモリ排他についての更なる情報として、メモリ安全を見てください。

A closure or nested function that captures an in-out parameter must be nonescaping. If you need to capture an in-out parameter without mutating it or to observe changes made by other code, use a capture list to explicitly capture the parameter immutably.
in-outパラメータをキャプチャするクロージャまたは入れ子にされた関数は、非脱出でなければなりません。あなたがin-outパラメータをキャプチャする必要がそれを変化させることなしにまたは他のコードによってなされる変更を監視するためにあるならば、キャプチャリストを使うことで明示的にそのパラメータを不変にキャプチャしてください。

  1. func someFunction(a: inout Int) -> () -> Int {
  2. return { [a] in return a + 1 }
  3. }

If you need to capture and mutate an in-out parameter, use an explicit local copy, such as in multithreaded code that ensures all mutation has finished before the function returns.
あなたがin-outパラメータをキャプチャして変化させる必要があるならば、明示的なローカルコピーを使ってください、例えばすべての変化がその関数が返るまえに完了してしまっていることを保証するマルチスレッド化されたコードにおいてなど。

  1. func multithreadedFunction(queue: DispatchQueue, x: inout Int) {
  2. // Make a local copy and manually copy it back. （ローカルコピーを作って手動でそれを元へコピーする）
  3. var localX = x
  4. defer { x = localX }
  6. // Operate on localX asynchronously, then wait before returning. （非同期にlocalXを処理を施す、それから返すまえに待機する）
  7. queue.async { someMutatingOperation(&localX) }
  8. queue.sync {}
  9. }

For more discussion and examples of in-out parameters, see In-Out Parameters.
in-outパラメータの議論と例のために、in-outパラメータを見てください。

Special Kinds of Parameters
特別な種類のパラメータ

Parameters can be ignored, take a variable number of values, and provide default values using the following forms:
パラメータは、無視されること、可変の数の値をとること、そして以下の形式を使って省略時の値を提供することができます： 

  • _ : parameter type
  • parameter name: parameter type...
  • parameter name: parameter type = default argument value

An underscore (_) parameter is explicitly ignored and can’t be accessed within the body of the function.
ひとつのアンダースコア（_）のパラメータは、明確に無視されます、そして関数の本体内でアクセスされることができません。

A parameter with a base type name followed immediately by three dots (...) is understood as a variadic parameter. A function can have at most one variadic parameter. A variadic parameter is treated as an array that contains elements of the base type name. For instance, the variadic parameter Int... is treated as [Int]. For an example that uses a variadic parameter, see Variadic Parameters.
基本の型の名前に直ちに３つの点（...）が続くパラメータは、可変長パラメータとして理解されます。関数は最大で１つの可変長パラメータしか持つことができません。可変長パラメータは、基本の型の名前の要素たちが入っている配列とみなされます。たとえば、可変長パラメータInt...は[Int]とみなされます。可変長パラメータを使う例のために、可変長パラメータを見てください。

A parameter with an equals sign (=) and an expression after its type is understood to have a default value of the given expression. The given expression is evaluated when the function is called. If the parameter is omitted when calling the function, the default value is used instead.
その型の後に等号（=）と式をもつパラメータは、与えられた式からなる省略時の値を持つと理解されます。与えられた式は、関数が呼び出される時に評価されます。パラメーターが関数呼び出し時に省略されるならば、省略時の値が代わりに使われます。

  1. func f(x: Int = 42) -> Int { return x }
  2. f() // Valid, uses default value （有効、省略時の値を使う）
  3. f(x: 7) // Valid, uses the value provided （有効、提供された値を使う）
  4. f(7) // Invalid, missing argument label （無効、引数ラベルが欠けている）

Special Kinds of Methods
特別な種類のメソッド

Methods on an enumeration or a structure that modify self must be marked with the mutating declaration modifier.
列挙または構造体でのselfを修正するメソッドは、mutating宣言修飾子で印されなければなりません。

Methods that override a superclass method must be marked with the override declaration modifier. It’s a compile-time error to override a method without the override modifier or to use the override modifier on a method that doesn’t override a superclass method.
スーパークラスのメソッドをオーバーライドするメソッドは、override宣言修飾子で印されなければなりません。override宣言修飾子なしでメソッドをオーバーライドするか、スーパークラスメソッドをオーバーライドしないメソッドでoverride宣言修飾子を使用することは、コンパイル時エラーです。

Methods associated with a type rather than an instance of a type must be marked with the static declaration modifier for enumerations and structures, or with either the static or class declaration modifier for classes. A class type method marked with the class declaration modifier can be overridden by a subclass implementation; a class type method marked with static can’t be overridden.
ある型のインスタンスとではなく、ある型と結び付けられるメソッドは、列挙と構造体ではstatic宣言修飾子で、またクラスではstaticまたはclassどちらかの宣言修飾子で印されなければなりません。class宣言修飾子で印されるクラス型メソッドは、サブクラス実装によってオーバーライドされることができます；staticで印されるクラス型メソッドはオーバーライドされることができません。

Throwing Functions and Methods
スローを行う関数とメソッド

Functions and methods that can throw an error must be marked with the throws keyword. These functions and methods are known as throwing functions and throwing methods. They have the following form:
エラーをスローできる関数とメソッドは、throwsキーワードで印されなければなりません。これらの関数とメソッドはスロー関数およびスローメソッドとして知られます。これらは以下の形式を持ちます： 

  • func function name(parameters) throws -> return type {
  •     statements
  • }

Calls to a throwing function or method must be wrapped in a try or try! expression (that is, in the scope of a try or try! operator).
スロー関数またはメソッドに対する呼び出しは、tryまたはtry!式の中に（即ち、tryまたはtry!演算子のスコープの中に）包まれなければなりません。

The throws keyword is part of a function’s type, and nonthrowing functions are subtypes of throwing functions. As a result, you can use a nonthrowing function in the same places as a throwing one.
throwsキーワードは関数の型の一部です、そしてスローを行わない関数はスロー関数の下位型です。結果として、あなたは非スロー関数をスロー関数と同じ場所で使うことができます。

You can’t overload a function based only on whether the function can throw an error. That said, you can overload a function based on whether a function parameter can throw an error.
あなたはある関数を、その関数がエラーをスローできるかどうかのみに基づいてオーバーロードできません。とは言え、あなたは関数を、ある関数パラメーターがエラーをスローできるかどうかに基づいてオーバーロードすることができます。

A throwing method can’t override a nonthrowing method, and a throwing method can’t satisfy a protocol requirement for a nonthrowing method. That said, a nonthrowing method can override a throwing method, and a nonthrowing method can satisfy a protocol requirement for a throwing method.
スローメソッドは、非スローメソッドをオーバーライドすることができません、そしてスローメソッドは、非スローメソッド用のプロトコル要件を満たすことができません。とは言え、非スローメソッドはスローメソッドをオーバーライドできます、そして非スローメソッドはスローメソッドのプロトコル要件を満たすことができます。

Rethrowing Functions and Methods
再スローを行う関数とメソッド

A function or method can be declared with the rethrows keyword to indicate that it throws an error only if one of its function parameters throws an error. These functions and methods are known as rethrowing functions and rethrowing methods. Rethrowing functions and methods must have at least one throwing function parameter.
関数またはメソッドは、rethrowsキーワードとともに宣言されて、それの関数パラメータの１つがエラーをスローする場合にのみそれがエラーをスローすることを指し示すことができます。これらの関数とメソッドは、再スロー関数と再スローメソッドとして知られています。再スロー関数とメソッドは、少なくとも１つのスロー関数パラメーターを持たなければなりません。

  1. func someFunction(callback: () throws -> Void) rethrows {
  2. try callback()
  3. }

A rethrowing function or method can contain a throw statement only inside a catch clause. This lets you call the throwing function inside a do-catch block and handle errors in the catch clause by throwing a different error. In addition, the catch clause must handle only errors thrown by one of the rethrowing function’s throwing parameters. For example, the following is invalid because the catch clause would handle the error thrown by alwaysThrows().
再度スローする関数やメソッドは、throw文をcatch節の内部にのみ含むことができます。これは、あなたにスロー関数をdo-catchプロックの内部で呼び出させ、そのcatch節において異なるエラーをスローすることによって、エラーを取り扱わせます。加えて、そのcatch節はスロー関数の持つスローパラメータの１つによってスローされるエラーのみを取り扱わなければなりません。例えば、以下のものは無効です、なぜならcatch節がalwaysThrows()によってスローされるエラーを取り扱おうとするからです。

  1. func alwaysThrows() throws {
  2. throw SomeError.error
  3. }
  4. func someFunction(callback: () throws -> Void) rethrows {
  5. do {
  6. try callback()
  7. try alwaysThrows() // Invalid, alwaysThrows() isn't a throwing parameter （無効、alwaysThrows()はスローパラメータではありません）
  8. } catch {
  9. throw AnotherError.error
  10. }
  11. }

A throwing method can’t override a rethrowing method, and a throwing method can’t satisfy a protocol requirement for a rethrowing method. That said, a rethrowing method can override a throwing method, and a rethrowing method can satisfy a protocol requirement for a throwing method.
スローメソッドは、再スローメソッドをオーバーライドできません、そしてスローメソッドは再スローメソッド用のプロトコル要件を満たすことができません。とは言え、再スローメソッドはスローメソッドをオーバーライドできます、そして再スローメソッドはスローメソッド用のプロトコル要件を満たすことができます。

Functions that Never Return
決して返らない関数

Swift defines a Never type, which indicates that a function or method doesn’t return to its caller. Functions and methods with the Never return type are called nonreturning. Nonreturning functions and methods either cause an irrecoverable error or begin a sequence of work that continues indefinitely. This means that code that would otherwise run immediately after the call is never executed. Throwing and rethrowing functions can transfer program control to an appropriate catch block, even when they are nonreturning.
スウィフトはNever型を定義します、それはある関数またはメソッドがそれの呼び出し側に帰らないことを指し示します。Never戻り型を持つ関数およびメソッドは、非復帰と呼ばれます。非復帰関数およびメソッドは、回復不能のエラーを起こすかまたは無期限に続く一連の作業を始めるかのどちらかです。これが意味するのは、そうでなければ呼び出しの直後に動作するコードは、決して実行されないということです。スローおよび再スロー関数は、制御を適切なcatchプロックに移すことができます、それらが非復帰である場合でさえも。

A nonreturning function or method can be called to conclude the else clause of a guard statement, as discussed in Guard Statement.
非復帰関数およびメソッドは、guard文のelse節で終わるために呼び出されることができます、guard文で議論されるように。

You can override a nonreturning method, but the new method must preserve its return type and nonreturning behavior.
あなたは非復帰メソッドをオーバーライドすることができます、しかし新しいメソッドはそれの戻り型と非復帰挙動を維持しなければなりません。

Grammar of a function declaration
関数宣言の文法

function-declaration → function-head­function-name­generic-parameter-clause­opt­function-signature­generic-where-clause­opt­function-body­opt­

function-head → attributes­opt­declaration-modifiers­opt­func­

function-name → identifier­ operator­

function-signature → parameter-clause­throws­opt­function-result­opt­

function-signature → parameter-clause­rethrows­function-result­opt­

function-result → ->­attributes­opt­type­

function-body → code-block­

parameter-clause → (­)­ (­parameter-list­)­

parameter-list → parameter­ parameter­,­parameter-list­

parameter → external-parameter-name­opt­local-parameter-name­type-annotation­default-argument-clause­opt­

parameter → external-parameter-name­opt­local-parameter-name­type-annotation­

parameter → external-parameter-name­opt­local-parameter-name­type-annotation­...­

external-parameter-name → identifier­

local-parameter-name → identifier­

default-argument-clause → =­expression­

Enumeration Declaration
列挙宣言

An enumeration declaration introduces a named enumeration type into your program.
列挙宣言は、名前をつけられた列挙型をあなたのプログラムに導入します。

Enumeration declarations have two basic forms and are declared using the enum keyword. The body of an enumeration declared using either form contains zero or more values—called enumeration cases—and any number of declarations, including computed properties, instance methods, type methods, initializers, type aliases, and even other enumeration, structure, and class declarations. Enumeration declarations can’t contain deinitializer or protocol declarations.
列挙宣言は、２つの基本の形式を持ち、キーワードenumを使って宣言されます。どちらの形式を使って宣言される列挙宣言の本文でも、０以上の値 ― 列挙ケース節と呼ばれるもの ― および任意の数の宣言から成っていて、計算プロパティ、インスタンスメソッド、型メソッド、イニシャライザ、型エイリアス、そして他の列挙、構造体、およびクラス宣言さえも含められます。列挙宣言は、デイニシャライザまたはプロトコル宣言を含むことができません。

Enumeration types can adopt any number of protocols, but can’t inherit from classes, structures, or other enumerations.
列挙型は、任意の数のプロトコルに準拠することができます、しかしクラス、構造体、または他の列挙から継承することはできません。

Unlike classes and structures, enumeration types do not have an implicitly provided default initializer; all initializers must be declared explicitly. Initializers can delegate to other initializers in the enumeration, but the initialization process is complete only after an initializer assigns one of the enumeration cases to self.
クラスや構造体と違って、列挙型には、暗黙のうちに提供される省略時のイニシャライザがありません；全てのイニシャライザは、明確に宣言されなければなりません。イニシャライザは、その列挙の中の他のイニシャライザに委任することができます、しかしその初期化処理はあるイニシャライザが列挙ケース節のうちの１つをselfに代入した後になって初めて終了します。

Like structures but unlike classes, enumerations are value types; instances of an enumeration are copied when assigned to variables or constants, or when passed as arguments to a function call. For information about value types, see Structures and Enumerations Are Value Types.
構造体のように、しかしクラスとは違い、列挙は値型です；列挙のインスタンスは、変数や定数に代入されるとき、または関数呼び出しに引数として渡されるときにコピーされます。値型に関して詳しくは、構造体と列挙は値型ですを見てください。

You can extend the behavior of an enumeration type with an extension declaration, as discussed in Extension Declaration.
あなたは列挙型の挙動を拡張宣言を使って拡張することができます、拡張宣言で議論されるように。

Enumerations with Cases of Any Type
随意の型のケース節をもつ列挙

The following form declares an enumeration type that contains enumeration cases of any type:
以下の形式は、随意の型の列挙ケース節を含む列挙型を宣言します： 

  • enum enumeration name: adopted protocols {
  •     case enumeration case 1
  •     case enumeration case 2(associated value types)
  • }

Enumerations declared in this form are sometimes called discriminated unions in other programming languages.
この形式で宣言される列挙は、時として他のプログラミング言語では判別共用体と呼ばれています。

In this form, each case block consists of the case keyword followed by one or more enumeration cases, separated by commas. The name of each case must be unique. Each case can also specify that it stores values of a given type. These types are specified in the associated value types tuple, immediately following the name of the case.
この形式では、それぞれのケース節ブロックはキーワードcaseとそれに続く一つ以上の、コンマで区切られた、列挙ケース節から成ります。各ケース節の名前は、固有でなければなりません。各ケース節は、また、それが特定の型の値を格納することを示すことができます。これらの型は、ケース節の名前の直後に、それら関連値型のタプルを使って指定されます。

Enumeration cases that store associated values can be used as functions that create instances of the enumeration with the specified associated values. And just like functions, you can get a reference to an enumeration case and apply it later in your code.
関連値を格納する列挙ケース節は、関数として使われることができ、それは指定された関連値を持つその列挙のインスタンスを作成します。さらにまさに関数のように、あなたはある列挙ケース節の参照を得ることができ、それを後であなたのコードに応用することができます。

  1. enum Number {
  2. case integer(Int)
  3. case real(Double)
  4. }
  5. let f = Number.integer
  6. // f is a function of type (Int) -> Number （fは型(Int) -> Numberの関数です）
  8. // Apply f to create an array of Number instances with integer values （fを適用して整数値を持つNumberインスタンスからなる配列を作成する）
  9. let evenInts: [Number] = [0, 2, 4, 6].map(f)

For more information and to see examples of cases with associated value types, see Associated Values.
より多くの情報のために、そして関連値型をもつケース節の例を見るために、関連値を見てください。

Enumerations with Indirection
間接参照を持つ列挙

Enumerations can have a recursive structure, that is, they can have cases with associated values that are instances of the enumeration type itself. However, instances of enumeration types have value semantics, which means they have a fixed layout in memory. To support recursion, the compiler must insert a layer of indirection.
列挙は、再帰構造を持つことができます、すなわち、それは、その列挙型それ自身のインスタンスである関連値を伴うケース節を持つことができます。しかしながら、列挙型のインスタンスは値意味論を持ちます、それは、それらがメモリにおいてある固定された配置を持つことを意味します。再帰をサポートするために、コンパイラは間接参照の階層を差し入れる必要があります。

To enable indirection for a particular enumeration case, mark it with the indirect declaration modifier. An indirect case must have an associated value.
ある特定の列挙ケース節に対して間接参照を可能にするには、それをindirect宣言修飾子で印してください。関節参照のケース節は、関連値を持っていなければなりません。

  1. enum Tree<T> {
  2. case empty
  3. indirect case node(value: T, left: Tree, right: Tree)
  4. }

To enable indirection for all the cases of an enumeration that have an associated value, mark the entire enumeration with the indirect modifier—this is convenient when the enumeration contains many cases that would each need to be marked with the indirect modifier.
ある列挙の中のすべてのケース節、それらは関連値を持っている、に対して間接参照を可能にするには、その列挙全体をindirect修飾子で印してください—これはその列挙がそのそれぞれがindirect修飾子で印される必要がある多くのケース節を含んでいる時に適します。

An enumeration that is marked with the indirect modifier can contain a mixture of cases that have associated values and cases those that don’t. That said, it can’t contain any cases that are also marked with the indirect modifier.
indirect修飾子で印される列挙は、関連値を持つケース節とそうでないケース節の入り交じったものを持つことができます。とは言うものの、それはindirect修飾子でさらに印されるどんなケース節も含むことはできません。

Enumerations with Cases of a Raw-Value Type
「生の値」型のケース節を持つ列挙

The following form declares an enumeration type that contains enumeration cases of the same basic type:
以下の形式は、同じ基本の型をもつ列挙ケース節たちを含む列挙型を宣言します： 

  • enum enumeration name: raw-value type, adopted protocols {
  •     case enumeration case 1 = raw value 1
  •     case enumeration case 2 = raw value 2
  • }

In this form, each case block consists of the case keyword, followed by one or more enumeration cases, separated by commas. Unlike the cases in the first form, each case has an underlying value, called a raw value, of the same basic type. The type of these values is specified in the raw-value type and must represent an integer, floating-point number, string, or single character. In particular, the raw-value type must conform to the Equatable protocol and one of the following protocols: ExpressibleByIntegerLiteral for integer literals, ExpressibleByFloatLiteral for floating-point literals, ExpressibleByStringLiteral for string literals that contain any number of characters, and ExpressibleByUnicodeScalarLiteral or ExpressibleByExtendedGraphemeClusterLiteral for string literals that contain only a single character. Each case must have a unique name and be assigned a unique raw value.
この形式では、それぞれのケース節ブロックはキーワードcase、それに続けて、コンマで区切られる一つ以上の列挙ケース節から成ります。最初の形式でのケース節と違って、それぞれのケース節は、同じ基本の型の、もととなる値、生の値と呼ばれるものを持ちます。これらの値の型は、生の値型において指定されて、整数、浮動小数点数、文字列または単一の文字を表さなければなりません。特に、生の値型は、Equatableプロトコルおよび次のプロトコルの内の１つに準拠しなければなりません：整数リテラルのためのExpressibleByIntegerLiteral、浮動小数点リテラルのためのExpressibleByFloatLiteral、随意の数の文字を含む文字列リテラルのためのExpressibleByStringLiteral、そしてただ１つの文字だけを含む文字列リテラルのためのExpressibleByUnicodeScalarLiteralまたはExpressibleByExtendedGraphemeClusterLiteral。それぞれのケース節は、固有な名前を持ち固有な生の値を割り当てられなければなりません。

If the raw-value type is specified as Int and you don’t assign a value to the cases explicitly, they are implicitly assigned the values 0, 1, 2, and so on. Each unassigned case of type Int is implicitly assigned a raw value that is automatically incremented from the raw value of the previous case.
もし生の値型がIntとして指定され、あなたが明示的に値をそれぞれのケース節に割り当てないならば、それらは暗黙のうちに値0、1、2、等々を割り当てられます。型Intの未割り当てのケース節それぞれは、暗黙のうちに生の値を割り当てられます、それは、前のケース節の生の値から自動的に増やされたものです。

  1. enum ExampleEnum: Int {
  2. case a, b, c = 5, d
  3. }

In the above example, the raw value of ExampleEnum.a is 0 and the value of ExampleEnum.b is 1. And because the value of ExampleEnum.c is explicitly set to 5, the value of ExampleEnum.d is automatically incremented from 5 and is therefore 6.
上記の例で、ExampleEnum.aの値は0です、そしてExampleEnum.bの値は1です。そしてExampleEnum.cの値が明示的に5に設定されるので、ExampleEnum.dの値は5から自動的に増加して、したがって6です。

If the raw-value type is specified as String and you don’t assign values to the cases explicitly, each unassigned case is implicitly assigned a string with the same text as the name of that case.
「生の値」型がStringとして指定されてあなたが明示的に値をそのケース節に割り当てないならば、未割り当てのケース節のそれぞれは暗黙的にそのケース節の名前である同じテキストをもつ文字列を割り当てられます。

  1. enum GamePlayMode: String {
  2. case cooperative, individual, competitive
  3. }

In the above example, the raw value of GamePlayMode.cooperative is "cooperative", the raw value of GamePlayMode.individual is "individual", and the raw value of GamePlayMode.competitive is "competitive".
上の例において、GamePlayMode.cooperativeの生の値は"cooperative"です、GamePlayMode.individualの生の値は"individual"です、そしてGamePlayMode.competitiveの生の値は"competitive"です。

Enumerations that have cases of a raw-value type implicitly conform to the RawRepresentable protocol, defined in the Swift standard library. As a result, they have a rawValue property and a failable initializer with the signature init?(rawValue: RawValue). You can use the rawValue property to access the raw value of an enumeration case, as in ExampleEnum.b.rawValue. You can also use a raw value to find a corresponding case, if there is one, by calling the enumeration’s failable initializer, as in ExampleEnum(rawValue: 5), which returns an optional case. For more information and to see examples of cases with raw-value types, see Raw Values.
「生の値」型のケース節を持つ列挙は、スウィフト標準ライブラリで定義されるRawRepresentableプロトコルに暗黙的に準拠します。結果として、それはrawValueプロパティとシグネチャinit?(rawValue: RawValue)を持つ失敗できるイニシャライザを持ちます。あなたは、rawValueプロパティを使うことで列挙ケース節の生の値にアクセスできます、ExampleEnum.b.rawValueにおけるように。あなたはまた生の値を使用して対応するケース節を見つけることが、もしそれが１つあるならば、列挙の持つ失敗できるイニシャライザを呼ぶことによって可能です、例えばExampleEnum(rawValue: 5)のように、それはオプショナルのケース節を返します。より多くの情報のために、そして「生の値」型をもつケース節の例を見るために、生の値を見てください。

Accessing Enumeration Cases
列挙ケース節にアクセスする

To reference the case of an enumeration type, use dot (.) syntax, as in EnumerationType.enumerationCase. When the enumeration type can be inferred from context, you can omit it (the dot is still required), as described in Enumeration Syntax and Implicit Member Expression.
列挙型のケース節に言及するために、EnumerationType.enumerationCaseのように、ドット（.）構文を使ってください。列挙型が前後関係から推論されることができるとき、列挙構文と暗黙のメンバー式で記述されるように、あなたはそれを省略することができます（ドットは依然必要です）。

To check the values of enumeration cases, use a switch statement, as shown in Matching Enumeration Values with a Switch Statement. The enumeration type is pattern-matched against the enumeration case patterns in the case blocks of the switch statement, as described in Enumeration Case Pattern.
列挙ケース節の値を調べるために、スイッチ文で列挙値を照合するで示されるように、switch文を使ってください。列挙型は、switch文のケース節ブロックにおいて、列挙ケース節パターンに対してパターンのマッチされます、列挙ケース節パターンで記述されるように。

Grammar of an enumeration declaration
列挙宣言の文法

enum-declaration → attributes­opt­access-level-modifier­opt­union-style-enum­

enum-declaration → attributes­opt­access-level-modifier­opt­raw-value-style-enum­

union-style-enum → indirect­opt­enum­enum-name­generic-parameter-clause­opt­type-inheritance-clause­opt­generic-where-clause­opt­{­union-style-enum-members­opt­}­

union-style-enum-members → union-style-enum-member­union-style-enum-members­opt­

union-style-enum-member → declaration­ union-style-enum-case-clause­ compiler-control-statement­

union-style-enum-case-clause → attributes­opt­indirect­opt­case­union-style-enum-case-list­

union-style-enum-case-list → union-style-enum-case­ union-style-enum-case­,­union-style-enum-case-list­

union-style-enum-case → enum-case-name­tuple-type­opt­

enum-name → identifier­

enum-case-name → identifier­

raw-value-style-enum → enum­enum-name­generic-parameter-clause­opt­type-inheritance-clause­generic-where-clause­opt­{­raw-value-style-enum-members­}­

raw-value-style-enum-members → raw-value-style-enum-member­raw-value-style-enum-members­opt­

raw-value-style-enum-member → declaration­ raw-value-style-enum-case-clause­ compiler-control-statement­

raw-value-style-enum-case-clause → attributes­opt­case­raw-value-style-enum-case-list­

raw-value-style-enum-case-list → raw-value-style-enum-case­ raw-value-style-enum-case­,­raw-value-style-enum-case-list­

raw-value-style-enum-case → enum-case-name­raw-value-assignment­opt­

raw-value-assignment → =­raw-value-literal­

raw-value-literal → numeric-literal­ static-string-literal­ boolean-literal­

Structure Declaration
構造体宣言

A structure declaration introduces a named structure type into your program. Structure declarations are declared using the struct keyword and have the following form:
構造体宣言は、名前をつけられた構造体型をあなたのプログラムに導入します。構造体宣言は、キーワードstructを使って宣言されて、以下の形式を持ちます： 

  • struct structure name: adopted protocols {
  •     declarations
  • }

The body of a structure contains zero or more declarations. These declarations can include both stored and computed properties, type properties, instance methods, type methods, initializers, subscripts, type aliases, and even other structure, class, and enumeration declarations. Structure declarations can’t contain deinitializer or protocol declarations. For a discussion and several examples of structures that include various kinds of declarations, see Classes and Structures.
構造の本文は、０以上の宣言を含みます。これらの宣言は、格納または計算プロパティの双方、型プロパティ、インスタンスメソッド、型メソッド、イニシャライザ、添え字、型エイリアス、そして他の構造体、クラス、および列挙宣言さえも含むことができます。構造宣言は、デイニシャライザまたはプロトコル宣言を含むことができません。議論および、いろいろな種類の宣言を含む構造体のいくつかの例のために、クラスと構造体を見てください。

Structure types can adopt any number of protocols, but can’t inherit from classes, enumerations, or other structures.
構造体型は、随意の数のプロトコルに準拠することができます、しかしクラス、列挙、または他の構造体から継承することはできません。

There are three ways to create an instance of a previously declared structure:
以前に宣言された構造体のインスタンスを作成するには３つの方法があります：

  • Call one of the initializers declared within the structure, as described in Initializers.
    その構造体の内部で宣言されるイニシャライザの内の１つを呼び出す、イニシャライザで記述されるように。

  • If no initializers are declared, call the structure’s memberwise initializer, as described in Memberwise Initializers for Structure Types.
    イニシャライザが宣言されないならば、その構造体のメンバー関連イニシャライザ呼び出す、構造型のためのメンバー関連イニシャライザで記述されるように。

  • If no initializers are declared, and all properties of the structure declaration were given initial values, call the structure’s default initializer, as described in Default Initializers.
    イニシャライザが宣言されない、そしてその構造体宣言の全てのプロパティが初期値を与えられたならば、構造体の省略時のイニシャライザを呼び出す、省略時のイニシャライザで記述されるように。

The process of initializing a structure’s declared properties is described in Initialization.
ある構造体の宣言されたプロパティを初期化する過程は、初期化で記述されます。

Properties of a structure instance can be accessed using dot (.) syntax, as described in Accessing Properties.
クラスインスタンスのプロパティにドット（.）構文でアクセスされることができます、プロパティにアクセスするで記述されるように。

Structures are value types; instances of a structure are copied when assigned to variables or constants, or when passed as arguments to a function call. For information about value types, see Structures and Enumerations Are Value Types.
構造体は、値型です；構造体のインスタンスは、変数や定数に代入される時、または関数呼び出しの引数として渡される時にコピーされます。値型に関して詳しくは、構造体と列挙は値型ですを見てください。

You can extend the behavior of a structure type with an extension declaration, as discussed in Extension Declaration.
あなたは構造体型の挙動を拡張宣言を使って拡張することができます、拡張宣言で議論されるように。

Grammar of a structure declaration
構造体宣言の文法

struct-declaration → attributes­opt­access-level-modifier­opt­struct­struct-name­generic-parameter-clause­opt­type-inheritance-clause­opt­generic-where-clause­opt­struct-body­

struct-name → identifier­

struct-body → {­struct-members­opt­}­

struct-members → struct-member­struct-members­opt­

struct-member → declaration­ compiler-control-statement­

Class Declaration
クラス宣言

A class declaration introduces a named class type into your program. Class declarations are declared using the class keyword and have the following form:
クラス宣言は、名前をつけられたクラス型をあなたのプログラムに導入します。クラス宣言は、キーワードclassを使用して宣言されて、以下の形式を持ちます： 

  • class class name: superclass, adopted protocols {
  •     declarations
  • }

The body of a class contains zero or more declarations. These declarations can include both stored and computed properties, instance methods, type methods, initializers, a single deinitializer, subscripts, type aliases, and even other class, structure, and enumeration declarations. Class declarations can’t contain protocol declarations. For a discussion and several examples of classes that include various kinds of declarations, see Classes and Structures.
クラスの本文は、０個以上の宣言を含みます。これらの宣言は、格納または計算プロパティの双方、インスタンスメソッド、型メソッド、イニシャライザ、一つだけのデイニシャライザ、添え字、型エイリアス、そして他のクラス、構造体、および列挙宣言さえも含むことができます。クラス宣言は、プロトコル宣言を含むことができません。議論および、いろいろな種類の宣言を含むクラスのいくつかの例のために、クラスと構造体を見てください。

A class type can inherit from only one parent class, its superclass, but can adopt any number of protocols. The superclass appears first after the class name and colon, followed by any adopted protocols. Generic classes can inherit from other generic and nongeneric classes, but a nongeneric class can inherit only from other nongeneric classes. When you write the name of a generic superclass class after the colon, you must include the full name of that generic class, including its generic parameter clause.
クラス型は、ただ１つの親クラス、それのスーパークラスから継承することだけが許されます、しかし随意の数のプロトコルに準拠することはできます。スーパークラスがまずクラス名とコロンの後に現れ、続いて随意の準拠するプロトコルが続きます。総称体クラスは、他の総称体および非総称体クラスから継承することができます、しかし非総称体クラスはただ他の非総称体クラスからのみ継承することができます。あなたがコロンの後に総称体スーパークラスの名前を書く時、あなたはその総称体クラスの名前全体を、それの総称体パラメーター節を含めて書く必要があります。

As discussed in Initializer Declaration, classes can have designated and convenience initializers. The designated initializer of a class must initialize all of the class’s declared properties and it must do so before calling any of its superclass’s designated initializers.
イニシャライザ宣言で議論されるように、クラスは、指定および便宜イニシャライザを持つことができます。あるクラスの指定イニシャライザは、そのクラスの指定するプロパティのすべてを初期化しなければ成りません、そしてそれは何であれそれのスーパークラスの指定イニシャライザを呼ぶ前にそうしなければなりません。

A class can override properties, methods, subscripts, and initializers of its superclass. Overridden properties, methods, subscripts, and designated initializers must be marked with the override declaration modifier.
クラスは、それのスーパークラスのプロパティ、メソッド、添え字、そしてイニシャライザをオーバーライドすることができます。プロパティ、メソッド、添え字、そして指定イニシャライザのオーバーライドは、override宣言修飾子で印されなければなりません。

To require that subclasses implement a superclass’s initializer, mark the superclass’s initializer with the required declaration modifier. The subclass’s implementation of that initializer must also be marked with the required declaration modifier.
あるスーパークラスの持つイニシャライザをそのサブクラスたちが実装することを要求するために、そのスーパークラスのイニシャライザをrequired宣言修飾子で印してください。そのイニシャライザのサブクラスの実装もまた、required宣言修飾子で印されなければなりません。

Although properties and methods declared in the superclass are inherited by the current class, designated initializers declared in the superclass are only inherited when the subclass meets the conditions described in Automatic Initializer Inheritance. Swift classes do not inherit from a universal base class.
スーパークラスの中で宣言されるプロパティやメソッドは現在のクラスによって継承されるけれども、スーパークラスの中で宣言される指定イニシャライザはただサブクラスが自動的なイニシャライザ継承で記述される条件と出会う場合に継承されるだけです。スウィフトのクラスたちは、ひとつの共通の基盤クラスから継承はしません。

There are two ways to create an instance of a previously declared class:
以前に宣言されたクラスのインスタンスをつくるには２つの方法があります：

  • Call one of the initializers declared within the class, as described in Initializers.
    そのクラス内で宣言されるイニシャライザのうちの１つを呼び出す、イニシャライザで記述されるように。

  • If no initializers are declared, and all properties of the class declaration were given initial values, call the class’s default initializer, as described in Default Initializers.
    イニシャライザが宣言されない、そして全てのクラス宣言のプロパティが初期値を与えられるならば、クラスの省略時のイニシャライザを呼び出す、省略時のイニシャライザで記述されるように。

Access properties of a class instance with dot (.) syntax, as described in Accessing Properties.
クラスインスタンスのプロパティにドット（.）構文でアクセスしてください、プロパティにアクセスするで記述されるように。

Classes are reference types; instances of a class are referred to, rather than copied, when assigned to variables or constants, or when passed as arguments to a function call. For information about reference types, see Structures and Enumerations Are Value Types.
クラスは、参照型です；クラスのインスタンスは、変数または定数に代入されるとき、または関数呼び出しに対する引数として渡されるときに、コピーされるのではなく、参照されます。参照型に関して詳しくは、構造体と列挙は値型ですを見てください。

You can extend the behavior of a class type with an extension declaration, as discussed in Extension Declaration.
あなたはクラス型の挙動を拡張宣言を使って拡張することができます、拡張宣言で議論されるように。

Grammar of a class declaration
クラス宣言の文法

class-declaration → attributes­opt­access-level-modifier­opt­final­opt­class­class-name­generic-parameter-clause­opt­type-inheritance-clause­opt­generic-where-clause­opt­class-body­

class-declaration → attributes­opt­final­access-level-modifier­opt­class­class-name­generic-parameter-clause­opt­type-inheritance-clause­opt­generic-where-clause­opt­class-body­

class-name → identifier­

class-body → {­class-members­opt­}­

class-members → class-member­class-members­opt­

class-member → declaration­ compiler-control-statement­

Protocol Declaration
プロトコル宣言

A protocol declaration introduces a named protocol type into your program. Protocol declarations are declared at global scope using the protocol keyword and have the following form:
プロトコル宣言は、名前をつけられたプロトコル型をあなたのプログラムに導入します。プロトコル宣言は、グローバルなスコープでキーワードprotocolを使って宣言されて、以下の形式を持ちます： 

  • protocol protocol name: inherited protocols {
  •     protocol member declarations
  • }

The body of a protocol contains zero or more protocol member declarations, which describe the conformance requirements that any type adopting the protocol must fulfill. In particular, a protocol can declare that conforming types must implement certain properties, methods, initializers, and subscripts. Protocols can also declare special kinds of type aliases, called associated types, that can specify relationships among the various declarations of the protocol. Protocol declarations can’t contain class, structure, enumeration, or other protocol declarations. The protocol member declarations are discussed in detail below.
プロトコルの本文は０以上のプロトコルメンバー宣言を含みます、それは、プロトコルを採用しているすべての型が満たさなければならない準拠要件を記述します。特に、プロトコルは、準拠している型が特定のプロパティ、メソッド、イニシャライザ、そして添え字を実装しなければならないと宣言することができます。プロトコルはまた、特別な種類の型エイリアス、そのプロトコルのいろいろな宣言の間での関係を指定することができる関連型と呼ばれるものを宣言することができます。プロトコル宣言は、クラス、構造体、列挙、または他のプロトコル宣言を含むことができません。プロトコルメンバー宣言は、詳細に下で議論されます。

Protocol types can inherit from any number of other protocols. When a protocol type inherits from other protocols, the set of requirements from those other protocols are aggregated, and any type that inherits from the current protocol must conform to all those requirements. For an example of how to use protocol inheritance, see Protocol Inheritance.
プロトコル型は、いくらかの他のプロトコルから継承することができます。あるプロトコル型が他のプロトコルから継承するとき、それらの他のプロトコルからの要件一式は、ひとまとめにされます、そして現在のプロトコルから継承するどんな型でも、それらの要件の全てに従わなければなりません。プロトコル継承を使う方法の例のために、プロトコル継承を見てください。

You can add protocol conformance to a previously declared type by adopting the protocol in an extension declaration of that type. In the extension, you must implement all of the adopted protocol’s requirements. If the type already implements all of the requirements, you can leave the body of the extension declaration empty.
あなたは、プロトコル準拠を以前に宣言された型に加えることが、その型の拡張宣言においてそのプロトコルを採用することによってできます。拡張において、あなたは採用されたプロトコルの要件の全てを実装しなければなりません。その型が要件の全てをすでに実装するならば、あなたは拡張宣言の本文を空のままにしておいてかまいません。

By default, types that conform to a protocol must implement all properties, methods, and subscripts declared in the protocol. That said, you can mark these protocol member declarations with the optional declaration modifier to specify that their implementation by a conforming type is optional. The optional modifier can be applied only to members that are marked with the objc attribute, and only to members of protocols that are marked with the objc attribute. As a result, only class types can adopt and conform to a protocol that contains optional member requirements. For more information about how to use the optional declaration modifier and for guidance about how to access optional protocol members—for example, when you’re not sure whether a conforming type implements them—see Optional Protocol Requirements.
初期状態では、あるプロトコルに準拠する型は、そのプロトコルにおいて宣言される全てのプロパティ、メソッド、そして添え字を実装しなければなりません。とは言え、 あなたはこれらのプロトコルメンバー宣言をoptional宣言修飾子を使って印して、ある準拠型にとってそれらの実装が随意であると指定することができます。optional修飾子は、objc属性で印されるメンバにだけ、そしてobjc属性で印されるプロトコルのメンバにだけ適用されることができます。結果として、クラス型だけがオプショナルメンバー要件を含むプロトコルを採用および準拠することができます。optional宣言修飾子を働かせる方法に関する詳細は、そして、オプショナルのプロトコルメンバーにアクセスする方法 ― 例えば、ある準拠している型がそれらを実装するかどうかについてあなたが確信が持てない時など ― についての手引きとしてオプショナルのプロトコル要件を見てください。

To restrict the adoption of a protocol to class types only, include the AnyObject protocol in the inherited protocols list after the colon. For example, the following protocol can be adopted only by class types:
あるプロトコルの採用をクラス型のみに制約するには、AnyObjectプロトコルを継承されたプロトコルのリストの中にコロンの後で加えてください。例えば、以下のプロトコルはクラス型によってのみ採用されることができます：

  1. protocol SomeProtocol: AnyObject {
  2. /* Protocol members go here */
  3. }

Any protocol that inherits from a protocol that’s marked with the AnyObject requirement can likewise be adopted only by class types.
AnyObject要件で印されるプロトコルから継承するどんなプロトコルも、同じようにクラス型でのみ採用されることができます。

Protocols are named types, and thus they can appear in all the same places in your code as other named types, as discussed in Protocols as Types. However, you can’t construct an instance of a protocol, because protocols do not actually provide the implementations for the requirements they specify.
プロトコルは名前をつけられた型です、したがってそれらはあなたのコードにおいて他の名前をつけられた型と同じ場所の全てにおいて現れることができます、型としてのプロトコルで議論されるように。しかし、あなたはプロトコルからインスタンスを造ることができません、なぜならプロトコルは実際にはそれらが指定する要件に対する実装を用意しないからです。

You can use protocols to declare which methods a delegate of a class or structure should implement, as described in Delegation.
あなたはプロトコルを使って、あるクラスまたは構造体から委任を受ける側が実装しなければならないのはどのメソッドかを宣言することができます、委任で記述されるように。

Grammar of a protocol declaration
プロトコル宣言の文法

protocol-declaration → attributes­opt­access-level-modifier­opt­protocol­protocol-name­type-inheritance-clause­opt­generic-where-clause­opt­protocol-body­

protocol-name → identifier­

protocol-body → {­protocol-members­opt­}­

protocol-members → protocol-member­protocol-members­opt­

protocol-member → protocol-member-declaration­ compiler-control-statement­

protocol-member-declaration → protocol-property-declaration­

protocol-member-declaration → protocol-method-declaration­

protocol-member-declaration → protocol-initializer-declaration­

protocol-member-declaration → protocol-subscript-declaration­

protocol-member-declaration → protocol-associated-type-declaration­

protocol-member-declaration → typealias-declaration­

Protocol Property Declaration
プロトコルプロパティ宣言

Protocols declare that conforming types must implement a property by including a protocol property declaration in the body of the protocol declaration. Protocol property declarations have a special form of a variable declaration:
プロトコルは、準拠している型がそのプロトコル宣言の本文の中のプロトコルプロパティ宣言を含めることによってプロパティを実装しなければならないことを宣言します。プロトコルプロパティ宣言は、変数宣言の特別な形式を持ちます： 

  • var property name: type { get set }

As with other protocol member declarations, these property declarations declare only the getter and setter requirements for types that conform to the protocol. As a result, you don’t implement the getter or setter directly in the protocol in which it is declared.
他のプロトコルメンバー宣言と同様に、これらのプロパティ宣言はそのプロトコルに準拠する型のためのゲッターとセッター要件だけを宣言します。結果として、それが宣言されるプロトコルにおいて、あなたは直接ゲッターまたはセッターを実装しません。

The getter and setter requirements can be satisfied by a conforming type in a variety of ways. If a property declaration includes both the get and set keywords, a conforming type can implement it with a stored variable property or a computed property that is both readable and writeable (that is, one that implements both a getter and a setter). However, that property declaration can’t be implemented as a constant property or a read-only computed property. If a property declaration includes only the get keyword, it can be implemented as any kind of property. For examples of conforming types that implement the property requirements of a protocol, see Property Requirements.
ゲッターとセッター要件は、準拠している型によっていろいろなやり方で満たされることができます。あるプロパティ宣言がgetとsetキーワードを両方とも含むならば、準拠している型はそれを、格納変数プロパティや計算プロパティを使って実装することができます、それは読み出し可能と書き込み可能の両方であるものです（すなわち、ゲッターとセッターのどちらも実装できるもの）。しかし、そのプロパティ宣言は、定数プロパティまたは読み出し専用の計算プロパティとして実装されることができません。プロパティ宣言がgetキーワードだけを含むならば、それはどんな種類のプロパティとしてでも実装されることができます。あるプロトコルのプロパティ要件を実装するものである、準拠している型の例のために、プロパティ要件を見てください。

See also Variable Declaration.
また、変数の宣言を見てください。

Grammar of a protocol property declaration
プロトコルプロパティ宣言の文法

protocol-property-declaration → variable-declaration-head­variable-name­type-annotation­getter-setter-keyword-block­

Protocol Method Declaration
プロトコルメソッド宣言

Protocols declare that conforming types must implement a method by including a protocol method declaration in the body of the protocol declaration. Protocol method declarations have the same form as function declarations, with two exceptions: They don’t include a function body, and you can’t provide any default parameter values as part of the function declaration. For examples of conforming types that implement the method requirements of a protocol, see Method Requirements.
プロトコルが宣言するのは、準拠している型は、プロトコル宣言の本文中のプロトコルメソッド宣言を含めることによって、あるメソッドを実装する必要があるということです。プロトコルメソッド宣言は、２つの例外を除いて、関数宣言と同じ形式を持ちます：それらは関数本体を含むことができません、そして、あなたは関数宣言の一部として省略時のパラメータ値をまったく提供することができません。あるプロトコルのメソッド要件を満たすものである準拠している型の例のために、メソッド要件を見てください。

To declare a class or static method requirement in a protocol declaration, mark the method declaration with the static declaration modifier. Classes that implement this method declare the method with the class modifier. Structures that implement it must declare the method with the static declaration modifier instead. If you’re implementing the method in an extension, use the class modifier if you’re extending a class and the static modifier if you’re extending a structure.
クラスまたは静的メソッド要件をあるプロトコル宣言において宣言するために、そのメソッド宣言をstatic宣言修飾子で印してください。そのメソッドを実装するクラスは、このメソッドをclass修飾子を使って宣言します。それを実装する構造体は、その代わりにstatic宣言修飾子を使ってメソッドを宣言しなければなりません。あなたがこのメソッドをある拡張の中で実装するならば、あなたがクラスを拡張しているならclass修飾子を、あなたが構造体を拡張しているならstatic修飾子を使ってください。

See also Function Declaration.
また、関数宣言を見てください。

Grammar of a protocol method declaration
プロトコルメソッド宣言の文法

protocol-method-declaration → function-head­function-name­generic-parameter-clause­opt­function-signature­generic-where-clause­opt­

Protocol Initializer Declaration
プロトコルイニシャライザ宣言

Protocols declare that conforming types must implement an initializer by including a protocol initializer declaration in the body of the protocol declaration. Protocol initializer declarations have the same form as initializer declarations, except they don’t include the initializer’s body.
プロトコルは、準拠している型がそのプロトコル宣言の本文の中のプロトコルイニシャライザ宣言を含めることによってイニシャライザを実装しなければならないと宣言します。プロトコルイニシャライザ宣言は、それらがイニシャライザ本文を含めないことを除いて、イニシャライザ宣言と同じ形式を持ちます。

A conforming type can satisfy a nonfailable protocol initializer requirement by implementing a nonfailable initializer or an init! failable initializer. A conforming type can satisfy a failable protocol initializer requirement by implementing any kind of initializer.
ある準拠している型は、失敗できないプロトコルイニシャライザ要件を満たすことが、失敗できないイニシャライザまたはinit!失敗できるイニシャライザを実装することによって可能です。ある準拠している型は、失敗できるプロトコルイニシャライザ要件を満たすことが、どんな種類のイニシャライザを実装することによっても可能です。

When a class implements an initializer to satisfy a protocol’s initializer requirement, the initializer must be marked with the required declaration modifier if the class is not already marked with the final declaration modifier.
あるクラスがプロトコルのイニシャライザ要件を満たすためにイニシャライザを実装するとき、そのイニシャライザはrequired宣言修飾子を使って印される必要が、そのクラスが既にfinal宣言修飾子を使って印されていないならば、あります。

See also Initializer Declaration.
また、イニシャライザ宣言を見てください。

Grammar of a protocol initializer declaration
プロトコル・イニシャライザ宣言の文法

protocol-initializer-declaration → initializer-head­generic-parameter-clause­opt­parameter-clause­throws­opt­generic-where-clause­opt­

protocol-initializer-declaration → initializer-head­generic-parameter-clause­opt­parameter-clause­rethrows­generic-where-clause­opt­

Protocol Subscript Declaration
プロトコル添え字宣言

Protocols declare that conforming types must implement a subscript by including a protocol subscript declaration in the body of the protocol declaration. Protocol subscript declarations have a special form of a subscript declaration:
プロトコルは、準拠している型がそのプロトコル宣言の本文の中のプロトコル添え字宣言を含めることによって添え字を実装しなければならないと宣言します。プロトコル添え字宣言は、添え字宣言の特別な形式を持ちます： 

  • subscript (parameters) -> return type { get set }

Subscript declarations only declare the minimum getter and setter implementation requirements for types that conform to the protocol. If the subscript declaration includes both the get and set keywords, a conforming type must implement both a getter and a setter clause. If the subscript declaration includes only the get keyword, a conforming type must implement at least a getter clause and optionally can implement a setter clause.
添え字宣言は、プロトコルに準拠する型のための最小限のゲッターとセッター実装要件を宣言するだけです。添え字宣言がgetとsetキーワードを両方とも含むならば、準拠している型はゲッターとセッター節を両方とも実装しなければなりません。添え字宣言がgetキーワードだけを含むならば、準拠している型は、少なくともゲッター節を実装しなければなりません、そして随意にセッター節を実装することができます。

See also Subscript Declaration.
また、添え字宣言を見てください。

Grammar of a protocol subscript declaration
プロトコル添え字宣言の文法

protocol-subscript-declaration → subscript-head­subscript-result­generic-where-clause­opt­getter-setter-keyword-block­

Protocol Associated Type Declaration
プロトコル関連型宣言

Protocols declare associated types using the associatedtype keyword. An associated type provides an alias for a type that is used as part of a protocol’s declaration. Associated types are similar to type parameters in generic parameter clauses, but they’re associated with Self in the protocol in which they’re declared. In that context, Self refers to the eventual type that conforms to the protocol. For more information and examples, see Associated Types.
プロトコルは、関連型をキーワードassociatedtypeを使って宣言します。関連型は、エイリアスをプロトコルの宣言の一部として使われる型のために用意します。関連型は、総称体パラメータ節の中の型パラメータに似ています、しかしそれらは、それらが宣言されるプロトコルにおいてSelfと結び付けられます。その文脈で、Selfはそのプロトコルに準拠する結果として生じる型に言及します。より多くの情報と例のために、関連型を見てください。

You use a generic where clause in a protocol declaration to add constraints to an associated types inherited from another protocol, without redeclaring the associated types. For example, the declarations of SubProtocol below are equivalent:
あなたは、総称体where節をプロトコル宣言の中で使うことで、別のプロトコルから継承された関連型に制約を追加します、その関連型を再宣言することなしに。例えば、下のSubProtocolの宣言は同等です：

  1. protocol SomeProtocol {
  2. associatedtype SomeType
  3. }
  5. protocol SubProtocolA: SomeProtocol {
  6. // This syntax produces a warning. （この構文は警告を生成します。）
  7. associatedtype SomeType: Equatable
  8. }
  10. // This syntax is preferred. （この構文はより好まれます。）
  11. protocol SubProtocolB: SomeProtocol where SomeType: Equatable { }

See also Type Alias Declaration.
また、型エイリアス宣言を見てください。

Grammar of a protocol associated type declaration
プロトコル関連型宣言の文法

protocol-associated-type-declaration → attributes­opt­access-level-modifier­opt­associatedtype­typealias-name­type-inheritance-clause­opt­typealias-assignment­opt­generic-where-clause­opt­

Initializer Declaration
イニシャライザ宣言

An initializer declaration introduces an initializer for a class, structure, or enumeration into your program. Initializer declarations are declared using the init keyword and have two basic forms.
イニシャライザ宣言は、あなたのプログラムにクラス、構造体、または列挙のためのイニシャライザを導入します。イニシャライザ宣言は、キーワードinitを使って宣言されて、２つの基本の書式を持ちます。

Structure, enumeration, and class types can have any number of initializers, but the rules and associated behavior for class initializers are different. Unlike structures and enumerations, classes have two kinds of initializers: designated initializers and convenience initializers, as described in Initialization.
構造体、列挙、そしてクラス型は、随意の数のイニシャライザを持つことができます、しかし、クラスイニシャライザのための規則および関連する挙動は異なります。構造体や列挙と違って、クラスは２種類のイニシャライザを持ちます：指定イニシャライザと便宜イニシャライザ、初期化で記述されるように。

The following form declares initializers for structures, enumerations, and designated initializers of classes:
以下の形式は、構造体、列挙のイニシャライザ、そしてクラスの指定イニシャライザを宣言します： 

  • init(parameters) {
  •     statements
  • }

A designated initializer of a class initializes all of the class’s properties directly. It can’t call any other initializers of the same class, and if the class has a superclass, it must call one of the superclass’s designated initializers. If the class inherits any properties from its superclass, one of the superclass’s designated initializers must be called before any of these properties can be set or modified in the current class.
あるクラスの指定イニシャライザは、直接そのクラスのプロパティの全てを初期化します。それは同じクラスの他のどのイニシャライザも呼ぶことができません、そしてそのクラスがスーパークラスを持つならば、それはスーパークラスの指定イニシャライザのうちの１つを呼ばなければなりません。クラスが何らかのプロパティをそのスーパークラスから受け継ぐならば、これらのプロパティのどれかが現在のクラスにおいて設定または修正されることができる前に、スーパークラスの指定イニシャライザのうちの１つが呼ばれなければなりません。

Designated initializers can be declared in the context of a class declaration only and therefore can’t be added to a class using an extension declaration.
指定イニシャライザは、クラス宣言の文脈においてのみ宣言されることができて、したがって拡張宣言を使ってあるクラスに加えられることはできません。

Initializers in structures and enumerations can call other declared initializers to delegate part or all of the initialization process.
構造体および列挙のイニシャライザは、初期化プロセスの一部または全てを委任するために他の宣言済みイニシャライザを呼ぶことができます。

To declare convenience initializers for a class, mark the initializer declaration with the convenience declaration modifier.
あるクラスの便宜イニシャライザを宣言するために、そのイニシャライザ宣言をconvenience宣言修飾子を使って印してください。 

  • convenience init(parameters) {
  •     statements
  • }

Convenience initializers can delegate the initialization process to another convenience initializer or to one of the class’s designated initializers. That said, the initialization processes must end with a call to a designated initializer that ultimately initializes the class’s properties. Convenience initializers can’t call a superclass’s initializers.
便宜イニシャライザは、初期化プロセスを別の便宜イニシャライザに、またはそのクラスの指定イニシャライザのうちの１つに委任することができます。とは言え、 初期化プロセスは、最終的にそのクラスのプロパティを初期化する指定イニシャライザに対する呼び出しで終わらなければなりません。便宜イニシャライザは、スーパークラスのイニシャライザを呼ぶことができません。

You can mark designated and convenience initializers with the required declaration modifier to require that every subclass implement the initializer. A subclass’s implementation of that initializer must also be marked with the required declaration modifier.
あなたは指定および便宜イニシャライザをrequired宣言修飾子で印して、全てのサブクラスがそのイニシャライザを実装することが必須であるようにすることができます。そのイニシャライザのサブクラスでの実装は、また、required宣言修飾子で印されなければなりません。

By default, initializers declared in a superclass are not inherited by subclasses. That said, if a subclass initializes all of its stored properties with default values and doesn’t define any initializers of its own, it inherits all of the superclass’s initializers. If the subclass overrides all of the superclass’s designated initializers, it inherits the superclass’s convenience initializers.
初期状態では、スーパークラスで宣言されるイニシャライザは、サブクラスによって継承されません。とは言え、サブクラスがそれの格納プロパティのすべてを省略時の値で初期化して、それ自身のイニシャライザを全く定義しないならば、それはそのスーパークラスのイニシャライザのすべてを継承します。サブクラスがスーパークラスの指定イニシャライザのすべてをオーバーライドするならば、それはスーパークラスの便宜イニシャライザたちを継承します。

As with methods, properties, and subscripts, you need to mark overridden designated initializers with the override declaration modifier.
メソッド、プロパティ、そして添え字と同様に、あなたはオーバーライドした指定イニシャライザをoverride宣言修飾子で印する必要があります。

Just like functions and methods, initializers can throw or rethrow errors. And just like functions and methods, you use the throws or rethrows keyword after an initializer’s parameters to indicate the appropriate behavior.
関数やメソッドのように、イニシャライザはエラーをスローまたは再スローできます。そして関数やメソッドのように、あなたはthrowsまたはrethrowsキーワードをイニシャライザのパラメータの後に使って、ふさわしい挙動を指し示すことができます。

To see examples of initializers in various type declarations, see Initialization.
いろいろな型宣言におけるイニシャライザの例を見るために、初期化を見てください。

Failable Initializers
失敗できるイニシャライザ

A failable initializer is a type of initializer that produces an optional instance or an implicitly unwrapped optional instance of the type the initializer is declared on. As a result, a failable initializer can return nil to indicate that initialization failed.
失敗できるイニシャライザは、イニシャライザの一種で、そのイニシャライザが宣言されている型の、オプショナルのインスタンスまたは暗黙的にアンラップされるオプショナルのインスタンスを生成します。結果として、失敗できるイニシャライザは、そのイニシャライザが失敗したのを指し示すためにnilを返すことができます。

To declare a failable initializer that produces an optional instance, append a question mark to the init keyword in the initializer declaration (init?). To declare a failable initializer that produces an implicitly unwrapped optional instance, append an exclamation mark instead (init!). The example below shows an init? failable initializer that produces an optional instance of a structure.
オプショナルインスタンスを生成する失敗できるイニシャライザを宣言するために、イニシャライザ宣言において疑問符をinitキーワードに加えてください（init?）。暗黙的にアンラップされるオプショナルインスタンスを生成する失敗できるイニシャライザを宣言するために、代わりに感嘆符を加えてください（init!）。下の例は、ある構造体のオプショナルインスタンスを生成する、失敗できるイニシャライザinit?を示します。

  1. struct SomeStruct {
  2. let property: String
  3. // produces an optional instance of 'SomeStruct' （「SomeStruct」のオプショナルインスタンスを生成します）
  4. init?(input: String) {
  5. if input.isEmpty {
  6. // discard 'self' and return 'nil' （「self」を廃棄して「nil」を返します）
  7. return nil
  8. }
  9. property = input
  10. }
  11. }

You call an init? failable initializer in the same way that you call a nonfailable initializer, except that you must deal with the optionality of the result.
あなたは失敗できるイニシャライザinit?を、オプショナルの結果を処理する必要があることを除き、失敗できないイニシャライザを呼び出すのと同じ方法で呼び出します。

  1. if let actualInstance = SomeStruct(input: "Hello") {
  2. // do something with the instance of 'SomeStruct' （「SomeStruct」のインスタンスで何か行う）
  3. } else {
  4. // initialization of 'SomeStruct' failed and the initializer returned 'nil' （「SomeStruct」の初期化は失敗したのでイニシャライザは「nil」を返した）
  5. }

A failable initializer can return nil at any point in the implementation of the initializer’s body.
失敗できるイニシャライザは、そのイニシャライザの本文の中の任意の地点でnilを返すことができます。

A failable initializer can delegate to any kind of initializer. A nonfailable initializer can delegate to another nonfailable initializer or to an init! failable initializer. A nonfailable initializer can delegate to an init? failable initializer by force-unwrapping the result of the superclass’s initializer—for example, by writing super.init()!.
失敗できるイニシャライザは、あらゆる種類のイニシャライザへ委任することができます。失敗できないイニシャライザは、別の失敗できないイニシャライザへ、または失敗できるイニシャライザinit!へ委任することができます。失敗できないイニシャライザは、init?失敗できるイニシャライザに委任することが、スーパークラスのイニシャライザの結果を強制アンラップすることによって可能です ― 例えば、super.init()!と書くことによって。

Initialization failure propagates through initializer delegation. Specifically, if a failable initializer delegates to an initializer that fails and returns nil, then the initializer that delegated also fails and implicitly returns nil. If a nonfailable initializer delegates to an init! failable initializer that fails and returns nil, then a runtime error is raised (as if you used the ! operator to unwrap an optional that has a nil value).
初期化失敗は、イニシャライザ委任を通じて伝えられます。具体的には、失敗できるイニシャライザが、ある失敗してnilを返すイニシャライザへ委任するならば、その時その委任した側のイニシャライザもまた失敗して暗黙的にnilを返します。失敗できないイニシャライザが、ある失敗してnilを返す失敗できるイニシャライザinit!へと委任するならば、その時は実行時エラーが（まるであなたがnilの値を持つオプショナルをアンラップするために!演算子を使ったかのように）引き起こされます。

A failable designated initializer can be overridden in a subclass by any kind of designated initializer. A nonfailable designated initializer can be overridden in a subclass by a nonfailable designated initializer only.
失敗できる指定イニシャライザは、サブクラスにおいて任意の種類の指定イニシャライザでオーバーライドされることができます。失敗できない指定イニシャライザは、サブクラスにおいて失敗できない指定イニシャライザでのみオーバーライドされることができます。

For more information and to see examples of failable initializers, see Failable Initializers.
さらなる情報と、失敗できるイニシャライザの例を見るために、失敗できるイニシャライザを見てください。

Grammar of an initializer declaration
イニシャライザ宣言の文法

initializer-declaration → initializer-head­generic-parameter-clause­opt­parameter-clause­throws­opt­generic-where-clause­opt­initializer-body­

initializer-declaration → initializer-head­generic-parameter-clause­opt­parameter-clause­rethrows­generic-where-clause­opt­initializer-body­

initializer-head → attributes­opt­declaration-modifiers­opt­init­

initializer-head → attributes­opt­declaration-modifiers­opt­init­?­

initializer-head → attributes­opt­declaration-modifiers­opt­init­!­

initializer-body → code-block­

Deinitializer Declaration
デイニシャライザ宣言

A deinitializer declaration declares a deinitializer for a class type. Deinitializers take no parameters and have the following form:
デイニシャライザ宣言は、クラス型のためにデイニシャライザを宣言します。デイニシャライザは、パラメータを取らない以下の形式を持ちます： 

  • deinit {
  •     statements
  • }

A deinitializer is called automatically when there are no longer any references to a class object, just before the class object is deallocated. A deinitializer can be declared only in the body of a class declaration—but not in an extension of a class—and each class can have at most one.
デイニシャライザは、あるクラスオブジェクトに対するいかなる参照ももはやない時、そのクラスオブジェクトが割り当て解除される直前に、自動的に呼ばれます。デイニシャライザは、クラス宣言の本文においてのみ ― しかしクラスの拡張においてではなく ― 宣言されることができます、そして各クラスが多くとも１つしか持つことができません。

A subclass inherits its superclass’s deinitializer, which is implicitly called just before the subclass object is deallocated. The subclass object is not deallocated until all deinitializers in its inheritance chain have finished executing.
サブクラスはそのスーパークラスのデイニシャライザを継承します、それは、サブクラスオブジェクトが割り当て解除される直前に、暗黙のうちに呼ばれます。サブクラスオブジェクトは、その継承連鎖の中の全てのデイニシャライザが実行を終えるまで、割り当て解除されません。

Deinitializers are not called directly.
デイニシャライザは、直接に呼ばれません。

For an example of how to use a deinitializer in a class declaration, see Deinitialization.
クラス宣言においてデイニシャライザを使う方法の例のために、デイニシャライズを見てください。

Grammar of a deinitializer declaration
デイニシャライザ宣言の文法

deinitializer-declaration → attributes­opt­deinit­code-block­

Extension Declaration
拡張宣言

An extension declaration allows you to extend the behavior of existing types. Extension declarations are declared using the extension keyword and have the following form:
拡張宣言があなたに可能にするのは、既存の型の挙動を拡張することです。拡張宣言は、キーワードextensionキーワードを使って宣言され、以下の形式を持ちます： 

  • extension type name where requirements {
  •     declarations
  • }

The body of an extension declaration contains zero or more declarations. These declarations can include computed properties, computed type properties, instance methods, type methods, initializers, subscript declarations, and even class, structure, and enumeration declarations. Extension declarations can’t contain deinitializer or protocol declarations, stored properties, property observers, or other extension declarations. Declarations in a protocol extension can’t be marked final. For a discussion and several examples of extensions that include various kinds of declarations, see Extensions.
拡張宣言の本文は、０個以上の宣言を含みます。これらの宣言は、計算プロパティ、計算型プロパティ、インスタンスメソッド、型メソッド、イニシャライザ、添え字宣言、そしてクラス、構造体、そして列挙宣言さえも含むことができます。拡張宣言は、デイニシャライザまたはプロトコル宣言、格納プロパティ、プロパティオブザーバー、または他の拡張宣言を含むことができません。プロトコル拡張の中の宣言は、finalで印されることができません。いろいろな種類の宣言を含む拡張の解説といくつかの例のために、拡張を見てください。

If the type name is a class, structure, or enumeration type, the extension extends that type. If the type name is a protocol type, the extension extends all types that conform to that protocol.
type nameがクラス、構造体、または列挙型ならば、その拡張はその型を拡張します。type nameがプロトコル型ならば、その拡張はそのプロトコルに準拠するすべての型を拡張します。

Extension declarations that extend a generic type or a protocol with associated types can include requirements. If an instance of the extended type or of a type that conforms to the extended protocol satisfies the requirements, the instance gains the behavior specified in the declaration.
総称体型またはプロトコルを関連型で拡張する拡張宣言は、requirements いくつかの要件を含むことができます。拡張された型のまたは拡張されたプロトコルに準拠する型のインスタンスがrequirements 要件を満たすならば、そのインスタンスは宣言において指定される挙動を獲得します。

Extension declarations can contain initializer declarations. That said, if the type you’re extending is defined in another module, an initializer declaration must delegate to an initializer already defined in that module to ensure members of that type are properly initialized.
拡張宣言は、イニシャライザ宣言を含むことができます。とは言え、 あなたが拡張している型が別のモジュールにおいて定義されるならば、イニシャライザ宣言はそのモジュールですでに定義されるイニシャライザに委任して、その型のメンバーが正しく初期化されることを確実にしなければなりません。

Properties, methods, and initializers of an existing type can’t be overridden in an extension of that type.
既存の型のプロパティ、メソッド、そしてイニシャライザは、その型の拡張においてオーバーライドされることができません。

Extension declarations can add protocol conformance to an existing class, structure, or enumeration type by specifying adopted protocols:
拡張宣言は、プロトコル準拠を既存のクラス、構造体、または列挙型に加えることがadopted protocols 採用プロトコルを指定することによって可能です： 

  • extension type name: adopted protocols where requirements {
  •     declarations
  • }

Extension declarations can’t add class inheritance to an existing class, and therefore you can specify only a list of protocols after the type name and colon.
拡張宣言は、クラス継承を既存のクラスに加えることができません、従ってあなたは幾らかのプロトコルからなるリストのみをtype name 型名とコロンの後に指定することができます。

Conditional Conformance
条件準拠

You can extend a generic type to conditionally conform to a protocol, so that instances of the type conform to the protocol only when certain requirements are met. You add conditional conformance to a protocol by including requirements in an extension declaration.
あなたは、条件付きでプロトコルに準拠するように総称体型を拡張できます、それでその型のインスタンスは特定の要件が満たされた場合にのみそのプロトコルに準拠します。あなたは、あるプロトコルに対する条件準拠を加えることを、要件を拡張宣言に含めることによって行います。

Overridden Requirements Aren’t Used in Some Generic Contexts
オーバーライドされた要件はいくつかの総称体文脈では使われません

In some generic contexts, types that get behavior from conditional conformance to a protocol don’t always use the specialized implementations of that protocol’s requirements. To illustrate this behavior, the following example defines two protocols and a generic type that conditionally conforms to both protocols.
いくつかの総称体文脈では、あるプロトコルに対する条件準拠由来の挙動を持つ型は、そのプロトコルの要件の特殊化された実装を必ず使うとは限りません。この挙動を図解するために、以下の例は２つのプロトコルおよび両方のプロトコルに条件付きで準拠する１つの総称体型を定義します。

  1. protocol Loggable {
  2. func log()
  3. }
  4. extension Loggable {
  5. func log() {
  6. print(self)
  7. }
  8. }
  10. protocol TitledLoggable: Loggable {
  11. static var logTitle: String { get }
  12. }
  13. extension TitledLoggable {
  14. func log() {
  15. print("\(Self.logTitle): \(self)")
  16. }
  17. }
  19. struct Pair<T>: CustomStringConvertible {
  20. let first: T
  21. let second: T
  22. var description: String {
  23. return "(\(first), \(second))"
  24. }
  25. }
  27. extension Pair: Loggable where T: Loggable { }
  28. extension Pair: TitledLoggable where T: TitledLoggable {
  29. static var logTitle: String {
  30. return "Pair of '\(T.logTitle)'"
  31. }
  32. }
  34. extension String: TitledLoggable {
  35. static var logTitle: String {
  36. return "String"
  37. }
  38. }

The Pair structure conforms to Loggable and TitledLoggable whenever its generic type conforms to Loggable or TitledLoggable, respectively. In the example below, oneAndTwo is an instance of Pair<String>, which conforms to TitledLoggable because String conforms to TitledLoggable. When the log() method is called on oneAndTwo directly, the specialized version containing the title string is used.
Pair構造体は、LoggableおよびTitledLoggableに準拠します、それの総称体型がそれぞれLoggableまたはTitledLoggableに準拠する時はいつでも。下の例において、oneAndTwoはPair<String>のインスタンスです、それはTitledLoggableに準拠します、なぜならStringはTitledLoggableに準拠するからです。log()メソッドがoneAndTwoにおいて直接に呼び出される時、タイトル文字列を含んでいる特殊化版が使われます。

  1. let oneAndTwo = Pair(first: "one", second: "two")
  2. oneAndTwo.log()
  3. // Prints "Pair of 'String': (one, two)"

However, when oneAndTwo is used in a generic context or as an instance of the Loggable protocol, the specialized version isn’t used. Swift picks which implementation of log() to call by consulting only the minimum requirements that Pair needs to conform to Loggable. For this reason, the default implementation provided by the Loggable protocol is used instead.
しかしながら、oneAndTwoがある総称体文脈においてまたはLoggableプロトコルのインスタンスとして使われる場合、この特殊化版は使用されません。スウィフトは、log()の実装のどれを呼び出すかの選択を、PairがLoggableに準拠するために必要とする最小限の要件のみを考慮することで行います。この理由のために、Loggableプロトコルによって提供される省略時の実装が代わりに使われます。

  1. func doSomething<T: Loggable>(with x: T) {
  2. x.log()
  3. }
  4. doSomething(with: oneAndTwo)
  5. // Prints "(one, two)"

When log() is called on the instance that’s passed to doSomething(_:), the customized title is omitted from the logged string.
log()がdoSomething(_:)に渡されるインスタンス上で呼び出される時、カスタマイズされたタイトルはログ文字列から省かれます。

Protocol Conformance Must Not Be Redundant
プロトコル準拠は冗長であってはいけません

A concrete type can conform to a particular protocol only once. Swift marks redundant protocol conformances as an error. You’re likely to encounter this kind of error in two kinds of situations. The first situation is when you explicitly conform to the same protocol multiple times, but with different requirements. The second situation is when you implicitly inherit from the same protocol multiple times. These situations are discussed in the sections below.
ある具象型は、特定のプロトコルにただ一度だけ準拠できます。スウィフトは、冗長なプロトコル準拠をエラーであると印します。あなたは、この種のエラーに２種類の状況において出くわしそうに思われます。第一の状況は、あなたが明示的に同じプロトコルに対しての複数回の準拠を、しかし異なる要件を使って行う時です。第二の状況は、あなたが暗黙的に同じプロトコルから複数回継承する時です。これらの状況は、以下の節で議論されます。

Resolving Explicit Redundancy
明示的な冗長性を解決する

Multiple extensions on a concrete type can’t add conformance to the same protocol, even if the extensions’ requirements are mutually exclusive. This restriction is demonstrated in the example below. Two extension declarations attempt to add conditional conformance to the Serializable protocol, one for for arrays with Int elements, and one for arrays with String elements.
ある具象型上の複数の拡張は、同じプロトコルに対して準拠を加えることはできません、たとえそれら拡張の持つ要件が相互に排他的であるとしてもです。この制限は、下の例において実演されます。２つの拡張宣言は、Serializableプロトコルへの条件準拠を加えることを試みます、Int要素を持つ配列のために１つ、そしてString要素を持つ配列のために１つ。

  1. protocol Serializable {
  2. func serialize() -> Any
  3. }
  5. extension Array: Serializable where Element == Int {
  6. func serialize() -> Any {
  7. // implementation
  8. }
  9. }
  10. extension Array: Serializable where Element == String {
  11. func serialize() -> Any {
  12. // implementation
  13. }
  14. }
  15. // Error: redundant conformance of 'Array<Element>' to protocol 'Serializable' （エラー: プロトコル 'Serializable' に対しての 'Array<Element>' の冗長な準拠）

If you need to add conditional conformance based on multiple concrete types, create a new protocol that each type can conform to and use that protocol as the requirement when declaring conditional conformance.
あなたが複数の具象型に基づく条件準拠を加える必要があるならば、それぞれの型が準拠できる新しいプロトコルを作成してください、そしてそのプロトコルを条件準拠を宣言する時に要件として使ってください。

  1. protocol SerializableInArray { }
  2. extension Int: SerializableInArray { }
  3. extension String: SerializableInArray { }
  5. extension Array: Serializable where Element: SerializableInArray {
  6. func serialize() -> Any {
  7. // implementation
  8. }
  9. }

Resolving Implicit Redundancy
暗黙的な冗長性を解決する

When a concrete type conditionally conforms to a protocol, that type implicitly conforms to any parent protocols with the same requirements.
具象型があるプロトコルに条件準拠するとき、その型は同じ要件を持つあらゆる親プロトコルに暗黙的に準拠します。

If you need a type to conditionally conform to two protocols that inherit from a single parent, explicitly declare conformance to the parent protocol. This avoids implicitly conforming to the parent protocol twice with different requirements.
あなたがある型に単一の親から継承する２つのプロトコルに対して条件準拠して欲しいならば、明示的に親プロトコルに対する準拠を宣言してください。これは、その親プロトコルに対する異なる要件での二重の暗黙的準拠を回避します。

The following example explicitly declares the conditional conformance of Array to Loggable to avoid a conflict when declaring its conditional conformance to both TitledLoggable and the new MarkedLoggable protocol.
以下の例は、Loggableに対してのArrayの条件準拠を明示的に宣言して、TitledLoggableと新しいMarkedLoggableプロトコルの両方に対してのそれの条件準拠を宣言する時に衝突を回避します。

  1. protocol MarkedLoggable: Loggable {
  2. func markAndLog()
  3. }
  5. extension MarkedLoggable {
  6. func markAndLog() {
  7. print("----------")
  8. log()
  9. }
  10. }
  12. extension Array: Loggable where Element: Loggable { }
  13. extension Array: TitledLoggable where Element: TitledLoggable {
  14. static var logTitle: String {
  15. return "Array of '\(Element.logTitle)'"
  16. }
  17. }
  18. extension Array: MarkedLoggable where Element: MarkedLoggable { }

Without the extension to explicitly declare conditional conformance to Loggable, the other Array extensions would implicitly create these declarations, resulting in an error:
拡張がLoggableへの条件準拠を明示的に宣言することなしには、他のArray拡張は、結果としてエラーになるこれら宣言を暗黙的に作成するでしょう。

  1. extension Array: Loggable where Element: TitledLoggable { }
  2. extension Array: Loggable where Element: MarkedLoggable { }
  3. // Error: redundant conformance of 'Array<Element>' to protocol 'Loggable' （エラー: プロトコル 'Loggable' に対しての 'Array<Element>' の冗長な準拠）

Grammar of an extension declaration
拡張宣言の文法

extension-declaration → attributes­opt­access-level-modifier­opt­extension­type-identifier­type-inheritance-clause­opt­generic-where-clause­opt­extension-body­

extension-body → {­extension-members­opt­}­

extension-members → extension-member­extension-members­opt­

extension-member → declaration­ compiler-control-statement­

Subscript Declaration
添え字宣言

A subscript declaration allows you to add subscripting support for objects of a particular type and are typically used to provide a convenient syntax for accessing the elements in a collection, list, or sequence. Subscript declarations are declared using the subscript keyword and have the following form:
添え字宣言は、特定の型のオブジェクトに対する添え字サポートを付け加えることをあなたに可能にして、コレクション、リスト、またはシーケンスの中の要素にアクセスするための便利な構文を提供するために概して使われます。添え字宣言は、キーワードsubscriptを使って宣言されて、以下の形式を持ちます： 

  • subscript (parameters) -> return type {
  •     get {
  •         statements
  •     }
  •     set(setter name) {
  •         statements
  •     }
  • }

Subscript declarations can appear only in the context of a class, structure, enumeration, extension, or protocol declaration.
添え字宣言は、クラス、構造体、列挙、拡張、またはプロトコル宣言の文脈においてだけ、現れることができます。

The parameters specify one or more indexes used to access elements of the corresponding type in a subscript expression (for example, the i in the expression object[i]). Although the indexes used to access the elements can be of any type, each parameter must include a type annotation to specify the type of each index. The return type specifies the type of the element being accessed.
パラメータは、対応する型の要素にアクセスするために添え字式において使用する一種類以上のインデックスを指定します（例えば、式object[i]におけるiなど）。要素にアクセスするために使用されるインデックスは、どんな型でも可能であるけれども、各パラメータは型注釈を含んで、各インデックスの型を指定しなければなりません。戻り型は、アクセスされている要素の型を指定します。

As with computed properties, subscript declarations support reading and writing the value of the accessed elements. The getter is used to read the value, and the setter is used to write the value. The setter clause is optional, and when only a getter is needed, you can omit both clauses and simply return the requested value directly. That said, if you provide a setter clause, you must also provide a getter clause.
計算プロパティと同様に、添え字宣言はアクセスされた要素の値を読み書きすることをサポートします。ゲッターが値を読むために使われます、そしてセッターが値を書くために使われます。セッター節は任意です、そしてゲッターだけが必要なとき、あなたは両方の節を省略して、単に直接要請された値を返すことができます。とは言え、 あなたがセッター節を提供するならば、あなたはまたゲッター節も提供しなければなりません。

The setter name and enclosing parentheses are optional. If you provide a setter name, it is used as the name of the parameter to the setter. If you do not provide a setter name, the default parameter name to the setter is value. The type of the setter name must be the same as the return type.
セッター名と囲んでいる括弧は、任意です。あなたがセッター名を提供するならば、それがセッターにパラメータの名前として使われます。あなたがセッター名を提供しないならば、セッターへの省略時ののパラメータ名はvalueです。セッター名の型は、戻り型と同じものでなければなりません。

You can overload a subscript declaration in the type in which it is declared, as long as the parameters or the return type differ from the one you’re overloading. You can also override a subscript declaration inherited from a superclass. When you do so, you must mark the overridden subscript declaration with the override declaration modifier.
あなたは、ある添え字宣言を、そこにおいてそれが宣言される型においてオーバーロードすることができます、パラメーターまたは戻り型があなたがオーバーロードしているものと異なる限りはです。あなたはまた、スーパークラスから継承した添え字宣言をオーバーライドすることができます。あなたがそうするとき、あなたはオーバーライドされる添え字宣言をoverride宣言修飾子で印しなければなりません。

By default, the parameters used in subscripting don’t have argument labels, unlike functions, methods, and initializers. However, you can provide explicit argument labels using the same syntax that functions, methods, and initializers use.
初期状態で、添字において使用されるパラメータは引数ラベルを持ちません、関数、メソッド、およびイニシャライザとは違って。しかしながら、あなたは明示的に引数ラベルを提供することが、関数、メソッド、およびイニシャライザが使うのと同じ構文を使うことで可能です。

You can also declare subscripts in the context of a protocol declaration, as described in Protocol Subscript Declaration.
プロトコル添え字宣言で記述されるように、あなたはまた、プロトコル宣言の文脈において添え字を宣言することができます。

For more information about subscripting and to see examples of subscript declarations, see Subscripts.
添え字に関するより多くの情報のために、そして、添え字宣言の例を見るために、添え字を見てください。

Grammar of a subscript declaration
添え字宣言の文法

subscript-declaration → subscript-head­subscript-result­generic-where-clause­opt­code-block­

subscript-declaration → subscript-head­subscript-result­generic-where-clause­opt­getter-setter-block­

subscript-declaration → subscript-head­subscript-result­generic-where-clause­opt­getter-setter-keyword-block­

subscript-head → attributes­opt­declaration-modifiers­opt­subscript­generic-parameter-clause­opt­parameter-clause­

subscript-result → ->­attributes­opt­type­

Operator Declaration
演算子宣言

An operator declaration introduces a new infix, prefix, or postfix operator into your program and is declared using the operator keyword.
演算子宣言は、新しい接中辞、接頭辞、または接尾辞演算子をあなたのプログラムに導入します、そしてキーワードoperatorを使って宣言されます。

You can declare operators of three different fixities: infix, prefix, and postfix. The fixity of an operator specifies the relative position of an operator to its operands.
あなたは、３つの異なる定着性の演算子を宣言することができます：接中辞、接頭辞、そして接尾辞。演算子の定着性は、その演算子の演算数に対する相対位置を指定します。

There are three basic forms of an operator declaration, one for each fixity. The fixity of the operator is specified by marking the operator declaration with the infix, prefix, or postfix declaration modifier before the operator keyword. In each form, the name of the operator can contain only the operator characters defined in Operators.
演算子宣言の基本の書式は、各定着性に対して１つずつ、３つあります。演算子の定着性は、演算子定義をoperatorキーワードの前にinfix、prefix、またはpostfix宣言修飾子を使って印することによって指定されます。各形式において、演算子の名前は演算子で定義される演算子文字だけを含むことができます。

The following form declares a new infix operator:
以下の形式は、新しい接中辞演算子を宣言します： 

  • infix operator operator name: precedence group

An infix operator is a binary operator that is written between its two operands, such as the familiar addition operator (+) in the expression 1 + 2.
接中辞演算子は、それの２つ演算数の間で書かれる二項演算子です、例えばよく知られた式1 + 2での加算演算子（+）など。

Infix operators can optionally specify a precedence group. If you omit the precedence group for an operator, Swift uses the default precedence group, DefaultPrecedence, which specifies a precedence just higher than TernaryPrecedence. For more information, see Precedence Group Declaration.
接中辞演算子は、任意に優先順位グループを指定することができます。あなたが優先順位グループを省略するならば、スウィフトは省略時の優先順位グループ、DefaultPrecedenceを使います、それはTernaryPrecedenceのすぐ上の優先順位を指定します。さらなる情報は、優先順位グループ定義を見てください。

The following form declares a new prefix operator:
以下の形式は、新しい接頭辞演算子を宣言します： 

  • prefix operator operator name

A prefix operator is a unary operator that is written immediately before its operand, such as the prefix logical NOT operator (!) in the expression !a.
接頭辞演算子は単項演算子です、それはその演算数の直前に書かれます、例えば式!aでの論理否定演算子（!）など。

Prefix operators declarations don’t specify a precedence level. Prefix operators are nonassociative.
接頭辞演算子宣言は、優先順位レベルを指定しません。接頭辞演算子は非結合です。

The following form declares a new postfix operator:
以下の形式は、新しい接尾辞演算子を宣言します： 

  • postfix operator operator name

A postfix operator is a unary operator that is written immediately after its operand, such as the postfix forced-unwrap operator (!) in the expression a!.
接尾辞演算子は単項演算子です、それはその演算数の直後に書かれます、例えば式a!での論理否定演算子（!）など。

As with prefix operators, postfix operator declarations don’t specify a precedence level. Postfix operators are nonassociative.
接頭辞演算子と同様に、接尾辞演算子宣言は、優先順位レベルを指定しません。接尾辞演算子は非結合です。

After declaring a new operator, you implement it by declaring a static method that has the same name as the operator. The static method is a member of one of the types whose values the operator takes as an argument—for example, an operator that multiplies a Double by an Int is implemented as a static method on either the Double or Int structure. If you’re implementing a prefix or postfix operator, you must also mark that method declaration with the corresponding prefix or postfix declaration modifier. To see an example of how to create and implement a new operator, see Custom Operators.
ある新しい演算子を宣言した後に、あなたはその演算子と同じ名前を持つ静的メソッドを宣言することによってそれを実装します。この静的メソッドは、その演算子が引数としてとる値の型のうちの１つに属するあるメンバーです、例えばDoubleにIntを掛ける演算子は静的メソッドとしてDoubleまたはInt 構造体のどちらかで実装されます。あなたが接頭辞または接尾辞演算子を実装しているならば、あなたはまたそのメソッド宣言を対応するprefixまたはpostfix宣言修飾子で印をしなければなりません。新しい演算子の作成と実装の方法の例を見るには、あつらえの演算子を参照してください。

Grammar of an operator declaration
演算子宣言の文法

operator-declaration → prefix-operator-declaration­ postfix-operator-declaration­ infix-operator-declaration­

prefix-operator-declaration → prefix­operator­operator­

postfix-operator-declaration → postfix­operator­operator­

infix-operator-declaration → infix­operator­operator­infix-operator-group­opt­

infix-operator-group → :­precedence-group-name­

Precedence Group Declaration
優先順位グループ定義

A precedence group declaration introduces a new grouping for infix operator precedence into your program. The precedence of an operator specifies how tightly the operator binds to its operands, in the absence of grouping parentheses.
優先順位グループは、接中辞演算子優先順位に対する新しいグループをあなたのプログラムへ導入します。ある演算子の優先順位は、どのくらいきつくその演算子をそれの演算数に束縛するかを、グループ化の丸括弧がないところで指定します。

A precedence group declaration has the following form:
優先順位グループ定義は、以下の形式を持ちます： 

  • precedencegroup precedence group name {
  •     higherThan: lower group names
  •     lowerThan: higher group names
  •     associativity: associativity
  •     assignment: assignment
  • }

The lower group names and higher group names lists specify the new precedence group’s relation to existing precedence groups. The lowerThan precedence group attribute may only be used to refer to precedence groups declared outside of the current module. When two operators compete with each other for their operands, such as in the expression 2 + 3 * 5, the operator with the higher relative precedence binds more tightly to its operands.
下方グループ名および上方グループ名リストは、新しい優先順位グループのもつ関係を既存の優先順位グループに対して指定します。lowerThan優先順位グループ属性は、現在のモジュールの外側で宣言される優先順位グループを参照するのに使われるだけでしょう。２つの演算子がそれらの演算数に対して互いと比較される時、例えば式2 + 3 * 5などで、より高い関係優先順位を持つ演算子はよりきつくそれの演算数に束縛されます。

Swift defines numerous precedence groups to go along with the operators provided by the standard library. For example, the addition (+) and subtraction (-) operators belong to the AdditionPrecedence group, and the multiplication (*) and division (/) operators belong to the MultiplicationPrecedence group. For a complete list of precedence groups provided by the Swift standard library, see Operator Declarations.
スウィフトは、標準ライブラリによって提供される演算子と一緒にやっていくために、多数の優先順位グループを定義します。例えば、加算（+）および減算（-）演算子は、AdditionPrecedenceグルーブに所属し、そして乗算（*）および減算（/）演算子はMultiplicationPrecedenceグルーブに属します。スウィフト標準ライブラリによって提供される優先順位グループの完全なリストとして、演算子宣言を見てください。

The associativity of an operator specifies how a sequence of operators with the same precedence level are grouped together in the absence of grouping parentheses. You specify the associativity of an operator by writing one of the context-sensitive keywords left, right, or none—if your omit the associativity, the default is none. Operators that are left-associative group left-to-right. For example, the subtraction operator (-) is left-associative, so the expression 4 - 5 - 6 is grouped as (4 - 5) - 6 and evaluates to -7. Operators that are right-associative group right-to-left, and operators that are specified with an associativity of none don’t associate at all. Nonassociative operators of the same precedence level can’t appear adjacent to each to other. For example, the < operator has an associativity of none, which means 1 < 2 < 3 is not a valid expression.
演算子の結合性は、グループ括弧がない場合に同じ優先順位レベルを持つひと連なりの演算子がどのようにまとめられるかを指定します。あなたはある演算子の結合性を文脈依存キーワードleft、right、またはnoneのうちの１つを書くことによって指定します—あなたが結合性を省略するならば、初期状態はnoneです。左結合である演算子は、左から右へとグループにまとめられます。例えば、減算演算子（-）は左結合です、それで式4 - 5 - 6は(4 - 5) - 6のようにグループにされて、-7に評価されます。右結合の演算子は右から左にグループにされます、そしてnoneの関係性を指定される演算子は全く結合しません。同じ優先順位レベルを持つ非結合演算子は、互いに隣同士に現れることができません。例えば、<演算子は、noneの関係性を持ちます、それは1 < 2 < 3が有効な式でないことを意味します。

The assignment of a precedence group specifies the precedence of an operator when used in an operation that includes optional chaining. When set to true, an operator in the corresponding precedence group uses the same grouping rules during optional chaining as the assignment operators from the standard library. Otherwise, when set to false or omitted, operators in the precedence group follows the same optional chaining rules as operators that don’t perform assignment.
優先順位グループのassignmentは、オプショナル連鎖を含む演算において使われる時ある演算子の優先順位を指定します。trueに設定する場合、対応する優先順位グループの演算子は標準ライブラリ由来のassignment（割り当て）演算子と同じグループ化規則をオプショナル連鎖の間に使います。そうせずに、falseに設定するか省略する場合は、その優先順位グループの演算子は代入を実行しない演算子と同じオプショナル連鎖規則に従います。

Grammar of a precedence group declaration
優先順位グループ宣言の文法

precedence-group-declaration → precedencegroup­precedence-group-name­{­precedence-group-attributes­opt­}­

precedence-group-attributes → precedence-group-attribute­precedence-group-attributes­opt­

precedence-group-attribute → precedence-group-relation­

precedence-group-attribute → precedence-group-assignment­

precedence-group-attribute → precedence-group-associativity­

precedence-group-relation → higherThan­:­precedence-group-names­

precedence-group-relation → lowerThan­:­precedence-group-names­

precedence-group-assignment → assignment­:­boolean-literal­

precedence-group-associativity → associativity­:­left­

precedence-group-associativity → associativity­:­right­

precedence-group-associativity → associativity­:­none­

precedence-group-names → precedence-group-name­ precedence-group-name­,­precedence-group-names­

precedence-group-name → identifier­

Declaration Modifiers
宣言修飾子

Declaration modifiers are keywords or context-sensitive keywords that modify the behavior or meaning of a declaration. You specify a declaration modifier by writing the appropriate keyword or context-sensitive keyword between a declaration’s attributes (if any) and the keyword that introduces the declaration.
宣言修飾子は、キーワードまたは文脈依存キーワードです、それは宣言のふるまいや意味することを修正します。あなたは、宣言修飾子を適切なキーワードまたは文脈依存キーワードを宣言の属性（もしあれば）と宣言を導入するキーワードとの間に書くことによって指定します。

dynamic

Apply this modifier to any member of a class that can be represented by Objective-C. When you mark a member declaration with the dynamic modifier, access to that member is always dynamically dispatched using the Objective-C runtime. Access to that member is never inlined or devirtualized by the compiler.
この修飾子をObjective-Cによって表わされることのできるクラスのあらゆるメンバーに適用してください。あなたがメンバー宣言をdynamic修飾子で印する時は、そのメンバーへのアクセスは、常に動的にObjective-Cランタイムを使用してディスパッチされます。そのメンパーに対するアクセスは、決してコンパイラによってインラインまたはデバーチャライズされません。

Because declarations marked with the dynamic modifier are dispatched using the Objective-C runtime, they must be marked with the objc attribute.
dynamic修飾子で印される宣言はObjective-Cランタイムを使ってディスパッチされるので、それらはobjc属性で印されなければなりません。

final

Apply this modifier to a class or to a property, method, or subscript member of a class. It’s applied to a class to indicate that the class can’t be subclassed. It’s applied to a property, method, or subscript of a class to indicate that a class member can’t be overridden in any subclass. For an example of how to use the final attribute, see Preventing Overrides.
この修飾子をクラスに、またはプロパティ、メソッド、またはクラスの添え字メンバーに適用してください。それはクラスに適用されて、そのクラスがサブクラスを作られることができないのを指し示します。それはプロパティ、メソッド、またはクラスの添え字に適用されて、そのクラスメンバーがあらゆるサブクラスにおいてオーバーライドされることができないのを指し示します。final属性を使う方法の例として、オーバーライドを防ぐを見てください。

lazy

Apply this modifier to a stored variable property of a class or structure to indicate that the property’s initial value is calculated and stored at most once, when the property is first accessed. For an example of how to use the lazy modifier, see Lazy Stored Properties.
この修飾子をクラスまたは構造体の格納変数プロパティに適用して、そのプロパティの初期値が最大でも一度だけ、そのプロパティが最初にアクセスされるときに、計算または格納されることを指し示してください。lazy修飾子を使う方法の例として、遅延格納プロパティを見てください。

optional

Apply this modifier to a protocol’s property, method, or subscript members to indicate that a conforming type isn’t required to implement those members.
この修飾子をプロトコルのプロパティ、メソッド、または添え字メンバーに適用して、ある準拠型がそれらのメンバーを実装する必要がないことを指し示してください。

You can apply the optional modifier only to protocols that are marked with the objc attribute. As a result, only class types can adopt and conform to a protocol that contains optional member requirements. For more information about how to use the optional modifier and for guidance about how to access optional protocol members—for example, when you’re not sure whether a conforming type implements them—see Optional Protocol Requirements.
あなたはoptional修飾子をobjc属性で印されるプロトコルだけに適用することができます。結果として、クラス型だけがオプショナルメンバー要件を含むプロトコルを採用および準拠することができます。optional修飾子を使う方法についての更なる情報のために、そしてオプショナルプロトコルメンバーにアクセスする方法についての手引きとして ― 例えば、あなたがある準拠型がそれらを実装するかどうか確信が持てない時など ― オプショナルのプロトコル要件を見てください。

required

Apply this modifier to a designated or convenience initializer of a class to indicate that every subclass must implement that initializer. The subclass’s implementation of that initializer must also be marked with the required modifier.
この修飾子をクラスの必須または便宜イニシャライザに適用して、全てのサブクラスがそのイニシャライザを実装しなければならないことを指し示してください。このイニシャライザのサブクラスでの実装はまた、required修飾子で印されなければなりません。

unowned

Apply this modifier to a stored variable, constant, or stored property to indicate that the variable or property has an unowned reference to the object stored as its value. If you try to access the variable or property after the object has been deallocated, a runtime error is raised. Like a weak reference, the type of the property or value must be a class type; unlike a weak reference, the type is nonoptional. For an example and more information about the unowned modifier, see Unowned References.
この修飾子を格納変数、定数、または格納プロパティに適用して、その変数またはプロパティがそれの値として格納されるオブジェクトに対して非所有参照を持つことを指し示してください。あなたが変数またはプロパティにそのオブジェクトがデアロケートされてしまった後にアクセスすることを試みるならば、実行時エラーが引き起こされます。弱い参照のように、プロパティや値の型はクラス型でなければなりません；弱い参照と違って、その型は非オプショナルです。unowned修飾子についての例とさらなる情報として、非所有参照を見てください。

unowned(safe)

An explicit spelling of unowned.
unownedの明確なつづり方。

unowned(unsafe)

Apply this modifier to a stored variable, constant, or stored property to indicate that the variable or property has an unowned reference to the object stored as its value. If you try to access the variable or property after the object has been deallocated, you’ll access the memory at the location where the object used to be, which is a memory-unsafe operation. Like a weak reference, the type of the property or value must be a class type; unlike a weak reference, the type is nonoptional. For an example and more information about the unowned modifier, see Unowned References.
この修飾子を格納変数、定数、または格納プロパティに適用して、その変数またはプロパティがそれの値として格納されるオブジェクトに対して非所有参照を持つことを指し示してください。あなたが変数またはプロパティに、そのオブジェクトがデアロケートされてしまった後にアクセスすることを試みるならば、あなたはそのオブジェクトが存在するのに使われたところの位置でメモリにアクセスするでしょう、それはメモリ安全ではない操作です。弱い参照のように、プロパティや値の型はクラス型でなければなりません；弱い参照と違って、その型は非オプショナルです。unowned修飾子についての例とさらなる情報として、非所有参照を見てください。

weak

Apply this modifier to a stored variable or stored variable property to indicate that the variable or property has a weak reference to the object stored as its value. The type of the variable or property must be an optional class type. If you access the variable or property after the object has been deallocated, its value is nil. For an example and more information about the weak modifier, see Weak References.
この修飾子を格納変数または格納変数プロパティに適用して、その変数またはプロパティがそれの値として格納されるオブジェクトに対して弱い参照を持つことを指し示してください。この変数またはプロパティの型はまた、オプショナルクラス型でなければなりません。あなたが変数またはプロパティにそのオブジェクトがデアロケートされてしまった後にアクセスするならば、それの値はnilです。weak修飾子についての例と更なる情報のために、弱い参照を見てください。

Access Control Levels
アクセス制御水準

Swift provides five levels of access control: open, public, internal, file private, and private. You can mark a declaration with one of the access-level modifiers below to specify the declaration’s access level. Access control is discussed in detail in Access Control.
スウィフトは、５つの水準のアクセス制御を提供します：公開、内部、そして非公開。あなたは、宣言を以下のアクセス水準修飾子のうちの１つで印して、その宣言のアクセス水準を指定することができます。アクセス制御は、アクセス制御で詳細に議論されます。

open

Apply this modifier to a declaration to indicate the declaration can be accessed and subclassed by code in the same module as the declaration. Declarations marked with the open access-level modifier can also be accessed and subclassed by code in a module that imports the module that contains that declaration.
この修飾子を宣言に適用して、その宣言がアクセスされることおよびサブクラスを作られることが、宣言と同じモジュールの中のコードによって可能なのを指し示してください。openアクセス水準修飾子で印される宣言はまた、アクセスされることおよびサブクラスを作られることが、その宣言を含むモジュールをインポートするモジュール内のコードによって可能です。

public

Apply this modifier to a declaration to indicate the declaration can be accessed and subclassed by code in the same module as the declaration. Declarations marked with the public access-level modifier can also be accessed (but not subclassed) by code in a module that imports the module that contains that declaration.
この修飾子を宣言に適用して、その宣言がアクセスされることおよびサブクラスを作られることが、宣言と同じモジュールの中のコードによって可能なのを指し示してください。publicアクセス水準修飾子で印される宣言はまた、アクセスされる（しかしサブクラスは作られない）ことが、その宣言を含むモジュールをインポートするモジュール内のコードによって可能です。

internal

Apply this modifier to a declaration to indicate the declaration can be accessed only by code in the same module as the declaration. By default, most declarations are implicitly marked with the internal access-level modifier.
この修飾子を宣言に適用して、その宣言が、宣言と同じモジュールの中のコードによってのみアクセスされることができるのを指し示してください。省略時では、大部分の宣言は暗黙的にinternalアクセス水準修飾子で印されます。

fileprivate

Apply this modifier to a declaration to indicate the declaration can be accessed only by code in the same source file as the declaration.
この修飾子を宣言に適用して、その宣言が、宣言と同じソースファイルの中のコードによってのみアクセスされることができるのを指し示してください。

private

Apply this modifier to a declaration to indicate the declaration can be accessed only by code within the declaration’s immediate enclosing scope.
この修飾子を宣言に適用して、その宣言がアクセスされることは、宣言が直に囲んでいるスコープ内のコードによってのみ可能なのを指し示してください。

For the purpose of access control, extensions to the same type that are in the same file share an access-control scope. If the type they extend is also in the same file, they share the type’s access-control scope. Private members declared in the type’s declaration can be accessed from extensions, and private members declared in one extension can be accessed from other extensions and from the type’s declaration.
アクセス制御の目的のために、同じ型で同じファイルの中にあるものに対する拡張それらは、アクセス制御スコープを共有します。それらが拡張した型もまた同じファイルにあるならば、それらはその型のもつアクセス制御スコープを共有します。型の持つ宣言において宣言される非公開メンバは拡張からアクセスできます、そして一方の拡張において宣言される非公開メンバは他方の拡張からそしてその型のもつ宣言からアクセスできます。

Each access-level modifier above optionally accepts a single argument, which consists of the set keyword enclosed in parentheses (for instance, private(set)). Use this form of an access-level modifier when you want to specify an access level for the setter of a variable or subscript that’s less than or equal to the access level of the variable or subscript itself, as discussed in Getters and Setters.
上記のそれぞれのアクセス水準修飾子は、任意に１つだけの引数を受け入れます、それは丸括弧に囲まれたキーワードsetからなります（例えば、private(set)）。アクセス水準修飾子のこの形式は、あなたが変数または添え字のセッターにその変数または添え字それ自身のアクセス水準よりもより少ないか等しいアクセス水準を指定することを望むときに使ってください、ゲッターとセッターで議論されるように。

Grammar of a declaration modifier
宣言修飾子の文法

declaration-modifier → class­ convenience­ dynamic­ final­ infix­ lazy­ optional­ override­ postfix­ prefix­ required­ static­ unowned­ unowned­(­safe­)­ unowned­(­unsafe­)­ weak­

declaration-modifier → access-level-modifier­

declaration-modifier → mutation-modifier­

declaration-modifiers → declaration-modifier­declaration-modifiers­opt­

access-level-modifier → private­ private­(­set­)­

access-level-modifier → fileprivate­ fileprivate­(­set­)­

access-level-modifier → internal­ internal­(­set­)­

access-level-modifier → public­ public­(­set­)­

access-level-modifier → open­ open­(­set­)­

mutation-modifier → mutating­ nonmutating­

Statements
文

Attributes
属性

Copyright © 2018 Apple Inc. All rights reserved. Terms of Use | Privacy Policy | Updated: 2018-03-29