Dart Cheatsheet

Language Overview

Dart is a client-optimized programming language developed by Google, designed for building mobile, web, desktop, and server applications. Key features include:

Strong typing with sound null safety
Object-oriented and class-based
Supports both ahead-of-time (AOT) and just-in-time (JIT) compilation
Primary language for Flutter cross-platform development
Supports functional and reactive programming paradigms

Basic Syntax

Hello World

dart

1
2
3
4
void main() {
  print('Hello, Dart!');
}

Comments

dart

1
2
3
4
5
6
7
// Single-line comment

/* Multi-line
   comment */

/// Documentation comment

Data Types

Primitive Types

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// Integer
int age = 30;

// Double
double height = 1.75;

// String
String name = 'John Doe';

// Boolean
bool isActive = true;

// Dynamic (avoid when possible)
dynamic variable = 42;

// Null safety
String? nullableString; // Can be null
String nonNullableString = 'Hello'; // Cannot be null

Null Safety

dart

1
2
3
4
5
6
7
8
// Late initialization
late String description; // Will be initialized before use

// Null-aware operators
String? name = null;
print(name?.length); // Safely access nullable property
print(name ?? 'Unknown'); // Provide default value

Collection Types

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
// List
List<int> numbers = [1, 2, 3, 4, 5];
List<String> fruits = ['apple', 'banana', 'cherry'];

// Set
Set<String> uniqueColors = {'red', 'green', 'blue'};

// Map
Map<String, int> ages = {
  'Alice': 30,
  'Bob': 25,
  'Charlie': 35
};

// Spread operator
List<int> list1 = [1, 2, 3];
List<int> list2 = [4, 5, 6];
List<int> combinedList = [...list1, ...list2];

Variables and Constants

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
// Variables
var dynamicVar = 42; // Type inferred
int explicitInt = 10;

// Final (runtime constant)
final String name = 'John';

// Const (compile-time constant)
const double pi = 3.14159;

// Late variables
late String expensiveComputation;

Operators

Arithmetic Operators

dart

1
2
3
4
5
6
7
8
int a = 10, b = 5;
print(a + b);   // Addition
print(a - b);   // Subtraction
print(a * b);   // Multiplication
print(a / b);   // Division
print(a % b);   // Modulo
print(a ~/ b);  // Integer division

Comparison Operators

dart

1
2
3
4
5
6
7
print(a == b);  // Equal
print(a != b);  // Not equal
print(a > b);   // Greater than
print(a < b);   // Less than
print(a >= b);  // Greater than or equal
print(a <= b);  // Less than or equal

Logical Operators

dart

1
2
3
4
5
bool x = true, y = false;
print(!x);      // Logical NOT
print(x && y);  // Logical AND
print(x || y);  // Logical OR

Control Structures

Conditional Statements

dart

1
2
3
4
5
6
7
8
9
10
11
12
// If-else
if (condition) {
  // Code
} else if (anotherCondition) {
  // Alternative code
} else {
  // Default code
}

// Ternary operator
var result = condition ? trueValue : falseValue;

Loops

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
// For loop
for (int i = 0; i < 5; i++) {
  print(i);
}

// For-in loop
List<String> fruits = ['apple', 'banana', 'cherry'];
for (var fruit in fruits) {
  print(fruit);
}

// While loop
int counter = 0;
while (counter < 5) {
  print(counter);
  counter++;
}

// Do-while loop
do {
  print(counter);
  counter++;
} while (counter < 10);

// Break and continue
for (int i = 0; i < 10; i++) {
  if (i == 5) break;     // Exit loop
  if (i % 2 == 0) continue; // Skip even numbers
  print(i);
}

Functions

Basic Functions

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
// Function declaration
int add(int a, int b) {
  return a + b;
}

// Optional parameters
void greet(String name, {int? age}) {
  print('Hello $name, ${age != null ? "you are $age" : ""}');
}

// Named parameters
void printUser({required String name, int age = 0}) {
  print('Name: $name, Age: $age');
}

// Arrow function syntax
int multiply(int a, int b) => a * b;

Anonymous Functions (Closures)

dart

1
2
3
4
5
var numbers = [1, 2, 3, 4];
numbers.forEach((number) {
  print(number * 2);
});

Async Programming

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
// Async function
Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 2));
  return 'Data fetched';
}

// Async with error handling
Future<void> asyncExample() async {
  try {
    String result = await fetchData();
    print(result);
  } catch (e) {
    print('Error: $e');
  }
}

Object-Oriented Programming

Classes and Objects

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
class Person {
  // Instance variables
  String name;
  int age;

  // Constructor
  Person(this.name, this.age);

  // Named constructor
  Person.fromJson(Map<String, dynamic> json)
      : name = json['name'],
        age = json['age'];

  // Method
  void introduce() {
    print('Hi, I\'m $name and I\'m $age years old');
  }
}

// Usage
var person = Person('Alice', 30);
person.introduce();

Inheritance

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
class Employee extends Person {
  String position;

  Employee(String name, int age, this.position)
      : super(name, age);

  @override
  void introduce() {
    super.introduce();
    print('My position is $position');
  }
}

Mixins

dart

1
2
3
4
5
6
7
8
mixin Swimmer {
  void swim() {
    print('Swimming');
  }
}

class Fish extends Animal with Swimmer {}

Error Handling

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
try {
  // Risky code
  int result = 10 ~/ 0; // Throws IntegerDivisionByZeroException
} on IntegerDivisionByZeroException {
  print('Cannot divide by zero');
} catch (e) {
  print('Unexpected error: $e');
} finally {
  print('Always executed');
}

// Custom exceptions
class CustomException implements Exception {
  String message;
  CustomException(this.message);
}

File I/O

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
import 'dart:io';

// Reading a file
Future<void> readFile() async {
  File file = File('example.txt');
  String contents = await file.readAsString();
  print(contents);
}

// Writing to a file
Future<void> writeFile() async {
  File file = File('output.txt');
  await file.writeAsString('Hello, File!');
}

Concurrency with Isolates

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
import 'dart:isolate';

void heavyComputation(SendPort sendPort) {
  // Perform complex computation
  int result = 42;
  sendPort.send(result);
}

Future<void> runIsolate() async {
  final receivePort = ReceivePort();
  await Isolate.spawn(heavyComputation, receivePort.sendPort);
  
  final result = await receivePort.first;
  print('Result from isolate: $result');
}

Pub Package Management

Bash

1
2
3
4
5
6
7
8
9
# Install a package
dart pub add http

# Upgrade packages
dart pub upgrade

# Run a package
dart pub run package_name

Common Libraries and Frameworks

Standard Libraries

dart:core: Core functionality
dart:async: Asynchronous programming
dart:io: File and system operations
dart:math: Mathematical functions

Popular Third-Party Packages

http: HTTP requests
provider: State management
dio: Advanced HTTP networking
bloc: State management
json_serializable: JSON serialization

Flutter Specific

dart

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
// Basic Flutter Widget
import 'package:flutter/material.dart';

class MyApp extends StatelessWidget {
  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      home: Scaffold(
        appBar: AppBar(title: Text('My App')),
        body: Center(child: Text('Hello, Flutter!')),
      ),
    );
  }
}

Best Practices

Code Style

Use meaningful variable and function names
Follow dart_style guidelines
Use dartfmt for consistent formatting

Performance Tips

Use const constructors when possible
Minimize widget rebuilds
Use final for variables that won't change
Leverage lazy loading and caching

Development Productivity

Use hot reload in Flutter
Utilize code generation tools
Implement proper error handling
Write unit and widget tests

Testing

dart

1
2
3
4
5
6
7
8
import 'package:test/test.dart';

void main() {
  test('Addition test', () {
    expect(1 + 1, equals(2));
  });
}

Dart

Continue Learning