Optional

Overview 概要

You use the Optional type whenever you use optional values, even if you never type the word Optional. Swift’s type system usually shows the wrapped type’s name with a trailing question mark (?) instead of showing the full type name. For example, if a variable has the type Int?, that’s just another way of writing Optional<Int>. The shortened form is preferred for ease of reading and writing code. あなたはOptional型を、あなたがオプショナル値を使う時はいつでも使います、たとえあなたが単語Optionalを決してタイプしないとしてもです。Swiftのもつ型システムは通常、ラップされた型のもつ名前を後に続く疑問符（?）で示します、完全な型の名前を示す代わりに。例えば、ある変数が型Int?を持つとすれば、それはOptional<Int>を記述することのありきたりのやり方です。この短縮された形式は、コードの読み書きの容易さのためにより好ましいものです。

The types of shortForm and longForm in the following code sample are the same: 以下のコード例におけるshortFormとlongFormの型は、同じです：

let shortForm: Int? = Int("42")
let longForm: Optional<Int> = Int("42")

The Optional type is an enumeration with two cases. Optional.none is equivalent to the nil literal. Optional.some(Wrapped) stores a wrapped value. For example: Optional型は、２つのケース節を持つ列挙です。Optional.noneは、nilリテラルに等しいです。Optional.some(Wrapped)は、あるラップされた値を格納します。例えば：

let number: Int? = Optional.some(42)
let noNumber: Int? = Optional.none
print(noNumber == nil)
// Prints "true"

You must unwrap the value of an Optional instance before you can use it in many contexts. Because Swift provides several ways to safely unwrap optional values, you can choose the one that helps you write clear, concise code. あなたは、あなたがそれを多くの文脈において使う前に、Optionalインスタンスの値をアンラップしなければなりません。Swiftは安全にオプショナル値をアンラップするために複数の方法を提供するので、あなたは明快な、簡潔なコードを記述する助けとしてその１つを選ぶことができます。

The following examples use this dictionary of image names and file paths: 以降の例は、この画像名とファイルパスの辞書を使います：

let imagePaths = ["star": "/glyphs/star.png",
                  "portrait": "/images/content/portrait.jpg",
                  "spacer": "/images/shared/spacer.gif"]

Getting a dictionary’s value using a key returns an optional value, so imagePaths["star"] has type Optional<String> or, written in the preferred manner, String?. 辞書の持つ値をあるキーを使って取得することはあるオプショナル値を返します、それでimagePaths["star"]は型Optional<String>または、より好ましい流儀で書かれて、String?を持ちます。

Optional Binding オプショナル束縛

To conditionally bind the wrapped value of an Optional instance to a new variable, use one of the optional binding control structures, including if let, guard let, and switch. Optionalインスタンスのラップされた値を新しい変数へ条件付きの束縛を行うには、if let、guard let、そしてswitchを含む、オプショナル束縛制御構造の１つを使ってください。

if let starPath = imagePaths["star"] {
    print("The star image is at '\(starPath)'")
} else {
    print("Couldn't find the star image")
}
// Prints "The star image is at '/glyphs/star.png'"

Optional Chaining オプショナル連鎖

To safely access the properties and methods of a wrapped instance, use the postfix optional chaining operator (postfix ?). The following example uses optional chaining to access the hasSuffix(_:) method on a String? instance. ラップされたインスタンスの持つプロパティおよびメソッドに安全にアクセスするには、後置オプショナル連鎖演算子（後置?）を使ってください。以下の例は、オプショナル連鎖を使って、hasSuffix(_:)メソッドにString?インスタンス上でアクセスします。

if imagePaths["star"]?.hasSuffix(".png") == true {
    print("The star image is in PNG format")
}
// Prints "The star image is in PNG format"

Using the Nil-Coalescing Operator nil合体演算子を使う

Use the nil-coalescing operator (??) to supply a default value in case the Optional instance is nil. Here a default path is supplied for an image that is missing from imagePaths. nil合体演算子（??）を使って、省略時の値をOptionalインスタンスがnilの場合に提供してください。ここで省略時のパスは、imagePathsから見つからない画像に対して提供されます。

let defaultImagePath = "/images/default.png"
let heartPath = imagePaths["heart"] ?? defaultImagePath
print(heartPath)
// Prints "/images/default.png"

The ?? operator also works with another Optional instance on the right-hand side. As a result, you can chain multiple ?? operators together. ??演算子はまた、別のOptionalインスタンスを右手側でも扱います。結果として、あなたは複数の??を一緒に鎖状につなげることができます。

let shapePath = imagePaths["cir"] ?? imagePaths["squ"] ?? defaultImagePath
print(shapePath)
// Prints "/images/default.png"

Unconditional Unwrapping 無条件にアンラップする

When you’re certain that an instance of Optional contains a value, you can unconditionally unwrap the value by using the forced unwrap operator (postfix !). For example, the result of the failable Int initializer is unconditionally unwrapped in the example below. あなたがあるOptionalのインスタンスが値を含むことを確信している場合、あなたはその値を無条件にアンラップすることが強制アンラップ演算子（後置!）を使って行えます。例えば、この失敗できるIntイニシャライザの結果は、下の例において無条件にアンラップされます。

let number = Int("42")!
print(number)
// Prints "42"

You can also perform unconditional optional chaining by using the postfix ! operator. あなたはまた、無条件のオプショナル連鎖を実行することが、後置!演算子を使って行えます。

let isPNG = imagePaths["star"]!.hasSuffix(".png")
print(isPNG)
// Prints "true"

Unconditionally unwrapping a nil instance with ! triggers a runtime error. nilインスタンスを!で無条件にアンラップすることは、実行時エラーの引き金となります。