Welcome to the second insertion to my Learning Typescript series, where I will be learning Typescript and passing on the glorious knowledge.
While the last submission dealt more with what Typescript is and when it is most beneficial to use, this article will deal more with viewing some beginner code to lay some nice groundwork, ya dig?
Those types are (in a specific order I will never tell a soul):
string- anything enclosed in ' ' or " "
number- any number value
boolean- a value of
null- an absence of value
undefined- when no value is assigned before using variable or object
Since Typescript is so 'type-y', when a variable is declared to have a certain type, this variable can never change its type. It may change its value, but not the initial declared type.
But hold your horses! What if you create a variable but you don't assign it any value for Typescript to know what it is! Well, in this case, TS brings in its handy
any type, that allows this variable to hold any value, and be changed to any type. However, this goes against what TS is trying to help you with, which is error checking for your types to be used properly. In the case you do not want TS to do this, there is also a
noImplicitAny flag that can put a stop to this. We'll talk about how to do that later, promise:)
I'm more of a visual learner, so I will put in some graphics below to show everything we have learned so far. But first, we need to talk about how Typescript allows us to declare our variables.
When declaring a variable with
var, TS gives us the option to declare the type as well, using Type Annotation. Take a look see here meow:
This is cool and sometimes useful. From what I see, this looks important only when you want to, or not want to, use
Typescript is also pretty smart and will sometimes just assume it knows what you mean when you set a variable up with a value. That would then look as follows in the picture below that you will now see:
That's a little bit better. I like that way, but there are a couple more to know about.
Sometimes (and please stop asking me 'when?') we need to have a variable set to multiple types, but not to the
any type. In this case, we would use the Union Type, as such that you are about to look at currently:
Something to note is that we could use
null | undefined, but TypeScript comes with the
strictNullChecks compiler option which does not allow assigning both to a variable. So not recommended, unless you turn this off.
And finally, the last option that we have to declare variables and give them some TYPES. TS also gives us the option to create our own type, using the
type keyword. There are a couple ways to do this, but we'll need to discuss other things first, so let's talk later about that! For now, this is setting a custom type while also using Union Types. Let's get it going and have a read of the thing we're talking about:
drink type can accept either of the values
'water', 'coffee', or 'tea'. Notice how we use the
| to create a union type. In this case, any variable assigned the type
drink can accept any of the three values. We'll definitely be coming back to this one.
How wild, we just learned about types in Typescript. What a world. This is a good amount of reading for not too much payout, but I promise we are laying some SICK ground work here. Keep looking out for that third post, as it is going to be one you do not want to miss, my friend. Thank you and look out for the next submission, don't forget to follow me here and on Twitter! Peace!