Oto co myślę jest różnica:

var john: Person?

Oznacza, że john może być zerowy

john?.apartment = number73

Kompilator zinterpretuje tę linię jako:

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

While

john!.apartment = number73

Kompilator zinterpretuje tę linię jako po prostu:

john.apartment = number73

Stąd używanie ! rozpakuje instrukcję if I sprawi, że będzie działać szybciej, ale jeśli john ma wartość nil, wtedy wystąpi błąd runtime.

Więc zawinięcie tutaj nie oznacza, że jest owinięte pamięcią, ale oznacza, że jest owinięte kodem, w tym przypadku jest owinięte z instrukcją if, a ponieważ Apple przywiązuje szczególną uwagę do wydajności w czasie wykonywania, chcą dać ci sposób, aby aplikacja działała z najlepszą możliwą wydajnością.

Update:

Wracając do tej odpowiedzi po 4 latach, ponieważ uzyskałem z niej najwyższą reputację w Stackoverflow :) Trochę źle zrozumiałem znaczenie rozpakowywania w tym czasie. Teraz po 4 latach wierzę, że sens rozpakowywania tutaj jest rozszerzenie kodu z jego oryginalnej kompaktowej formy. Oznacza to również usunięcie niejasności wokół tego obiektu, ponieważ nie jesteśmy pewni z definicji, że jest zerowy lub nie. Tak jak odpowiedź Ashley powyżej, pomyśl o tym jak o prezencie, który nie może zawierać nic w sobie. Ale nadal uważam, że rozpakowywanie to rozpakowywanie kodu, a nie rozpakowywanie oparte na pamięci jako użycie enum.

TL;DR

Wykrzyknik skutecznie mówi: "Wiem, że to opcjonalne zdecydowanie ma wartość; proszę go użyć."Jest to znane jako wymuszone rozpakowanie wartości opcjonalnej:

Przykład

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."

Źródło: https://developer.apple.com/library/content/documentation/Swift/Conceptual/Swift_Programming_Language/TheBasics.html#//apple_ref/doc/uid/TP40014097-CH5-XID_399

If john were a optional var (declared thusly)

var john: Person?

Wtedy byłoby możliwe, aby john nie miał żadnej wartości (w języku Objective, nil value)

Wykrzyknik w zasadzie mówi kompilatorowi "wiem, że to ma wartość, nie musisz tego testować". Jeśli nie chcesz go używać, możesz go warunkowo przetestować:

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

Wnętrze tego będzie oceniać tylko wtedy, gdy john ma wartość.

Niektóre duże perspektywy obrazu, aby dodać do innych przydatnych, ale bardziej skoncentrowanych na szczegółach odpowiedzi:

• przymusowe rozpakowywanie: let name = nameLabel!.text
• domyślnie rozpakowane opcje: var logo: UIImageView!
• Wymuszony casting: logo.image = thing as! UIImage
• nieobsługiwane wyjątki: try! NSJSONSerialization.JSONObjectWithData(data, [])

Każdy z nich jest inną konstrukcją językową o innym znaczeniu, ale wszystkie mają trzy ważne rzeczy w często:

1. Wykrzykniki omijają kontrolę bezpieczeństwa Swifta w czasie kompilacji.

Kiedy używasz ! w języku Swift, zasadniczo mówisz: "Hej, kompilatorze, wiem, że uważasz, że błąd może się tutaj zdarzyć, ale ja {38]}wiem {39]} z całkowitą pewnością, że nigdy nie nastąpi."

Nie wszystkie poprawne kody mieszczą się w polu systemu typu kompilacji Swifta-lub dowolnego języka, jeśli o to chodzi. Są sytuacje, w których można logicznie udowodnij, że błąd nigdy się nie wydarzy, ale nie możesz udowodnić tego kompilatorowi. Dlatego projektanci Swifta dodali te funkcje w pierwszej kolejności.

2. Wykrzykniki to potencjalne awarie.

Wykrzyknik mówi również: "Hej Swift, jestem więc pewien, że ten błąd nigdy się nie zdarzy, że lepiej dla Ciebie awaria całej aplikacji niż jest dla mnie, aby zakodować ścieżkę odzyskiwania dla niego."

Jednakże, kiedy widzę ! na wolności, rzadko używa się go tak uważnie. Zamiast tego, zbyt często oznacza to: "ta wartość była opcjonalna i tak naprawdę nie myślałem zbyt mocno o dlaczego to może być nil lub jak poprawnie poradzić sobie z tą sytuacją, ale dodanie ! sprawiło, że się skompilowało ... więc mój kod jest poprawny, prawda?"

3. Wykrzykniki najlepiej stosować oszczędnie.

Każdy z tych ! konstruktów ma ? odpowiednik, który zmusza cię do radzenia sobie z przypadkiem błędu/zera:

• warunkowe rozpakowanie: if let name = nameLabel?.text { ... }
• opcje: var logo: UIImageView?
• rzuty warunkowe: logo.image = thing as? UIImage
• wyjątki Zero-on-failure: try? NSJSONSerialization.JSONObjectWithData(data, [])

Jeśli masz ochotę użyć !, zawsze dobrze jest dokładnie rozważyć, dlaczego nie używasz ? zamiast tego. Czy awaria programu jest naprawdę najlepszą opcją, jeśli operacja ! nie powiedzie się? dlaczego ta wartość jest opcjonalna/niemożliwa?

Czy istnieje rozsądna ścieżka odzyskiwania Twojego kodu w przypadku braku / błędu? Jeśli tak, to koduj.

Jeśli nie może być nil, jeśli błąd nigdy się nie wydarzy, to czy istnieje rozsądny sposób na przerobienie logiki, aby kompilator o tym wiedział? Jeśli tak, zrób to; Twój kod będzie mniej podatny na błędy.

Okresowo przeszukuję całą bazę kodową pod kątem ! i sprawdzam każde jej użycie. Bardzo nieliczne zwyczaje stawiają na Kontrola. (W chwili pisania tego tekstu cały Framework Siesta ma dokładnie dwa instancje tego.)

Nie oznacza to, że powinieneś nigdy używać ! w swoim kodzie - tylko, że powinieneś używać go uważnie i nigdy nie robić z niego opcji domyślnej.

john jest opcjonalnym var. Więc może zawierać nil wartość. Aby upewnić się, że wartość nie jest zerowa, użyj ! na końcu nazwy var.

Z dokumentacji

"Po upewnieniu się, że opcja zawiera wartość, możesz uzyskać dostęp do jej podstawowej wartości, dodając wykrzyknik (!) na końcu nazwy opcjonalnej. Wykrzyknik skutecznie mówi: "Wiem, że ta opcja zdecydowanie ma wartość; proszę jej użyć."

Inny sposób na check non nil value is

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

Oto kilka przykładów:

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

Gdzie word jest wartością opcjonalną. oznacza, że może zawierać lub nie może zawierać wartości.

word = name 

Tutaj name ma wartość, więc możemy ją przypisać

var cow:String = nil
var dog:String!

Gdzie {[6] } jest rozpakowany oznacza, że musi zawierać wartość

dog = cow

Aplikacja ulegnie awarii, ponieważ przypisujemy nil do unwrapped

W tym przypadku...

Var John: Person!

Oznacza to, że początkowo John będzie miał wartość nil, zostanie ona ustawiona i raz ustawiona już nigdy nie będzie Nil-led. Dlatego dla wygody mogę użyć łatwiejszej składni dostępu do opcjonalnego var, ponieważ jest to "Unwrapped optional"

Jeśli pochodzisz z języka rodziny C, będziesz myśleć o " wskaźniku do obiektu typu X, który może być adresem pamięci 0 (NULL)", a jeśli pochodzisz z dynamicznie wpisywanego języka, będziesz myśleć o "obiekcie, który prawdopodobnie jest typu X, ale może być typu niezdefiniowanego". Żadna z nich nie jest poprawna, chociaż w sposób okrężny pierwsza jest bliska.

Sposób, w jaki powinieneś o tym myśleć, jest tak, jakby to był obiekt w stylu:

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

Kiedy testujesz twoja opcjonalna wartość z {[3] }to naprawdę zwraca foo.isNil, a kiedy mówisz foo! to zwraca foo.realObject z twierdzeniem, że foo.isNil == false. Ważne jest, aby to zauważyć, ponieważ jeśli foo rzeczywiście jest nil, gdy robisz foo!, jest to błąd runtime, więc zazwyczaj chcesz zamiast tego użyć warunkowego let, chyba że jesteś pewien, że wartość nie będzie nil. Ten rodzaj oszustwa oznacza, że język może być mocno wpisany bez zmuszania do testowania, czy wartości są wszędzie zerowe.

W praktyka, nie zachowuje się tak naprawdę, ponieważ praca jest wykonywana przez kompilator. Na wysokim poziomie istnieje Typ Foo?, który jest oddzielny od Foo, co uniemożliwia funkcjom akceptującym typ Foo otrzymywanie wartości nil, ale na niskim poziomie opcjonalna wartość nie jest prawdziwym obiektem, ponieważ nie ma żadnych właściwości ani metod; jest prawdopodobne, że w rzeczywistości jest to wskaźnik, który może przez NULL(0) z odpowiednim testem podczas rozpakowywania siły.

Jest inna sytuacja, w której zobaczyłbyś wykrzyknik jest na typie, jak w:

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

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

Możesz użyć tej metody, aby mieć metodę, która technicznie akceptuje wartość opcjonalną, ale będzie miała błąd runtime, jeśli jest nil. W obecnej wersji Swift to najwyraźniej omija twierdzenie is-not-nil, więc zamiast tego będziesz miał błąd niskiego poziomu. Ogólnie nie jest to dobry pomysł, ale może być przydatny przy konwersji kodu z innego język.

The ! oznacza, że jesteś siłą rozpakowywania obiektu ! / align = "left" / Więcej informacji można znaleźć w dokumentacji Apples, która znajduje się tutaj: https://developer.apple.com/library/ios/documentation/swift/conceptual/Swift_Programming_Language/TheBasics.html

Jeśli znasz C#, jest to jak typy Nullable, które są również deklarowane za pomocą znaku zapytania:

Person? thisPerson;

I wykrzyknik w tym przypadku jest równoznaczny zWłaściwość Value typu nullable w ten sposób:

thisPerson.Value

W celu C zmienne bez wartości były równe "nil"(możliwe było również użycie wartości " nil "takich samych jak 0 I false), stąd możliwe było użycie zmiennych w instrukcjach warunkowych (zmienne o wartościach są takie same jak "TRUE", a te bez wartości były równe "FALSE").

Swift zapewnia bezpieczeństwo typu poprzez podanie "opcjonalnej wartości". tzn. zapobiega powstawaniu błędów przy przypisywaniu zmiennych różnych typów.

Więc w Swift można podać tylko booleany na instrukcje warunkowe.

var hw = "Hello World"

Tutaj, nawet-choć' hw ' jest ciągiem znaków, nie może być użyty w instrukcji if, jak w objective C.

//This is an error

if hw

 {..}

Do tego musi być stworzony jako,

var nhw : String? = "Hello World"

//This is correct

if nhw

 {..}

The ! na końcu obiektu mówi, że obiekt jest opcjonalny i rozpakować, jeśli może w przeciwnym razie zwraca zero. Jest to często używane do przechwytywania błędów, które w przeciwnym razie spowodowałyby awarię programu.

W Skrócie (!): Po zadeklarowaniu zmiennej i upewnieniu się, że zmienna zawiera wartość.

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

W przeciwnym razie musiałbyś to zrobić na każdym po przekazaniu wartości...

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

John jest osobą opcjonalną, co oznacza, że może posiadać wartość lub być zerowe.

john.apartment = number73

Jest używany, jeśli john nie jest opcjonalny. Ponieważ john nigdy nie jest zerowy, możemy być pewni, że nie zadzwoni do mieszkania na zero. While

john!.apartment = number73

Obiecuje kompilatorowi, że john nie jest nil, a następnie rozpakowuje opcję, aby uzyskać wartość Johna i uzyskuje dostęp do własności mieszkania Johna. Użyj tego, jeśli wiesz, że john nie jest nil. Jeśli wywołasz to na zero opcjonalne, pojawi się błąd runtime.

Dokumentacja zawiera ładny przykład użycia tego, gdzie convertedNumber jest opcjonalny.

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

Mówiąc prościej, wykrzykniki oznaczają, że opcja jest rozpakowywana. Opcjonalna jest zmienna, która może mieć wartość lub nie -- więc możesz sprawdzić, czy zmienna jest pusta, używając instrukcji if let Jak pokazano tutaj, a następnie wymusić jej rozpakowanie. Jeśli wymusisz rozpakowanie opcji, która jest pusta, Twój program ulegnie awarii, więc uważaj! Opcjonalne deklaruje się poprzez umieszczenie znaku zapytania na końcu jednoznacznego przypisania zmiennej, np. I could napisz:

var optionalExample: String?

Ta zmienna nie ma wartości. Gdybym miał go rozpakować, program się zawiesi i Xcode powie Ci, że próbowałeś rozpakować opcję o wartości zero.

W PROSTYCH SŁOWACH

Użycie wykrzyknika oznacza, że zmienna musi składać się z wartości innej niż nil (nigdy nie będzie nil)

Cała historia zaczyna się od funkcji swift zwanej opcjonalnymi varami. Są to zmienne, które mogą mieć wartość lub mogą nie mieć wartości. Ogólnie swift nie pozwala nam używać zmiennej, która nie jest inicjalizowana, ponieważ może to prowadzić do awarii lub nieoczekiwanych powodów, a także serwera zastępczego dla backdoorów. Tak więc w celu zadeklarowania zmiennej, której wartość nie jest wstępnie określona, używamy'?'. Gdy taka zmienna jest zadeklarowana, aby użyć jej jako części jakiegoś wyrażenia, należy ją rozpakować przed ich użyciem rozpakowywanie jest operacją, za pomocą której odkrywana jest wartość zmiennej. dotyczy to obiektów. Bez rozpakowywania jeśli spróbujesz ich użyć, będziesz miał błąd czasu kompilacji. Aby rozpakować zmienną, która jest opcjonalnym var, wykrzyknik"!"jest używany.

Teraz są czasy, kiedy wiesz, że takie opcjonalne zmienne będą przypisane wartości przez system na przykład lub własny program, ale jakiś czas później, na przykład gniazda UI, w takiej sytuacji zamiast deklarować opcjonalna zmienna ze znakiem zapytania"?"używamy"!".

Tak więc system wie, że ta zmienna, która jest zadeklarowana przez"!"jest opcjonalny w tej chwili i nie ma wartości, ale otrzyma wartość w późniejszym okresie życia.

Tak więc wykrzyknik ma dwa różne zastosowania, 1. Aby zadeklarować zmienną, która będzie opcjonalna i otrzyma wartość zdecydowanie później 2. Aby rozpakować opcjonalną zmienną przed użyciem jej w wyrażeniu.

Powyższe opisy unika zbyt wielu mam nadzieję, że TECHNICZNE.

Jeśli użyjesz go jako opcji, rozpakuje opcję i zobaczy, czy coś tam jest. Jeśli użyjesz go w instrukcji if-else is to kod dla NOT. Na przykład,

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

Zmienna opcjonalna może zawierać wartość lub może nie być

Case 1: var myVar:String? = "Something"

Case 2: var myVar:String? = nil

W przypadku 2 to się rozbije.

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

ZAPYTAJ SIEBIE

• czy typ person? masz apartment członka / własność? Lub
• czy typ person masz apartment członka / własność?

_{aby zrozumieć, możesz potrzebować super-podstawowego poziomu zrozumienia generyków . Zobacz tutaj . Wiele rzeczy w języku Swift jest pisanych przy użyciu generyków. Opcje zawarte}

The poniższy kod został udostępniony z tego filmu. Gorąco polecam obejrzeć pierwsze 5 minut

Opcjonalny jest enum z tylko 2 przypadkami

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
}

Opcjonalne oprawa:

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
}

Kiedy mówisz var john: Person? masz na myśli takie:

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

Czy powyższy enum ma jakąś właściwość o nazwie apartment? Widzisz to gdzieś? To jest Nie tam w ogóle! Jednak jeśli rozpakujesz go ie do person! wtedy możesz ... to co robi pod maską to: Optional<Person>.Some(Person(name: "John Appleseed"))

Gdybyś zdefiniował var john: Person zamiast: var john: Person? wtedy nie musiałbyś już używać !, ponieważ Person samo w sobie ma element apartment

Jako przyszła dyskusja na temat dlaczego używanie ! do rozpakowania jest czasami nie zalecane zobacz to Q & A {22]}