This chapter will focus purely on Dart instead of Flutter. There are two primary options for executing these samples:

• DartPad (https://dartpad.dartlang.org): DartPad is a simple web app where you can execute Dart code. It's a great playground for trying out new ideas and sharing code.
• IDEs: If you wish to try out these samples locally with complete code support, then you can use either Visual Studio Code or IntelliJ.

Variables are user-defined symbols that hold a reference to some value. They can range from a single number to large object graphs. It is virtually impossible to write a useful program without at least one variable. You can probably argue that almost every program ever written can be boiled down to taking in some input, storing that data in a variable, manipulating the data in some way, and then returning an output. All of this would be impossible without variables.

Recently, a new trend has appeared in programming that emphasizes immutability. This means that once the values are stored in a variable, that's it – they cannot change. Immutable variables are safer, produce no side effects, and lead to fewer bugs as a consequence.

In this recipe, we will create a small toy program that will declare variables in the three different ways that Dart allows – var, final, and const. 

Install the following before you get started with this recipe:

• DartPad:
  1. In your browser, navigate to https://dartpad.dartlang.org.
• Visual Studio Code:
  1. Double-check that the DartCode plugin has been installed. If you followed the steps in the previous chapter, you should be good to go.
  2. Press Command + N to create a new file and save it as main.dart.
• IntelliJ:
  1. Double-check that you have the Dart plugin installed.
  2. Select Create new project. The following dialog will appear, asking what language and configuration you want to use: 

• 3. Pick Dart as your language and then select Console Application. This effectively runs the same commands as the command-line instructions but wraps everything in a nice GUI.

Let's get started with our first Dart project. We will start from a blank canvas:

1. Open main.dart and delete everything. At this point, the file should be completely empty. Now, let's add the main function, which is the entry point for every Dart program:

main() {
 variablePlayground();
}

2. This code won't compile yet because we haven't defined that variablePlayground function. This function will be a hub for all the different examples in this recipe:

void variablePlayground() {
 basicTypes();
 untypedVariables();
 typeInterpolation();
 immutableVariables();
}

We added the void keyword in front of this function, which is the same as saying that this function returns nothing.

3. Now, let's implement the first example. In this method, all these variables are mutable; they can change once they've been defined:

void basicTypes() {
 int four = 4;
 double pi = 3.14;
 num someNumber = 24601;
 bool yes = true;
 bool no = false;
 int nothing; 

 print(four);
 print(pi);
 print(someNumber);
 print(yes);
 print(no);
 print(nothing == null);
}

The syntax for declaring a mutable variable should look very similar to other programming languages. First, you declare the type and then the name of the variable. You can optionally supply a value for the variable after the assignment operator. If you don't supply a value, that variable will be set to null.

4. Dart has a special type called dynamic, which is a sort of "get out of jail free" card from the type system. You can annotate your variables with this keyword to imply that the variable can be anything. It is useful in some cases, but for the most part, it should be avoided:

void untypedVariables() {
 dynamic something = 14.2;
 print(something.runtimeType); //outputs 'double'
}

5. Dart can also infer types with the var keyword. var is not the same as dynamic. Once a value has been assigned to the variable, Dart will remember the type and it cannot be changed later. The values, however, are still mutable:

void typeInterpolation() {
 var anInteger = 15;
 var aDouble = 27.6;
 var aBoolean = false;

 print(anInteger.runtimeType);
 print(anInteger);

 print(aDouble.runtimeType);
 print(aDouble);

 print(aBoolean.runtimeType);
 print(aBoolean);
}

6. Finally, we have our immutable variables. Dart has two keywords that can be used to indicate immutability – final and const. 

7. Add the following function to the main.dart file:

void immutableVariables() {
 final int immutableInteger = 5;
 final double immutableDouble = 0.015;
 
 // Type annotation is optional
 final interpolatedInteger = 10;
 final interpolatedDouble = 72.8;

 print(interpolatedInteger);
 print(interpolatedDouble);

 const aFullySealedVariable = true;
 print(aFullySealedVariable);
}

An assignment statement in Dart follows the same grammar as other languages in the C language family:

// (optional modifier) (optional type) variableName = value;
final String name = 'Donald'; //final modifier, String type

First, you can optionally declare a variable as either var, final, or const, like so:

var animal = 'Duck';
final numValue = 42;
const isBoring = true;

These modifiers indicate whether the variable is mutable. var is completely mutable as its value can be reassigned at any point. final variables can only be assigned once, but by using objects, you can change the value of its fields. const variables are compile-time constants and are fully immutable; nothing about these variables can be changed once they've been assigned.

Please note that you can only specify a type when you're using the final modifier, as follows:

final int numValue = 42; // this is ok
// NOT OK: const int or var int.

After the final modifier, you can optionally declare the variable type, from simple built-in types such as int, double, and bool, to your own more complex custom types. This notation is standard for languages such as Java, C, C++, Objective-C, and C#.

Explicitly annotating the type of a variable is the traditional way of declaring variables in languages such as Java and C, but Dart can also interpolate the type based on its assignment. In the typeInterpolation example, we decorated the types with the var keyword; Dart was able to figure out the type based on the value that was assigned to the variable. For example, 15 is an integer, while 27.6 is a double. In most cases, there is no need to explicitly reference the type; the compiler is smart enough to figure this out. This allows us, as developers, to write succinct, script-like code and still take advantage of inherent gains that we get from a type-safe language.

The difference between final and const is subtle but important. A final variable must have a value assigned to it in the same statement where it was declared, and that variable cannot be reassigned to a different value:

final meaningOfLife = 42;
meaningOfLife = 64; // This will throw an error

While the top-level value of a final variable cannot change, its internal contents can. In a list of numbers that have been assigned to a final variable, you can change the internal values of that list, but you cannot assign a completely new list.

const takes this one step further. const values must be determined at compile time, new values are blocked from being assigned to const variables, and the internal contents of that variable must also be completely sealed. Typically, this is indicated by having the object have a const constructor, which only allows immutable values to be used. Since their value is already determined at compile time, const values also tend to be faster than variables.