forced-unwrapping

I'm used to write code with early return/golden path in Objective-C. I tried this approach in Swift, and noticed that early return comes at the expense of using the forced unwrapping operator ( ! ) when optionals are involved. Take a method that calculates the size of a directory. First, the golden path version: private func calculateSize_GoldenPath(directory:String) -> UInt64 { let fileManager = NSFileManager.defaultManager() var error : NSError? var contents = fileManager.contentsOfDirectoryAtPath(directory, error: &error) as [String]? if contents == nil { NSLog("Failed to list directory

In swift documentation, you can find this : if convertedNumber != nil { println("convertedNumber has an integer value of \(convertedNumber!).") } // prints "convertedNumber has an integer value of 123." With this explaination Once you’re sure that the optional does contain a value, you can access its underlying value by adding an exclamation mark (!) to the end of the optional’s name. The exclamation mark effectively says, “I know that this optional definitely has a value; please use it.” This is known as forced unwrapping of the optional’s value: Ok, got it, but what's the usefulness of it ?

I no longer see Xcode complaining that certain things need optionals (the "?"). Now it is always forced unwrapped (the bang "!"). Is there any reason to use optionals anymore when we now have forced unwrap? I don't really know what you mean when you write that you no longer see Xcode complaining that "certain things need optionals. Now it is always forced unwrapped" . These two sentences contradict eachother: You may have non-optional variables as much as you wish, but optional can really nice once you get to know all the benefits of using them. If you have a property that is not an optional,

When call a function of an object instance, the object may be not exist(optional type), it seems like you can always put an question mark behind the object name, instead of put an exclamation mark behind the object name, and not crash. window!.rootViewController = containerViewController // forced unwrapping // Can change to question mark and not crash. window?.rootViewController = containerViewController // Optional chaining Is that in the place of use forced unwrapping, you can always change to use optional chaining, and the result is same? If yes, what is the difference? The difference is

This question already has an answer here: What is an optional value in Swift? 13 answers Below is the code for optional string for variable name yourname and yourname2. Practically what is difference between them and how forced unwrapping in case of yourname2 var yourname:String? yourname = "Paula" if yourname != nil { println("Your name is \(yourname)") } var yourname2:String! yourname2 = "John" if yourname2 != nil { println("Your name is \(yourname2!)") } The String? is normal optional. It can contain either String or nil. The String! is an implicitly unwrapped optional where you indicate

The NSMetadataItem class in the Cocoa framework under Swift contains the following function: func valueForAttribute(key: String!) -> AnyObject! I'm still learning the difference (and details) between forced unwrapping and optional chaining. In the above function, does this mean: The key parameter must have a value, and The return value is guaranteed to have a value? My primary concern is with the exclamation point following the return value - once I have assigned the return value: var isDownloadedVal = item.valueForAttribute(NSMetadataUbiquitousItemIsDownloadedKey) Do I need to include an if