Dart Static Typing

Master Dart with Coddy

Learn Dart through interactive, bite-sized lessons. Build Flutter apps and master modern development.

Dart is a statically typed language, which means variable types are known at compile-time. This feature enhances code reliability and performance. Let's explore static typing in Dart and its advantages.

What is Static Typing?

Static typing requires developers to declare variable types explicitly. The Dart compiler checks these types before runtime, catching potential errors early in the development process.

Benefits of Static Typing

Early error detection
Improved code readability
Better performance
Enhanced IDE support

Declaring Types in Dart

In Dart, you can declare types for variables, function parameters, and return values. Here's a simple example:


String greeting = 'Hello, Dart!';
int age = 25;
double pi = 3.14159;

void printInfo(String name, int year) {
    print('$name was born in $year');
}

bool isEven(int number) {
    return number % 2 == 0;
}

Type Inference

Dart also supports type inference, allowing you to omit type annotations when the compiler can determine the type:


var message = 'Hello'; // Inferred as String
var count = 42; // Inferred as int
var items = ['apple', 'banana', 'orange']; // Inferred as List<String>

Generics and Static Typing

Dart's static typing system includes support for generics, allowing you to create type-safe collections and classes:


List<int> numbers = [1, 2, 3, 4, 5];
Map<String, double> prices = {'apple': 0.99, 'banana': 0.59};

class Box<T> {
    T value;
    Box(this.value);
}

Box<String> stringBox = Box('Hello');
Box<int> intBox = Box(42);

Null Safety

Dart's static typing system includes null safety, which helps prevent null reference errors:


String? nullableString = null; // Can be null
String nonNullableString = 'This cannot be null';

int? nullableInt;
int nonNullableInt = nullableInt ?? 0; // Provide a default value

Best Practices

Use explicit types for public APIs to improve readability
Leverage type inference for local variables when types are obvious
Utilize generics for type-safe collections and classes
Enable and use null safety to prevent null reference errors
Use the Dart analyzer to catch type-related issues early

By mastering static typing in Dart, you'll write more robust and maintainable code. It's a powerful feature that, when used effectively, can significantly improve your Dart programming experience.