This is good to know.

thanks for sharing too

Yeah I learned about this recently, myself. It makes guard really attractive, adds in code clarity, especially when you are guarding against edge cases.

I always use guard let for error handling and unwrapping optionals in general. I rarely have to not 'return' if an optional if nil.

oohhhh that's why it's called "guard"

Glad you found it helpful!

@@seanallen From the beginning I've found Swift one of the most complicated programming languages (if let guard, try, catch, _ names, ??, ?, !, $0) I've ever seen. Even Objective C was more logical. I understand that you need to clear your memory from objects, etc. but why with ??, ?, !, guards, try?. I hope that Apple will create a more accessable language fore a wide audience in the near future.

Thanks Jake! Much appreciated. Happy to hear I'm helping out.

Thanks! Glad you like my teaching style 😀

That's awesome to hear, AliReza 👍. Happy they have been helpful.

That's awesome to hear, Reade! Glad you're enjoying the channel. Happy to help if I can!

These are a little older now, but they still hold up (which is why I haven't remade them). Glad you're enjoying the channel! These were some of my first videos... I like to think my recent ones are even better 😀

Thanks Jeff! Glad you like them 😀

Glad you enjoyed it!

Glad it helped, Nasir!

Thanks for the kind words! Best of luck in the interview!

Happy to hear it helped, Si Maw!

Thanks for the kinds words, Srav!

Hey Tashi! That is a great point. Nil-Coalescing comes in handy many times. Using your example to explain for others (let a= b ?? c), if "b" happens to be nil, then you set "a" to a default value that you've hardcoded ("c" in this case).

Particularly good for setting default values where there are none; like when parsing a portable array that lacks a key -> value pair that requires a value.

Yes! I use nil coalescing when building default values for my models.

Happy to help, Sangita! Glad you found the video helpful.

Quick and to the point!

Thanks Kristijan! I agree... when I was starting, optionals took me a little bit to understand, and I remember what parts confused me, so I tried to be extra clear on those.

Glad you liked it!

Glad to hear it!

Thanks for the kind words, Jacob. You're not alone, I have a lot of people say that I speak to quickly and I've been working on slowing down.

Glad it helped, Emil!

+kanduri vivek Thanks Kanduri! Glad you're enjoying the channel. More on the way!

Thanks for the kind words, Lars!

Thanks Jerome!

Happy to help!

Glad you enjoyed it!

Glad you liked it!

Thank you 🙂

Thanks RochNoure!

Thanks Steve. Hope you're unwrapping optionals like a pro now!

Thanks for the continued support, Rahul!

Thanks for the sub, Shail! Happy to have ya on the channel.

Glad you enjoyed it, Kalyani!

Happy to help, Hari!

Thanks Gunjan!

Happy to help!

Thanks Rajagopal!

Thanks!

Happy to hear it helped 👍

Thanks Marv. Glad you enjoyed it 👍

Thanks for the kind words. Been a huge basketball fan my whole life.

Thanks for the sub! Working on it...

This depends on your style guide and personal preference. But it is common practice to use the same name.

Hey John, are you talking about when you create an outlet from storyboard (@IBOutlet weak var myButton: UIButton!)? If so, that's implicitly unwrapping the storyboard object. You can read more about implicitly unwrapped optional here: krakendev.io/when-to-use-implicitly-unwrapped-optionals/

Thanks Sean! I will look into it!

Solid.

Thanks Brian!

Great work Allen .. thank you so much to explain this topic

Oops! I found your channel too late

Why too late?

Waiting for an answer for a year now. @@seanallen , maybe @Mr Coder answer was nil and it was force unwrapped.

Thanks Victor... about the speaking speed, this is one of my much older videos. I've worked on that and in my more recent videos it's not so much of an issue.

@@seanallen Thanks Sean, but as a temporary fix I am watching your videos in 0.75x speed. Anyway, awesome work, I have learned a lot.

It's dangerous and should never be the normal way you do things. There are a few exceptions, but you should default to unwrapping.

When you force unwrap you're basically saying "I have considered all the possible scenarios and this will never be nil; I know everything". Which is not true, to say the least 🤣

@@seanallen tableView cells: let cell = tableView.dequeueReusableCell(withIdentifier: "WorkoutCell", for: indexPath) as! WorkoutCell

Ever had a null pointer exception in Java? Optionals are added type safety around nil pointers to avoid these pesky exceptions. Think of it this way, in swift the compiler is your friend. Any value that may be nil should be specified as an optional so that the compiler will generate warnings for you when you try to directly manipulate the value. By doing `guard `or `if let` statements, you are working with the compiler to get the `.Some` part of the optional, aka the value. This way, you can write certain functions that take all non optional values, and the compiler will make sure that you never pass an optional to said `func`. You no longer have to think, did I check for null? everywhere in your app. In java, you can check for null all over the place, but there's no idiomatic, built in way (if any at all) to disallow someone from calling your function with an object that hasn't been explicitly checked for null. If you've written good defensive Java, you'd be doing all the same null checks that are handled with optionals here. The major difference is, in Swift, the compiler has your back and makes sure you don't miss these checks and lets you write pure functions that dont have to worry about nil since the parameters are non optional.

Hey Adis! Yes, this is called implicitly unwrapping the optional. It is similar to force unwrapping. Here is a good blog post all about that: krakendev.io/when-to-use-implicitly-unwrapped-optionals/

Guard can also unwrap the value. In the example you gave, "number" still wouldn't be unwrapped.

It will be the same if you rearrange it slighly.. if let myVar = number { }else { print("Exiting") return} guard sort of works in the opposite sense like guarding to make sure something has happened rather that checking if(statement) something has happened that's why it's in the return is in the else block and the other code would be in the first block. Using guard would be cleaner

Got it... guard let isHeader = wrapper?.isHeader, isHeader else { return .zero }

That's called Nil Coalescing.

Sean Allen thanks!

No. You shouldn't.

I agree 100% that you should be cautious and use force unwrapping VERY sparingly. However, I wouldn't say you should NEVER use it.