Swiftプログラミング言語ガイドには、次の例があります。

class Person {
    let name: String
    init(name: String) { self.name = name }
    var apartment: Apartment?
    deinit { println("\(name) is being deinitialized") }
}

class Apartment {
    let number: Int
    init(number: Int) { self.number = number }
    var tenant: Person?
    deinit { println("Apartment #\(number) is being deinitialized") }
}

var john: Person?
var number73: Apartment?

john = Person(name: "John Appleseed")
number73 = Apartment(number: 73)

//From Apple's “The Swift Programming Language” guide (https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/AutomaticReferenceCounting.html)

次に、アパートメントを人物に割り当てるときに、感嘆符を使用して「インスタンスのラップを解除」します。

john!.apartment = number73

「インスタンスをアンラップする」とはどういう意味ですか？なぜ必要なのですか？以下を実行するだけの場合とどう違うのですか？

john.apartment = number73

私はSwift言語に非常に慣れていません。基本を理解しようとしています。

更新：
私が行方不明だったパズルの大きな部分（答えに直接述べられていません-少なくともこれを書いている時点ではありません）は、次のことをするときです：

var john: Person?

私が最初に思ったように、それjohnは「タイプでPersonあり、それはnilかもしれない」という意味ではありません。私は単にそれを誤解してPersonおりPerson?、完全に別のタイプです。それを理解すると、他のすべて?、!狂気、および以下の素晴らしい答えは、はるかに理解しやすくなりました。

「インスタンスをアンラップする」とはどういう意味ですか？なぜ必要なのですか？

私ができる限り（これも私にとって非常に新しいです）...

「ラップされた」という用語は、オプションの変数を光沢のある紙に包まれたプレゼントとして考える必要があることを意味します。

「ラップ」されている場合、省略可能な変数の値は、2つの可能な値（ブール値に少し似ている）を持つ列挙型です。この列挙型は、変数が値を保持するか（Some(T)）、保持しないか（None）を示します。

値がある場合は、変数を「アンラップ」することで取得できます（Tfromを取得Some(T)）。

どうjohn!.apartment = number73違うのjohn.apartment = number73？（言い換え）

オプション変数の名前（たとえばjohn、なしのtext !）を記述する場合、これは値自体（T）ではなく、「ラップされた」列挙型（Some / None）を参照します。つまりjohnはのインスタンスでPersonはなく、apartmentメンバーもありません。

john.apartment
// 'Person?' does not have a member named 'apartment'

実際のPerson値は、さまざまな方法でラップ解除できます。

• 「強制アンラップ」：（存在する場合john!はPerson値を、nilの場合は実行時エラー）
• 「オプションのバインディング」：（値が存在する場合はをif let p = john { println(p) }実行しprintlnます）
• 「オプションの連鎖」：（john?.learnAboutSwift()値が存在する場合、この構成されたメソッドを実行します）

nilの場合に何が起こるか、そしてその可能性に応じて、アンラップする方法の1つを選択したと思います。この言語の設計により、nilケースは明示的に処理されるように強制されます。これにより、Obj-C（nilケースの処理を忘れがちな場合）よりも安全性が向上すると思います。

更新：

感嘆符は、「暗黙的にアンラップされたオプション」を宣言する構文でも使用されます。

これまでの例では、john変数はとして宣言されておりvar john:Person?、オプションです。その変数の実際の値が必要な場合は、上記の3つの方法のいずれかを使用して、変数をアンラップする必要があります。

var john:Person!代わりに宣言されている場合、変数はImplicitly Unwrapped Optionalになります（Appleの本のこの見出しのセクションを参照）。値にアクセスするときにこの種の変数をアンラップする必要はなく、john追加の構文なしで使用できます。しかしAppleの本はこう言っている：

後で変数がnilになる可能性がある場合は、暗黙的にアンラップされたオプションを使用しないでください。変数の有効期間中にnil値を確認する必要がある場合は、常に通常のオプションの型を使用してください。

アップデート2：

Mike Ash の記事「Interesting Swift Features」は、オプションのタイプにいくつかの動機を与えています。素晴らしい、はっきりした文章だと思います。

アップデート3：

感嘆符の暗黙的にアンラップされたオプションの使用に関する別の有用な記事：Chris Adamsonによる「Swift and the Last Mile」。この記事では、これは、Objective-Cフレームワークで使用される、nilを含む可能性のある型を宣言するために使用されるAppleによる実用的な方法であることを説明しています。型をオプション（を使用?）または暗黙的にアンラップ（を使用）として宣言すること!は、「安全性と利便性の間のトレードオフ」です。記事の例では、Appleは型を暗黙的にアンラップするものとして宣言することを選択しているため、呼び出しコードはより便利になりますが、安全性は低下します。

おそらく、Appleは将来的にフレームワークをくまなく調べ、暗黙的にアンラップされた（おそらくnilでない）パラメータの不確実性を取り除き、それらをオプション（「確かにnilである可能性が高い[うまくいけば、文書化されている！]状況）または標準の非-optional（ "is never nil"）宣言。Objective-Cコードの正確な動作に基づいています。

ここに私が違いがあると思います：

var john: Person?

ジョンは無にできる

john?.apartment = number73

コンパイラーはこの行を次のように解釈します。

if john != nil {
    john.apartment = number73
}

ながら

john!.apartment = number73

コンパイラーはこの行を単純に解釈します。

john.apartment = number73

したがって、！ifステートメントがラップ解除され、より高速に実行されますが、johnがnilの場合、ランタイムエラーが発生します。

したがって、ここでラップするとは、メモリラップであることを意味するのではなく、コードラップであることを意味します。この場合は、ifステートメントでラップされます。また、Appleは実行時のパフォーマンスに細心の注意を払っているので、可能な限り最高のパフォーマンスでアプリを実行します。

更新：

Stackoverflowでそれから最高の評判を得たので、4年後にこの回答に戻ります:)そのときのラップ解除の意味を少し誤解しました。4年経った今、ここでアンラップすることの意味は、元のコンパクトな形式からコードを拡張することだと思います。また、定義によってnilであるかどうかは不明なので、オブジェクトのあいまいさを取り除くことも意味します。上記のアシュリーの答えと同じように、何も含まれない可能性のあるプレゼントと考えてください。しかし、アンラッピングはコードのアンラッピングであり、列挙型を使用するメモリベースのアンラッピングではないとまだ思います。

TL; DR

Swift言語で感嘆符はどういう意味ですか？

感嘆符は効果的に次のように述べています。使ってください。」これは、オプションの値の強制アンラップと呼ばれます。

例

let possibleString: String? = "An optional string."
print(possibleString!) // requires an exclamation mark to access its value
// prints "An optional string."

let assumedString: String! = "An implicitly unwrapped optional string."
print(assumedString)  // no exclamation mark is needed to access its value
// prints "An implicitly unwrapped optional string."

ソース：https : //developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_399

johnがオプションの変数である場合（このように宣言されています）

var john: Person?

その場合、johnが値を持たない可能性があります（ObjC用語では、nil値）

感嘆符は基本的にコンパイラに「これには値があることを知っているので、テストする必要がない」と伝えます。使用したくない場合は、条件付きでテストできます。

if let otherPerson = john {
    otherPerson.apartment = number73
}

この内部は、johnに値がある場合にのみ評価されます。

他の有用であるがより詳細な中心の回答に追加するいくつかの全体像の視点：

Swiftでは、感嘆符はいくつかのコンテキストで表示されます。

• 強制アンラップ： let name = nameLabel!.text
• 暗黙的にアンラップされたオプション： var logo: UIImageView!
• 強制鋳造： logo.image = thing as! UIImage
• 未処理の例外： try! NSJSONSerialization.JSONObjectWithData(data, [])

これらはすべて、異なる意味を持つ異なる言語構成要素ですが、すべてに3つの重要な共通点があります。

1.感嘆符はSwiftのコンパイル時の安全性チェックを回避します。

使うとき !スウィフトに、あなたは基本的に、言っている「ねえ、コンパイラ、私はあなたがエラーが考える知っている可能性があり、ここで起こるが、私は知っている、それは決してことを合計確実に。」

すべての有効なコードがSwiftのコンパイル時型システムのボックスに収まるわけではありません—または 。つまり、任意の言語の静的型チェックに。エラーが発生しないことを論理的に証明できても、それをコンパイラに証明できない状況があります。そのため、Swiftの設計者が最初にこれらの機能を追加しました。

ただし、を使用するときはいつでも!、エラーの回復パスを除外することになります。つまり、…

2.感嘆符は潜在的なクラッシュです。

感嘆符には「Hey Swift、このエラーが発生することはないと確信しているので、私の全体のアプリをクラッシュ、それはそれの回復パスは、コードに私のためであるより。」

それは危険な主張です。それは正しいものになる可能性があります。コードの不変条件について一生懸命考えたミッションクリティカルなコードでは、偽の出力がクラッシュよりも悪い可能性があります。

しかし、私が!実際に目にするときは、それほど注意深く使用されることはめったにありません。代わりに、あまりにも多くの場合、「この値はオプションであり、なぜ nilになる可能性があるのか​​、またはその状況を適切に処理する方法についてそれほど深く考えていませんでしたが、!とコンパイルされました…したがって、私のコードは正しいですか？」

感嘆符の傲慢さに注意してください。代わりに…

3.感嘆符は控えめに使用するのが最適です。

これらの!構成要素にはそれぞれ?、エラー/ nilのケースに対処するように強制する対応物があります。

• 条件付きアンラップ： if let name = nameLabel?.text { ... }
• オプション： var logo: UIImageView?
• 条件付きキャスト： logo.image = thing as? UIImage
• 失敗時の例外： try? NSJSONSerialization.JSONObjectWithData(data, [])

を使いたくなったら!、?代わりになぜ使用しないのかを常に慎重に検討することをお勧めします。!操作が失敗した場合、プログラムのクラッシュは本当に最良の選択肢ですか？なぜその値はオプション/失敗可能ですか？

コードがnil / errorの場合に取ることができる合理的な回復パスはありますか？その場合は、コード化してください。

nilになる可能性がない場合、エラーが発生しない場合、コンパイラーがそれを認識できるようにロジックを作り直すための合理的な方法はありますか？もしそうなら、それを行います。コードはエラーが発生しにくくなります。

エラーを処理するための合理的な方法がない場合があり、単にエラーを無視して、誤ったデータを処理するほうが、クラッシュするよりも悪い場合があります。それらは強制アンラップを使用する時代です。

私は定期的にコードベース全体を検索し、コードベースの!使用をすべて監査しています。精査に耐える使用法はほとんどありません。（これを書いている時点で、Siestaフレームワーク全体には2つの インスタンスがありますがあります。）

それはあなたがあなたのコードで決して使用すべきでないと言っているのではありません! -それを注意深く使用すべきであり、決してそれをデフォルトのオプションにしないでください。

johnオプションですvar。したがって、nil値を含めることができます。値がnilでないことを確認するに!は、var名前の最後にa を使用します。

ドキュメントから

「オプションに値が含まれていることを確認したら、オプションの名前の末尾に感嘆符（！）を追加することで、その基になる値にアクセスできます。感嘆符は効果的に次のように述べています。使ってください。」

非nil値をチェックする別の方法は、

    if let j = json {
        // do something with j
    }

ここではいくつかの例を示します。

var name:String = "Hello World"
var word:String?

どこにwordオプションの値です。値が含まれる場合と含まれない場合があります。

word = name 

ここnameには値があるので、割り当てることができます

var cow:String = nil
var dog:String!

dog強制的にアンラップされる場所は、値が含まれている必要があることを意味します

dog = cow

nilアンラップに割り当てられているため、アプリケーションがクラッシュします

この場合...

varジョン：人！

つまり、Johnは最初は値がnilになり、設定されます。一度設定すると、再びnil-ledになることはありません。したがって、これは「暗黙的にアンラップされたオプション」であるため、便宜上、オプションの変数にアクセスするための簡単な構文を使用できます。

Cファミリの言語を使用している場合は、「メモリアドレス0（NULL）である可能性のあるタイプXのオブジェクトへのポインタ」と考えるでしょう。動的にタイプされた言語を使用している場合は、 「おそらくタイプXであるが、未定義のタイプである可能性があるオブジェクト」を考えています。これらのどちらも実際には正しくありませんが、最初の方は遠回りですが。

あなたがそれを考えるべき方法は、それが次のようなオブジェクトであるかのようです。

struct Optional<T> {
   var isNil:Boolean
   var realObject:T
}

オプションの値をテストしfoo == nilて実際に返ってくるfoo.isNilとき、そしてfoo!それがfoo.realObjectアサーションで返ってくると言うときはfoo.isNil == false。foo実際にnilの場合は、nil なので、これに注意することが重要です。foo!、それはランタイムエラーであるため、これ通常、値がnilにならないことが確実でない限り、代わりに条件付きletを使用することをお勧めします。この種の策略は、値がどこでもnilであるかどうかをテストせずに、言語を強く型付けできることを意味します。

実際には、作業はコンパイラーによって行われるため、実際にはそのようには動作しません。高レベルでは、Foo?とは別のタイプがあり、タイプをFoo受け入れるfuncがFoonil値を受け取るのを防ぎますが、低レベルでは、プロパティやメソッドがないため、オプションの値は真のオブジェクトではありません。実際には、強制アンラップ時に適切なテストでNULL（0）になる可能性のあるポインタである可能性があります。

次のように、感嘆符が型にある他の状況もあります。

func foo(bar: String!) {
    print(bar)
}

これは、強制アンラップでオプションを受け入れることとほぼ同じです。つまり、

func foo(bar: String?) {
    print(bar!)
}

これを使用して、技術的にオプションの値を受け入れるが、nilの場合はランタイムエラーが発生するメソッドを作成できます。Swiftの現在のバージョンでは、これは明らかにis-not-nilアサーションをバイパスするため、代わりに低レベルのエラーが発生します。一般的には良い考えではありませんが、別の言語からコードを変換するときに役立ちます。

！オブジェクトを強制的にアンラップすることを意味します！続く。詳細については、Appleのドキュメントを参照してください。https：//developer.apple.com/library/ios/documentation/swift/conceptual/Swift_Programming_Language/TheBasics.html

C＃に精通している場合、これは疑問符を使用して宣言されるNullable型のようなものです。

Person? thisPerson;

この場合の感嘆符は、次のようにnull許容型の.Valueプロパティにアクセスすることと同じです。

thisPerson.Value

値のない目的Cの変数は「nil」に等しいため（0やfalseと同じ「nil」の値を使用することも可能）、条件付きステートメントで変数を使用できました（値を持つ変数は「TRUE」と同じです） 'と値のないものは' FALSE 'に等しい）。

Swiftは「オプションの値」を提供することでタイプセーフを提供します。つまり、異なるタイプの変数を割り当てることによって形成されるエラーを防ぎます。

したがって、Swiftでは、ブール値のみを条件付きステートメントで提供できます。

var hw = "Hello World"

ここでは、「hw」は文字列ですが、目的Cのようなifステートメントでは使用できません。

//This is an error

if hw

 {..}

そのため、次のように作成する必要があります。

var nhw : String? = "Hello World"

//This is correct

if nhw

 {..}

！オブジェクトの最後に、オブジェクトはオプションであり、それ以外の場合はnilを返すことができる場合はアンラップすることを示します。これは、プログラムをクラッシュさせるエラーをトラップするためによく使用されます。

簡単に（！）：変数を宣言し、変数が値を保持していることを確認した後。

let assumedString: String! = "Some message..."
let implicitString: String = assumedString

そうでなければ、値を渡した後に毎回これを行う必要があります...

let possibleString: String? = "An optional string."
let forcedString: String = possibleString! // requires an exclamation mark

JohnはオプションのPersonです。つまり、値を保持することも、nilにすることもできます。

john.apartment = number73

johnがオプションでない場合に使用されます。ジョンはnilになることはないので、nil値でアパートメントを呼び出すことはありません。ながら

john!.apartment = number73

ジョンがnilではないことをコンパイラに約束し、オプションのラップを解除してジョンの値を取得し、ジョンのアパートメントプロパティにアクセスします。johnがnilでないことがわかっている場合は、これを使用してください。nilオプションでこれを呼び出すと、ランタイムエラーが発生します。

ドキュメントには、convertedNumberがオプションである、これを使用するための良い例が含まれています。

if convertedNumber {
    println("\(possibleNumber) has an integer value of \(convertedNumber!)")
} else {
    println("\(possibleNumber) could not be converted to an integer")
}

簡単に言えば、感嘆符はオプションがラップ解除されていることを意味します。オプションは、値を持つかどうかに関係なく変数です。そのため、ここに示すように if letステートメントを使用して変数が空かどうかを確認し、強制的にアンラップできます。空のオプションを強制的にアンラップすると、プログラムがクラッシュするので注意してください。オプションは、変数への明示的な割り当ての最後に疑問符を付けることによって宣言されます。

var optionalExample: String?

この変数には値がありません。アンラップすると、プログラムがクラッシュし、値がnilのオプションをアンラップしようとしたことがXcodeから通知されます。

お役に立てば幸いです。

簡単な言葉で

USING感嘆符は、変数が非nil値で構成される必要があることを示します（nilになることはありません）。

ストーリー全体は、オプション変数と呼ばれる迅速な機能から始まります。これらは、値がある場合とない場合がある変数です。一般的に、swiftでは初期化されていない変数を使用できません。これは、クラッシュや予期しない理由につながり、バックドアのプレースホルダーとして機能するためです。したがって、最初に値が決定されていない変数を宣言するには、「？」を使用します。そのような変数が宣言されている場合、それを何らかの式の一部として使用するには、使用前にアンラップする必要があります。アンラップは、変数の値がオブジェクトに適用されることを発見する操作です。アンラップせずに使用しようとすると、コンパイル時エラーが発生します。オプションの変数である変数をアンラップするには、感嘆符「！」使用されている。

このようなオプションの変数には、たとえばシステムまたは独自のプログラムによって値が割り当てられることがわかっていることがありますが、そのような状況で、疑問符「？」を使用してオプションの変数を宣言する代わりに、UIアウトレットなど を使用しております "！"。

したがって、システムは "！"で宣言されたこの変数を知っています。現在はオプションであり、値はありませんが、ライフタイムの後半で値を受け取ります。

したがって、感嘆符は2つの異なる使用法を保持します。1。オプションであり、後で確実に値を受け取る変数を宣言する2.式で使用する前にオプション変数をアンラップする。

上記の説明は、技術的なものの多くを避けています。

これをオプションとして使用すると、オプションがアンラップされ、何かが存在するかどうかが確認されます。if-elseステートメントで使用する場合は、NOTのコードです。例えば、

if (myNumber != 3){
 // if myNumber is NOT 3 do whatever is inside these brackets.
)

オプションの変数には値が含まれる場合と含まれない場合があります

ケース1： var myVar:String? = "Something"

ケース2： var myVar:String? = nil

ここでmyVar！を要求すると、1の場合に値を返すようにコンパイラーに指示します。 "Something"

ケース2ではクラッシュします。

意味！markは、存在しない場合でも、コンパイラに値を強制的に返します。それがForce Unwrappingという名前の理由です。

Simple the Optional variable allows nil to be stored.

var str : String? = nil

str = "Data"

To convert Optional to the Specific DataType, We unwrap the variable using the keyword "!"

func get(message : String){
   return
}

get(message : str!)  // Unwapped to pass as String

自問してみてください

• タイプperson?にはapartmentメンバー/プロパティがありますか？または
• タイプpersonにはapartmentメンバー/プロパティがありますか？

この質問に答えられない場合は、読み続けてください。

_{理解するには、ジェネリックスの超基本的なレベルの理解が必要かもしれません。こちらをご覧ください。Swiftの多くはGenericsを使用して記述されています。オプションが含まれています}

以下のコードは、このスタンフォードのビデオから入手できます。最初の5分間を視聴することを強くお勧めします

オプションは2つのケースのみを持つ列挙型です

enum Optional<T>{
    case None
    case Some(T)
}

let x: String? = nil //actually means:

let x = Optional<String>.None

let x :String? = "hello" //actually means:

let x = Optional<String>.Some("hello")

var y = x! // actually means:

switch x {
case .Some(let value): y = value
case .None: // Raise an exception
}

オプションのバインディング：

let x:String? = something
if let y = x {
    // do something with y
}
//Actually means:

switch x{
case .Some(let y): print)(y) // or whatever else you like using 
case .None: break
}

あなたが言うときあなたはvar john: Person?実際にそのような意味です：

enum Optional<Person>{
case .None
case .Some(Person)
}

上記の列挙型には、という名前のプロパティがありapartmentますか？どこかで見ますか？それはだないまったくあり！しかし、それを展開すると、つまり、person!次のことができます...フードの下で何が行われるか：Optional<Person>.Some(Person(name: "John Appleseed"))

var john: Person代わりに定義した場合：var john: Person?それ自体はのメンバーを持っている!ので、もはや使用する必要はありませんでした。Personapartment

!アンラップに使用することが推奨されないことがある理由に関する今後の議論として、このQ＆Aを参照してください