Original subtitles

0 Now in the last lesson, we saw inside dartpad when we tried to change the variable that's holding a 1

string namely a string of characters, so basically text. 2

And we tried to make it hold a number instead, or an integer. 3

It wasn't really happy with that and it didn't want to do it for me. 4

In order to understand what's going on, we have to understand Dart data types. 5

Dart is what we call a statically typed language. 6

What does that mean? 7

Well let's say we create a variable called myVar. It kind of acts a bit like one of those children's 8

toys which has different shaped holes and you have to fit the right shape inside the right hole. 9

So for example, if I had something that was circular, then that would go through the circular hole. 10

But if I had something that was a triangle for example, then it won't go through the hole. And it's very 11

similar 12

when we have statically typed languages like Dart. Essentially when I create a variable and I say that 13

this variable can only hold pieces of text, 14

then if I try to put a number into this variable it won't accept it. 15

It says I can't mix up my types. 16

What are these types that we're talking about? 17

Well they're essentially types of data. 18

So we've got strings, which are essentially a string of characters like a string of pearls, but we've 19

strung together some characters instead. 20

And in Dart, its convention to have a single quote around the piece of text to represent a string. 21

So we know that if we don't have single quotes, the computer will think that we're writing code. But if 22

we do have the single quotes, then it'll know that we're trying to specify a string and it doesn't treat 23

it as code. 24

Now there's also int, which is short for integer. And integers are basically just whole numbers. 25

They can be positive or negative, but they can't have a decimal point. 26

So if you wanted a decimal point in Dart, you would be working with something called a double. 27

And this is a data type that allows you to have a decimal point 28

and it will hold your data with all those numbers after the decimal point. 29

Now the last data type that you'll see commonly occurring, is something called a bool which is short 30

for a boolean. And it's a data type that can only hold one of two values, either true or false. 31

And all of these data types together are known as primitive data types. 32

So they're the most basic fundamental building blocks of any computer program. 33

And we're going to use them as we build up more and more complex apps to store more and more complex 34

data. Coming back to this idea of Dart being a statically typed language. 35

It means that at the point when we create the variable, it will get a data type and at a later date, we 36

can change what's stored inside the variable as long as we don't change the data type. Heading back into 37

our dartpad 38

let's delete everything inside our main function. And this time let's create some other variables. 39

We're going to create a variable a, and we're going to assign this to the value 40

hello. 41

Now at the moment when I double click on this a variable ,the dartpad very helpfully points out that 42

this is a string. 43

This variable holds data that has to be of the type string. 44

So 45

hello 46

works or bye 47

or anything that's inside a set of single quotes will work just fine. 48

But I can't change the data type of this variable. 49

I can't for example change it to 123. 50

Now this is what we mean when we say that Dart is a statically typed language. 51

If it was a dynamically type language and there's many of those out there, then this would be a perfectly 52

valid thing to do. 53

And it won't complain at all. 54

It'll just silently suck it up and probably judge you, 55

the human whose programming this, for being so indecisive. 56

But it won't actually have a problem. 57

And one of those languages is JavaScript. 58

So if I straight up just take these two lines of code that we've already seen leads to all sorts of 59

problems in Dart, and I put it inside a JavaScript playground such as jsbin, and if I console log, which 60

is the JavaScript equivalent of print, the value of the variable a, then it'll happily print 123 61

in here. 62

And if I put it here, then it'll print hello. 63

So you can see that these are completely different data types and being able to change the data type 64

that a variable holds, makes JavaScript a dynamically typed programming language. 65

Now there are pros and cons of each type of programming language. Dynamically typed languages are more 66

flexible. 67

You can change things on the fly, where statically typed 68

programming languages are generally safer. You're less likely to run into problems because you forgot 69

that, 'oh a was actually meant to be a variable that only holds strings'. 70

It'll actually enforce it for you. 71

Now with Dart though, there is a way of turning it into a dynamic programming language. And it might actually 72

trip you up at some point. here in this line. 73

We've created our variable a and we've set it to equal hello. 74

But the reason why 'a' knows that it should store a string is because it's inferring the data type from 75

the value. Because it knows that the value that you've given it, is a string. 76

So therefore I must be a variable that holds strings. 77

And similarly if I changed 'a' to hold a number, then it will be able to correctly infer that 'oh I'm actually 78

a variable that holds integers' And it's very clever about this because as soon as you change the value 79

to have a decimal point, then it knows 'oh actually now I'm a variable that can hold doubles.' 80

But what if you did this. 81

What if you create this variable and you don't give it a value at all? 82

You just say here's an empty box. 83

It's called a''. 84

And at some point later on down the line, you decide to give it a value let's say, 'a' equals 12 85

3. 86

Now what do we think is the data type of 'a' at this point? 87

Now at this point, 'a' is now dynamic. And I can prove that because I can now set 'a' to equal a string and 88

it won't complain about this at all. 89

And in fact I can even print my string 'a' into the console and everything will work just as you would 90

expect for a dynamically typed programming language. 91

So what's going on here? 92

Well, Dart also has a data type called dynamic. And what this means is that you can create a variable that 93

doesn't have to have a fixed data type. 94

So if I was creating a variable and I wanted it to be a fixed string data type, then I would write string. 95

If I wanted to create a variable that had an integer as the data type, then I would write 'int' in the beginning 96

instead of var. 97

Now I could also write dynamic as the key word. 98

And now my variable c is dynamic. 99

So if 'a' is only able to hold strings, then I can put the value 'hello' inside it. But I can't put the value 100

123. 101

This will generate an error. But if I had my variable created as a dynamic type, then I can put any sort 102

of data in it. I can put 123 and that will be just fine. It'll print out c without a problem 103

I can change c into a string if I wanted to. 104

And now when I print the string, hello 105

now gets printed. 106

This is how dynamic types work. And when we created the var without giving it a value, we essentially 107

created a dynamic type variable. 108

So when I click on 'a' you can see it's data type is dynamic. Because it didn't get a value, it couldn't 109

work out what data type it was meant to hold. 110

So it instead created a dynamic type. 111

The important thing here to take away is that if you want to use Dart for its type safety, 112

so ensuring that you don't mess up the data type and you don't accidentally put in the wrong thing that 113

you didn't mean to, then it's best to create your variables with the data type to start with. 114

So if we wanted to create a variable that holds a string, then we would write string a = hello or 115

whatever value you want. 116

If we wanted to create a variable that's an int, then we would write int b = 123 or whatever 117

maybe. 118

And if you're creating a variable that you don't yet have a value for, say the score of the game as soon 119

as the game starts, won't really have a value. 120

Well then in that case you can create an int and give it a name, but not give it a value. 121

But this way further down the line, c can never pulled a string. 122

It can't ever change its data type because when we created it, we already specified it. 123

So in terms of best practice, I recommend to avoid using var, and avoid using dynamic data types unless 124

you actually need it for a reason. Because it can lead to unexpected things happening in your code, and 125

it can lead to crashes down the line. 126

So in this lesson, we talked about data types and the primitive data types that Dart has access to. 127

And we also talked about how Dart can be a statically typed language because once you create a variable 128

that has a fixed type, then it won't accept values that are of different data types. 129

But we also saw how Dart can have this dynamic typing, which makes it a lot more similar to dynamically 130

type languages such as JavaScript. Now the official Dart documentation says that Dart 2, 131

so the latest version of Dart, is a statically typed language. Which means that we can't switch around 132

the data type of a variable once we've created it. But it does say that you can use this dynamic keyword 133

if you want to be able to change the data type. 134

But it does of course remove the benefits of a type-safe language. So I recommend to avoid using the 135

keyword var, and avoid using dynamic types when you're working with Dart, in order for your code to be less 136

error prone. 137

Now at this stage, it might not affect us very much. But later, on as our code gets more complex and does 138

a lot more things, it becomes a lot easier to work with Dart as a statically type language. 139

But if you come from JavaScript or another language that has dynamic typing, just be aware that you can 140

also do the same with Dart. Now in the next lesson, 141

we're going to head back to making our apps and we're going to learn about stateful and stateless 142

widgets in Flutter.