Dart for Beginners: The Language Behind Flutter

Dart is a statically typed, object-oriented language built by Google, and it powers every Flutter app. You write one codebase and compile it to Android, iOS, web, and desktop. If you know JavaScript, Java, C#, or Kotlin, the syntax will look familiar within an hour. This guide covers the core language with isolated, runnable examples.

Quick Takeaways

• Dart is sound-null-safe, so a String can never be null unless you declare String?.
• Use final for runtime constants and const for compile-time constants. Avoid dynamic.
• Future, async, and await handle asynchronous work. Stream handles sequences of async values.
• Dart 3 added records, pattern matching, and sealed classes. These features make Flutter state code far safer.

What Is Dart, and Why Does Flutter Use It?

Dart compiles in two ways, and that is why Flutter feels fast in both development and production.

Here is how Dart compares with the languages beginners usually know.

Setting Up and Writing Your First Program

Install the Dart SDK (it also ships inside Flutter), then run files with dart run.

// hello.dart
void main() {
  const language = 'Dart';
  print('Hello, $language!');
}

Run it with dart run hello.dart. The output is Hello, Dart!. Every program starts at main(). The $language syntax is string interpolation. Use ${expression} when you need more than a bare variable name.

Variables, Types, and Constants

Dart infers types, so you rarely write them out. Keep the distinction between var, final, and const clear from day one.

void main() {
  var count = 3;                      // inferred as int
  String name = 'Ada';                // explicit type
  double price = 9.99;
  bool isActive = true;
  final createdAt = DateTime.now();   // set once, at runtime
  const maxRetries = 5;               // fixed at compile time

  count = 4;                          // allowed: var is mutable
  // maxRetries = 6;                  // compile error: const is immutable

  print('$name has $count items at ${price * 2} total');
}

The program prints Ada has 4 items at 19.98 total. The built-in numeric types are int and double. Both extend num.

Null Safety: The Feature That Prevents Most Crashes

By default, no type accepts null. Add a ? to opt in.

void greet(String? nickname) {
  // ?. short-circuits on null; ?? supplies a fallback
  print(nickname?.toUpperCase() ?? 'ANONYMOUS');

  // Type promotion: inside the check, nickname is a non-null String
  if (nickname != null) {
    print(nickname.length);
  }
}

void main() {
  greet(null);
  greet('Zed');
}

The first call prints ANONYMOUS. The second prints ZED and then 3. The compiler promotes a local variable to its non-null type after a null check. Promotion does not work on top-level or mutable instance fields, because another piece of code could change them between the check and the use. Copy the field into a local variable first.

Use the late modifier only when you can guarantee initialization before first read. A wrong late turns a compile-time error into a runtime LateInitializationError.

Functions: Positional, Named, and Arrow Syntax

Flutter widgets lean heavily on named parameters, so learn them early.

// Named parameters; 'required' forces the caller to pass width
double area({required double width, double height = 1}) => width * height;

void main() {
  print(area(width: 4, height: 2.5)); // 10.0
  print(area(width: 3));              // 3.0
}

The => form is arrow syntax, shorthand for a single-expression body with an implicit return. Functions are first-class objects, so you can pass them as arguments and store them in variables.

Collections: List, Set, and Map

void main() {
  final scores = <int>[90, 72, 85];
  final tags = <String>{'dart', 'flutter', 'dart'}; // Set removes duplicates
  final user = <String, Object>{'name': 'Ada', 'age': 36};

  // Chain .where() and .map(), then materialize with .toList()
  final boosted = scores.where((s) => s >= 80).map((s) => s + 5).toList();
  print(boosted);       // [95, 90]
  print(tags);          // {dart, flutter}
  print(user['name']);  // Ada

  // Collection if/for build lists declaratively
  final isAdmin = true;
  final menu = [
    'Home',
    if (isAdmin) 'Admin',
    for (final t in tags) t.toUpperCase(),
  ];
  print(menu);          // [Home, Admin, DART, FLUTTER]
}

Collection if and collection for appear constantly in Flutter’s children: [...] lists. Methods like .where() and .map() return lazy Iterable objects, so call .toList() when you need a real list.

Classes, Constructors, and Encapsulation

Dart has no private keyword. A leading underscore makes a member library-private.

class Account {
  final String owner;
  double _balance; // library-private field

  // Initializing formals: 'this.owner' assigns the field directly
  Account(this.owner, [this._balance = 0]);

  // Named constructor that redirects to the main one
  Account.empty(String owner) : this(owner, 0);

  double get balance => _balance; // getter

  void deposit(double amount) {
    if (amount <= 0) {
      throw ArgumentError.value(amount, 'amount', 'must be positive');
    }
    _balance += amount;
  }
}

void main() {
  final account = Account('Ada');
  account.deposit(50);
  print(account.balance); // 50.0
}

The constructor shorthand removes the boilerplate common in Java. Square brackets mark an optional positional parameter. Dart also supports inheritance with extends, interfaces through implements, and code reuse through mixins declared with mixin and applied with with.

Dart 3 Features: Records, Patterns, and Sealed Classes

Dart 3 made the type system much more expressive.

Records

A record returns multiple values without a custom class.

(String, int) parse(String raw) {
  final parts = raw.split(':');
  return (parts[0], int.parse(parts[1]));
}

void main() {
  final (name, age) = parse('Ada:36'); // destructuring
  print('$name is $age'); // Ada is 36
}

Sealed Classes and Exhaustive Switch

A sealed class lets the compiler know every possible subtype. A switch expression over it must cover all cases, or the code will not compile.

sealed class Shape {}

class Circle extends Shape {
  final double r;
  Circle(this.r);
}

class Rect extends Shape {
  final double w, h;
  Rect(this.w, this.h);
}

double area(Shape s) => switch (s) {
      Circle(:final r) => 3.14159 * r * r,
      Rect(:final w, :final h) => w * h,
    };

void main() {
  print(area(Rect(3, 4))); // 12.0
}

If you add a Triangle subclass later, every switch that misses it fails at compile time. This pattern models loading, success, and error states in Flutter apps cleanly.

Asynchronous Dart: Future, async/await, and Stream

Dart runs your code on a single-threaded event loop. Waiting on a network call does not block the UI because the call returns a Future.

Future<String> fetchUser(int id) async {
  await Future.delayed(const Duration(milliseconds: 200)); // simulate I/O
  if (id < 0) throw ArgumentError('id must be >= 0');
  return 'user-$id';
}

Stream<int> countdown(int from) async* {
  for (var i = from; i > 0; i--) {
    await Future.delayed(const Duration(milliseconds: 100));
    yield i; // emit a value to the stream
  }
}

void main() async {
  try {
    print(await fetchUser(7));  // user-7
    await fetchUser(-1);        // throws
  } on ArgumentError catch (e) {
    print('Error: ${e.message}'); // Error: id must be >= 0
  }

  await for (final n in countdown(3)) {
    print(n); // 3, 2, 1
  }
}

A Future delivers one value later. A Stream delivers many. Use try/catch around await exactly as you would around synchronous code. For CPU-heavy work, such as parsing a large JSON file, use an Isolate (Isolate.run()). Isolates have separate memory and do not share state.

How Dart Connects to Flutter

Every Flutter widget is a Dart class. This example uses everything above: a const constructor, a named parameter, a final field, and string interpolation.

import 'package:flutter/material.dart';

class Greeting extends StatelessWidget {
  const Greeting({super.key, required this.name});

  final String name;

  @override
  Widget build(BuildContext context) => Text('Hello, $name');
}

The const constructor lets Flutter skip rebuilding identical widget instances. The super.key syntax forwards the key parameter to the parent class.

Best Practices: Anti-Patterns vs. Clean Code

Bad Code

// Anti-patterns: dynamic typing, force-unwraps, manual concatenation, index loops
dynamic data = fetch();
String name = data['name'];
var message = 'Hello ' + name + ', you are ' + age.toString();

var result = [];
for (int i = 0; i < items.length; i++) {
  if (items[i].active) {
    result.add(items[i].name);
  }
}

String city = user!.address!.city!;

Good Code

// Typed model, interpolation, declarative collection ops, null-aware access
class Item {
  const Item({required this.name, required this.active});
  final String name;
  final bool active;
}

final message = 'Hello $name, you are $age';

final result = items
    .where((item) => item.active)
    .map((item) => item.name)
    .toList();

final city = user?.address?.city ?? 'Unknown';

The refactored version has four advantages:

• A typed Item class catches field typos at compile time. dynamic defers them to runtime.
• Interpolation removes the repeated + and the manual .toString().
• .where().map().toList() states intent without index bookkeeping.
• ?. and ?? replace the chain of ! operators, which throw if any link is null.

Common Edge Cases for Beginners

• Integer division: 7 / 2 returns 3.5 (a double). Use 7 ~/ 2 for integer division, which gives 3.
• Missing await: Calling an async function without await gives you a Future, not the value. The analyzer lint unawaited_futures flags this.
• List mutability: A const [1, 2] list throws UnsupportedError on .add(). Use final with a normal list literal when you need to modify it.
• Equality: == compares object identity by default. Override == and hashCode, or use a package such as equatable, for value equality.
• Strings are immutable: Building a string in a loop with += is O(n²). Use a StringBuffer instead.

FAQ

Is Dart only used for Flutter?

No. Dart also builds command-line tools, backend servers (with frameworks like Shelf), and web apps. Flutter is its largest use case, but the language runs independently of it.

Is Dart hard to learn for beginners?

No. Dart’s syntax resembles Java, C#, and JavaScript, and its strict typing and null safety catch many mistakes before you run the code. Most beginners write useful programs within a week.

Do I need to learn Dart before Flutter?

You need the basics: variables, functions, classes, collections, null safety, and async/await. Learn these first, then start Flutter. You will pick up the rest while building widgets.

What is the difference between Dart and JavaScript?

Dart is statically typed with sound null safety and compiles to native code. JavaScript is dynamically typed and runs through an interpreter or JIT in the browser. Dart also compiles to JavaScript or WebAssembly for web targets.