Learn Dart in 5 minutes

Do you want to learn Flutter or just interested in Dart? Let’s do a 5 minute run-through of the Dart language to get you up to speed!

We are going to cover variables, types, operators, control flow, functions, and classes, so let’s dive in.

Variables

Variables are used to store information in memory using a keyword that you define. The information stored can be of many different types. For example, numbers.

1
final x = 10;

Types

Numbers

In Dart, there are two types of numbers: int and double. Integers are whole numbers, while doubles can be fractions or decimals.

1
int x = 10;
2
double y = 10.0;

Strings

There are also strings. A string is a sequence of characters used to represent text in programming. For example, “Hello, world!” is a string.

1
String x = "Hello, world!";

And technically, numbers can be strings too, but the difference with the string data type is that you won’t be able to add those numbers since a string is the character representation of that number, not the number itself. Well, technically you can still add them, but it would just put the characters next to each other. This is called concatenation.

1
String first = "4";
2
String second = "5";
3

4
print(first + second); // Output: "45"

Booleans

Then there is the boolean type, which represents either true or false.

1
bool x = true;
2
bool y = false;

List

Next, we have the list data type, which can also be called arrays. A list is exactly how it sounds: it can hold a list of other data types.

1
List<String> fruits = ['Apple', 'Banana', 'Orange'];

Including a list of lists if you want to get crazy.

1
List<List<int>> nestedList = [
2
  [1, 2, 3],
3
  [4, 5, 6],
4
  [7, 8, 9]
5
];
6

7
int value = nestedList[1][2]; // 6

Map

Next is a data type called map, which is very similar to a list except that each item in a map has a key-value pair. In this example, the key is the name of a person and the value is their age. You can retrieve the age of each person by using the key of that key-value pair.

1
Map<String, int> ages = {
2
  'Tadas': 28,
3
  'Robert': 28,
4
  'Your Mom': 69,
5
};
6

7
print(ages['Tadas']); // Output: 28

Others

The last data type is functions, but we will cover functions later in this article.

These are the data types you will use 99% of the time.

However, there are a few others like records, sets, and runes. You really don’t need to worry about these, but for the sake of completeness:

• Records are like two previously mentioned data types bundled into one.

1
final (name, age, job) = ('John', 25, 'Engineer');
2
print(name);  // Output: John

• Sets are like lists, but each item has to be unique.

1
var fruits = {'Apple', 'Banana', 'Orange'};
2

3
fruits.add('Mango');
4

5
print(fruits);  // Output: {Apple, Banana, Orange, Mango}

• And runes are a datatype commonly used for emojis.

1
var str = 'Hello, 🌍!';
2

3
print(str.runes);  // Output: (72, 101, 108, 108, 111, 44, 32, 127757, 33)

Operators

Next, we move onto operators in Dart. Operators are used to perform logic on your data. You can:

• + - Add and subtract.
• * / Multiply and divide.
• % Get the remainder of a division.
• > < Check the relationship of data using greater than or less than.
• == Check if two values are equal to each other.
• || && There are logical OR and AND operators.
• ?? The if-null operator checks if the first value is null it will use the second value.
• ? : Conditionals check the output of the first expression and if it’s true use the second, if false use the third.
• = And lastly, there are assignment operators which you use to assign values to a variable.

Here is a complete list of operators in Dart, but the ones we discussed are most commonly used.

Control Flow

Next is control flow statements. Just like the name sounds, these control the execution flow of your application.

If-else

Let’s start with if-else statements. These check if a condition is true. If it is, execute the logic within the first bracket pair, otherwise execute logic from the second bracket pair.

1
final temperature = 30;
2

3
if (temperature > 25) {
4
  print('Hot day.');
5
} else {
6
  print('Cool day.');
7
}

For loops

There are also for loops. This can either loop through a list of objects, or define your own loop.

1
for (var i = 0; i < 5; i++) {
2
  print(i); // Output: 0,1,2,3,4
3
}

While loops

There are while loops which are similar to for loops but you do the incrementing within the loop.

1
var i = 0;
2

3
while (i < 5) {
4
  print(i); // Output: 0,1,2,3,4
5
  i++;
6
}

Switch case

And lastly, switch case statements which are similar to if-else statements but they are nicer to use when you have a lot of conditionals.

1
var color = 'red';
2

3
switch (color) {
4
  case 'red':
5
    print('Color is red');
6
    break;
7
  case 'blue':
8
    print('Color is blue');
9
    break;
10
  default:
11
    print('Unknown color');
12
}

Functions

We mentioned a variable type called functions. But it is not just a variable type. Functions are a way to organize your code into sections to make your application code more readable. A function takes defined inputs and returns an output. For example, the print function takes an input and displays it in your terminal.

1
for (var i = 0; i < 5; i++) {
2
  print(i); // Output: 0,1,2,3,4
3
}

Another example is a function to calculate tips. Here is what the function might look like and instead of having to write out the equation every time, you can use this calculate tip function.

1
double calculateTip(double bill) {
2
  double tip = bill * 0.20;
3
  return tip;
4
}
5

6
double bill = 50.0; // Example bill amount
7
double tip = calculateTip(bill);
8

9
print(tip.toStringAsFixed(2)); // Output: 10.00

In Dart, functions can also be variables. So you can assign a function to a memory location, or even pass in a function to another function.

1
void executeFunction(void Function() action) {
2
  print("Before executing function...");
3
  action(); // Call the passed function
4
  print("After executing function...");
5
}
6

7
void sayHello() {
8
  print("Hello, Dart!");
9
}
10

11
void main() {
12
  executeFunction(sayHello);
13
}

Asynchronous Programming

These functions can run synchronously or asynchronously. This is related to the execution order of the code. Synchronous code runs in a row. That means each line of code gets executed in order.

Asynchronous code doesn’t always get executed in order.

This is because it relies on information outside the execution loop.

The most common example of this is when you call a database. If a database call was performed synchronously, the entire application would come to a halt, until the information from the database was retrieved.

With asynchronous programming, your application can keep running until the information comes back from the database, and then it gets processed.

This type of data is called Futures.

Dart also has Streams, which is data that is streamed into your application.

To be clear, we used a database as an example, but futures and streams can be used internally within an application.

Classes

The last thing we will cover in Dart is classes. Classes are an object-oriented programming principle that separates your code into objects.

1
class Person {
2
  Person(this.name);
3

4
  String name;
5

6
  void greet() => print('Hello, I am $name!');
7
}
8

9
void main() {
10
  final person = Person('Mom');
11
  person.greet(); // prints "Hello, I am Mom!"
12
}

This is a layer that adds even more separation than functions. A class is the definition of the code, but when it is used within an app it becomes an object. Each object can have its own variables and functions that are tied to that class.

1
class Car {
2
  Car(this.model);
3

4
  String model;
5

6
  void drive() => print('$model is driving!');
7
}
8

9
void main() {
10
  final car1 = Car('Tesla');
11
  final car2 = Car('BMW');
12

13
  car1.drive(); // Tesla is driving!
14
  car2.drive(); // BMW is driving!
15
}

This lets you separate your code into more simple, reusable components, making it easier to manage and scale. Instead of working with scattered variables and functions, you can group related data and behavior into a class.

For example, instead of having separate variables for a car’s speed and color, along with standalone functions to accelerate or brake, you can define a Car class that encapsulates these properties and behaviors:

1
class Car {
2
  Car(this.color, this.speed);
3

4
  String color;
5
  int speed;
6

7
  void accelerate() {
8
    speed += 10;
9
    print("The car is now going $speed mph.");
10
  }
11
}
12

13
void main() {
14
  Car myCar = Car("Red", 0);
15
  myCar.accelerate(); // The car is now going 10 mph.
16
}

Want to dive deeper into Dart, I think you will find this next article on working with Dart exceptions interesting.