Dart Basics: Variables, Types, Null Safety, and Control Flow

Variables and Types in Dart

Coming from JavaScript and TypeScript, Dart's approach to variables and types will feel quite natural. Dart is a strongly typed language, but like TypeScript, it has excellent type inference, which keeps the code concise.

Let's start with variable declaration. You can declare a variable using the var keyword. Dart will infer its type from the initialized value.

// Dart infers the type of 'greeting' to be a String.
var greeting = 'Hello, Dart!';

// Reassigning to a different type will cause an error.
// greeting = 123; // Error: A value of type 'int' can't be assigned to a variable of type 'String'.

If you don't initialize a variable upon declaration, you should provide an explicit type. If you omit the type, it defaults to dynamic, which is similar to TypeScript's any type and should be used sparingly.

// Explicitly typed variable.
int year;
year = 2024;

// This variable is of type 'dynamic' and can hold any value.
dynamic anything;
anything = 'a string';
anything = 42; // This is allowed.

Immutability with final and const

You'll frequently use final and const to declare variables that don't change.

• final: Use this when you want a variable to be assigned only once. It's analogous to const in JavaScript. A final variable's value is determined at runtime.
• const: Use this for values that are known at compile time. This is a stronger form of immutability than final. A const variable must be initialized with a compile-time constant value.

final String name = 'Alice';
// name = 'Bob'; // Error: The final variable 'name' can only be set once.

const double pi = 3.14159;
// pi = 3.14; // Error: Constant variables can't be assigned a value.

The article "Learning Dart as a JavaScript developer" provides a good comparison of these concepts with their JavaScript counterparts.

Basic Data Types

Dart comes with a core set of built-in types. For now, we'll focus on the most common ones. The video below gives a great visual overview of declaring variables and using these types.

To summarize the types from the video:

• Numbers: Dart has two main numeric types:
  • int: For integer values (e.g., 10, -5).
  • double: For floating-point numbers (e.g., 3.14, -0.5).
    Both are subtypes of a class called num.
• Strings: The String type represents a sequence of UTF-16 code units. You can use single (') or double (") quotes. String interpolation is done with $variable or ${expression}.
• Booleans: The bool type has two possible values: true and false. Unlike JavaScript's "truthy" and "falsy" values, Dart conditions strictly require a bool.
• dynamic: As mentioned, this is a special type that tells the type checker to allow any type. It's similar in spirit to TypeScript's any.

Understanding Sound Null Safety

One of Dart's most important features is its sound null safety. This system prevents a whole class of errors commonly known as "null pointer exceptions" or "null reference errors." Since you have experience with TypeScript's strict null checks, the core ideas should be very intuitive.

The fundamental principle is: types are non-nullable by default. A variable of type String can never hold a null value. This is enforced at compile time.

If you need a variable to be able to hold null, you must explicitly declare it as nullable by adding a question mark (?) to the type.

String nonNullableName = 'Jane';
// nonNullableName = null; // Error: A value of type 'Null' can't be assigned to a variable of type 'String'.

String? nullableName = 'John';
nullableName = null; // This is allowed.

A nullable type like String? is a union of the String type and the Null type.

The following video provides an excellent conceptual overview of why null safety is important and how it works in Dart.

Working with Nullable Types

Since you can't call methods on null (e.g., null.toUpperCase()), Dart requires you to handle the possibility of null before you can use a nullable variable. There are several ways to do this.

1. Flow Analysis (Type Promotion)
The Dart analyzer is smart. If you perform a null check, it will "promote" the variable's type to its non-nullable version within that code branch.

void printNameLength(String? name) {
  if (name != null) {
    // Inside this block, Dart knows 'name' is not null.
    // It's treated as a non-nullable 'String'.
    print(name.length);
  } else {
    print('No name provided.');
  }
}

2. Null-aware Operators
These operators provide a more concise way to handle nullability and will be very familiar from modern JavaScript.

• ?. (Null-aware access): If the object is not null, access the property. Otherwise, the expression evaluates to null.

  String? name;
  int? length = name?.length; // length is null because name is null.
  

• ?? (If-null operator): If the expression on the left is null, use the value on the right.

t String? name;
String guestName = name ?? 'Guest'; // guestName is 'Guest'.
```

• ! (Null assertion operator): If you are certain that a nullable expression is not null, you can use the ! operator to tell Dart to treat it as non-nullable. This is like a type cast and will throw an error at runtime if the expression is indeed null. Use it with caution.

  String? name = 'Bob';
  int length = name!.length; // You are asserting name is not null.
  

3. The late Keyword
Sometimes you have a non-nullable variable that can't be initialized immediately when it's declared, but you guarantee it will be assigned a value before it's used. In such cases, you can use the late keyword.

class MyClass {
  late String description;

  void fetchData() {
    // Simulates fetching data and then initializing the variable.
    description = 'Data has been fetched!';
  }
}

This avoids making description nullable (String?) when you know it will eventually have a value.

Control Flow

Dart's control flow statements are very similar to what you know from C++ and JavaScript.

• if-else: Works as expected, but remember, the condition must be a bool.
• for loops: The standard for (var i = 0; i < 5; i++) loop is available. Dart also has a for-in loop, which behaves like JavaScript's for-of loop for iterating over the elements of a collection.
• while and do-while: Standard pre-test and post-test loops.
• break and continue: Work inside loops as expected.
• switch: Dart switch statements can be used with integers, strings, and compile-time constants. A key difference from JavaScript is that there is no implicit fall-through. A non-empty case must end with break, return, throw, or continue.

Practice: The FizzBuzz Challenge

To put your knowledge of variables, control flow, and operators to the test, try implementing the classic "FizzBuzz" problem in a Dart file.

The Challenge:
Write a program that prints the numbers from 1 to 100. But for multiples of three, print "Fizz" instead of the number, and for the multiples of five, print "Buzz". For numbers which are multiples of both three and five, print "FizzBuzz".

You will need:

• A for loop to iterate from 1 to 100.
• if, else if, and else statements to check the conditions.
• The modulo operator (%) to check for multiples (e.g., number % 3 == 0).

Give it a try! This simple exercise is a great way to solidify your understanding of the fundamentals.

Conclusion

In this lesson, we've covered the foundational syntax of the Dart language. You've learned about:

• Declaring variables with var, final, and const, and the core data types like int, double, String, and bool.
• Dart's sound null safety, which helps you write more robust code by default, and the tools (?, !, ??) to manage nullability when needed.
• Standard control flow statements like if, for, and switch, noting some key differences from JavaScript.

You now have the basic building blocks to start writing logic in Dart.

In our next lesson, we will move on to one of the most powerful features of Dart: classes. We'll explore how to define classes and constructors, and how to use inheritance and mixins for code reuse. This will draw heavily on your existing knowledge of object-oriented programming from C++ and JavaScript.