なぜ暗黙的にアンラップされたオプションが割り当てられていないのですか？

Question

次のコードでは、なぜ「somevar」に5が割り当てられていないのですか？

class ViewController: UIViewController { 

    var somevar : Int? 

    override func viewDidLoad() { 
     super.viewDidLoad() 
     somevar! = Int(5) // why 5 is not assigned to somevar here 
    } 
} 

背景：

somevarは、この変数がゼロである場合、この変数は無視されます使用してコマンドを意味し、オプション変数として宣言されます。

例：

class ViewController: UIViewController { 

    var somevar : Int? 

    override func viewDidLoad() { 
     super.viewDidLoad() 
     somevar? = 5 // this command will be ignored bcz somevar is nil 
    } 
} 

が強制的に我々は、コマンドが実行された場合、次の行には、実行されることを確信しているように、「オプションの暗黙的に開封された」使用私たち自身のリスクでコマンドを実行するには

somevar! = 5 

fatal error: unexpectedly found nil while unwrapping an Optional value

この行が実行されると、なぜ「5」「SOMEVAR」に割り当てられていない代わりに、致命的なエラーが発生しましたか？

class ViewController: UIViewController { 

    var somevar : Int? 

    override func viewDidLoad() { 
     super.viewDidLoad() 
     somevar! = 5 
    } 
} 

Answer 1

我々はsomething!（！マークに重点を）実行すると、私たちは "を読ん力"（をアンラップ力）はオプションです。

つまり、上記のコードは、新しい値を割り当てる前にsomethingを読み込もうとします。
somethingはnilなので、コードが爆発します。

は説明するために：

var somevar: Int? 

print(somevar!) 
// Code explodes! 

print(somevar) 
// Output is "nil" 

somevar = 5 

print(somevar!) 
// Output is "5" 

print(somevar) 
// Output is "Optional(5)" 

@LeoDabusが述べたように、これはApple's awesome Swift bookで覆われています。
（本当に良い本です！❤️）

Answer 2

somevar? = 5は何をしているのですか？

//: Playground - noun: a place where people can play 

import Foundation 

// In swift you have to unwrap an optional before you can do anything with it 
var x: Int? = 1 
var y: Int? = 2 

// So you can't do this 
//var z = x + y 

// You have to do this 
if let x = x, 
    let y = y { 
    // Here x and y are no longer of the type Int? they are of the type Int 
    var z = x + y 
} 

// You don't have to name them the same 
if let someX = x, 
    let someY = y { 
    // Here x and y are no longer of the type Int? they are of the type Int 
    var z = someX + someY 
} 

// This can be a pain sometimes if you want to "do nothing" in the nil case, or want to unwrap something multiple "levels" 
// of optionals deep. For example: 

struct Pet { 
    let name: String 
} 

struct Person { 
    let pet: Pet? 
} 

var person: Person? = Person(pet: Pet(name: "Rex")) 

// To get the person's pet's name we have to unwrap a few things 
if let person = person, 
    let pet = person.pet { 
    print("The pet's name is \(pet.name)") 
} 

// We can do this a little easier by using "Optional Chaining" 
if let name = person?.pet?.name { 
    print("The pet's name is \(name)") 
} 

// So here's where your problem comes in 
var number: Int? = nil 

// This is "optional chaining" the assignment of 5 to number. But, because number is current nil the assignment won't happen. 
number? = 5 

// However 
number = 5 

// Now the number is 5 

number? = 10 

// Now the number is 10, because the optional chaining succeded because number was not nil. All this being said, I've never 
// seen someone use x? = 5 in production code, and I can't think of a reason to do that. Just do x = 5 like the other 
// answers have said. 

TL; DRは、somevar? = 5がnilでない場合のみ5にsomevarを設定するオプションのチェーンを使用しています。