All language subtitles for 029 Nullables In Kotlin__en

Welcome back and this video, I would like to start with a little history lesson in order to get to

knuckleballs, because nobles are a type that is only necessary because of a decision of Tony Aware,

which was made in 1965 as part of his ALGOL w language development.

So he invented this language.

And then he also invented this now a reference which now finally results in a lot of null reference

exceptions or multipoint or exceptions.

So errors that come up quite often in programming and they are called by himself as a billion dollar

mistake or his billion dollar mistake.

So it was the invention of the null reference in nineteen sixty five.

At the time, I was designing the first comprehensive type system for references in an object oriented

language.

Algol w my goal was to ensure that all use of references should be absolutely safe with checking performed

automatically by the compiler.

But I couldn't resist the temptation to put it in the reference simply because it was so easy to implement.

This has led to innumerable errors, vulnerabilities and system crashes, which have probably cost a

billion dollars of pain and damage in the last 40 years.

And I believe that is quite a lot more than just a billion dollars because it takes so much time very

often to figure out what the problem is.

And now it's a lot easier than it was in the past.

I can imagine it was really a pain back in the day.

And yeah, now there are a bunch of cool tools which make life so much easier when it comes to no pointers

or null references.

So we're going to look at one of them, which are unknowables in Scotland.

And if you come from a programming language like Swift, then you know this term as a optional.

So Hainsworth is called optional here.

It's called the nullable.

So the idea is just that it's a null type that were a type that allows to be a null type.

So just a type that allows variables to have a null as its value.

So not zero, but a null and then some programming languages.

It's called nil in objective C, for example, but in.

Java and in Courtland's called not so let's go back to our code, and here I cleaned up again, so I

have only my main function.

So Kotlin supporters notability as part of its type system, that means that you have the ability to

declare whether a variable can hold a value or not.

And by supporting the lability in the type system, the compiler can detect possible null pointer exception

errors at compile time and reduce the possibility of having them thrown at runtime.

And that is super useful because you can see no pointer exceptions before they happen, so to speak.

So before they happen on your phone, for example, when developing apps.

Right.

So let's see how we can even create such a situation.

So first of all, I'm going to create a new variable and I'm going to call this one name and it's going

to have the value of Dennis.

And I'm going to explicitly state that this is going to be a string and it will make a little more sense

once we go to the nullable types.

So what I can do is I can assign a new value here.

So instead of Dennis, I could rename myself and my name would be Adam.

But what I cannot do is I cannot assign null to my name variable.

Why is that?

Well, because as you can see here, now cannot be a value of a non null type string.

So if you create a variable, as we've done in the past, then it's a non null type and it doesn't accept

to be empty.

So it has to have a value.

So what can we do if we want to have a variable that accepts null as a value?

Well, we can make it a nullable value.

So I'm just going to call this one nullable.

Name and it doesn't have to have this nullable at the beginning, so this is just a name that I give

it and I explicitly say again that it's a string, but now I'm adding a question mark.

So this question mark now allows me to assign an empty value there so I can go ahead and say nullable

name is going to be no.

So here I don't get a compilation error and it totally accepts it.

That's because I said, OK, this will be of type string nullable or elf type nullable string.

So we have this new variable and I call this one nullable name and it gets a value at the beginning

and then I assign null to it.

But of course I could have also assign null to it straight from the get go.

OK, that could have been an option as well.

So now I have a nullable.

And let's have a look at the difference between the two, so what is really the idea behind all of that?

Now, let's say I want to go ahead and get the length of my name.

Well, I can very easily do so by using name that length.

Now, if I go ahead and do the same thing with my nullable name, I suddenly get an error because it

says.

Only safe or none now asserted calls are allowed on the nullable receiver of type string.

So how can we fix that?

Well, there is one way and there is another way.

So let's go ahead with the first way, which is the old fashioned way.

So this is how you would have done it in the past if you hadn't or when you didn't have the option to

use Nullable.

So what you could do is you could check if nullable name is not equal now, only then go ahead and do

that.

And otherwise.

Just return now, so that would be an option to do it.

OK, so you can see we can now access the length if the nullable name is not null, otherwise it will

return null.

All right, so that's the old fashioned way, and this is not necessary in Scotland because we have

a much shorter approach to this.

So instead of doing all of that here, what we can do is we can go ahead and create this variable,

lend to as nullable name that length.

But now we add a question mark here.

OK, so this line here is the same as this line over here.

Now, the problem, of course, is that our nullable name here is in fact now.

So now I will get rid of this here.

And as you can see now, it's not much anymore.

So we can even get rid of this whole line.

But I'm just going to comment about.

OK, so this is a lot of work you need to put in a lot of work, you need to write all of this code

right.

Or you can just add a question mark to the nullable variable that you have here.

And it does the same thing for you.

So it says, OK, either it's going to work and if it works, then give the length.

So if the nullable name is in fact, not now.

So if there is a value in there, like in our case, it's Dennis, then just store the result in linta

and otherwise store null and then to.

All right, back here.

Now, you can go ahead and not only get properties of nullable variables, but also you can use methods

on them.

So in this case, I'm using the two lower case method on my nullable name.

And if I run this, then what?

It will return.

If it's empty, it will just return null.

So otherwise it's going to return the name doneness in my case, so that we are Stenness.

But let's say we make it now.

So I uncommented this line here and I run it again then.

Well, it's not even accepting it, so I can't even run the code.

It's even.

Not even printing it, so that's the thing about Nullable.

Variables and using the question mark here.

Which is the safe call operator.

So now let's say we only want to do something or print something, if the variable is in fact not know

what we can then do, we can use the safe call operator with let.

So let me show you that real quick.

So here.

I'm just going to use the nullable name again.

Then the question mark, so I need to use the safe call operator, not let, and then in curly brackets,

the code that I want to execute only if it's not now, so only if there is a value in there.

I want to execute something.

So this is a very short way of doing another if else statement here.

OK, so let me run it again.

And there we are.

It says five, because the length of my name is five.

So now let's say it's now let's test it and we are there's nothing, so it says nothing.

It didn't do anything because our nullable name, in fact, was null.

All right.

So that's the first part of Nullable.

In the next video, we are going to look at the Elvis operator and not no assertion operator.

So, yeah, let's just check those out, because then we have a rather full understanding of what those

multiples do and how we can use them.

So see you in the next video.