Dart Cheat Sheet and Quick Reference
Source: raywenderlich.com
main() function
void main() {
print('Hello, Dart!');
}
Variables, Data Types, & Comments
// Use var with type inference or instead use type name directly
var myAge = 35; // inferred int created with var
var pi = 3.14; // inferred double created with var
int yourAge = 27; // type name instead of var
double e = 2.718; // type name instead of var
// This is a comment
print(myAge); // This is also a comment.
/*
And so is this.
*/
// dynamic can have value of any type
dynamic numberOfKittens;
// dynamic String
numberOfKittens = 'There are no kittens!';
numberOfKittens = 0; // dynamic int
numberOfKittens = 1.0; // dynamic double
bool areThereKittens = true; // bool
// Compile-time constants
const speedOfLight = 299792458;
// Immutables with final
final planet = 'Jupiter';
// planet = 'Mars'; // error: planet is immutable
// Enumerations
enum Month { january, february, march, april, may, june, july, august, september, october, november, december }
final month = Month.august;
Null
int age; // initialized to null
double height;
String err;
// Check for null
var error = err ?? "No error"; // No error
// Null-check compound assignment
err ??= error;
// Null-check on property access
print(age?.isEven);
Operators
// Arithmetic
40 + 2; // 42
44 - 2; // 42
21 * 2; // 42
84 / 2; // 42
84.5 ~/ 2.0; // int value 42
392 % 50; // 42
// Types can be implicitly converted
var answer = 84.0 / 2; // int 2 to double
// Equality and Inequality
42 == 43; // false
42 != 43; // true
// Increment and decrement
print(answer++); // 42, since it prints first for postfix
print(--answer); // 42, since it decrements first for prefix
// Comparison
42 < 43; // true
42 > 43; // false
42 <= 43; // true
42 >= 43; // false
// Compound assignment
answer += 1; // 43
answer -= 1; // 42
answer *= 2; // 84
answer /= 2; // 42
// Logical
(41 < answer) && (answer < 43); // true
(41 < answer) || (answer > 43); // true
!(41 < answer)); // false
Strings
// Can use single or double quotes for String type
var firstName = 'Albert';
String lastName = "Einstein";
// Escape sequences such as \' and \n
// and concatenating adjacent strings
var quote = 'If you can\'t' ' explain it simply\n'
"you don't understand it well enough.";
// Concatenation with +
var energy = "Mass" + " times " + "c squared";
// Preserving formatting with """
var model = """
I'm not creating the universe.
I'm creating a model of the universe,
which may or may not be true.""";
// Raw string with r prefix
var rawString =r”I'll\nbe\nback!"; // prints I’ll\nbe\nback!
Control Flow: Conditionals
var animal = 'fox';
if (animal == 'cat' || animal == 'dog') {
print('Animal is a house pet.');
} else if (animal == 'rhino') {
print('That\'s a big animal.');
} else {
print('Animal is NOT a house pet.');
}
// switch statement
enum Semester { fall, spring, summer }
Semester semester;
switch (month) {
case Month.august:
case Month.september:
case Month.october:
case Month.november:
case Month.december:
semester = Semester.fall;
break;
case Month.january:
case Month.february:
case Month.march:
case Month.april:
case Month.may:
semester = Semester.spring;
break;
case Month.june:
case Month.july:
semester = Semester.summer;
break;
}
Control Flow: While loops
var i = 1;
// while, print 1 to 9
while (i < 10) {
print(i);
i++;
}
// do while, print 1 to 9
i = 1;
do {
print(i);
++i;
}
while (i < 10);
// break at 5
do {
print(i);
if (i == 5) {
break;
}
++i;
} while (i < 10);
Control Flow: For loops
var sum = 0;
// Init; condition; action for loop
for (var i = 1; i <= 10; i++) {
sum += i;
}
// for-in loop for list
var numbers = [1, 2, 3, 4];
for (var number in numbers) {
print(number);
}
// Skip over 3 with continue
for (var number in numbers) {
if (number == 3) {
continue;
}
print(number);
}
// forEach with function argument
numbers.forEach(print); // 1, 2, 3, 4 on separate lines
// forEach with anonymous function argument
numbers = [13, 14, 15, 16];
numbers.forEach((number) => print(number.toRadixString(16)); // d, e, f, 10
Functions
// Named function
bool isBanana(String fruit) {
return fruit == 'banana';
}
var fruit = 'apple';
isBanana(fruit); // false
// Optional parameters with square brackets
String fullName(String first, String last, [String title]) {
return "${title == null ? "" : "$title "}$first
$last";
}
fullName("Ray", "Wenderlich"); // Ray Wenderlich
fullName("Albert", "Einstein", "Professor"); //Professor Albert Einstein
// Optional named arguments with braces
bool withinTolerance(int value, {int min, int max}) {
return (min ?? 0) <= value && value <= (max ??
10);
}
withinTolerance(11, max: 10, min: 1); // false
// Default values
bool withinTolerance(int value, {int min = 0, int max = 10}) {
return min <= value && value <= max;
}
withinTolerance(5); // true
// Function as parameter
int applyTo(int value, int Function(int) op) {
return op(value);
}
int square(int n) {
return n * n;
}
applyTo(3, square); // 9
// Arrow syntax for one line functions
int multiply(int a, int b) => a * b;
multiply(14, 3); // 42
Anonymous Functions and Closures
// Anonymous functions (without a name)
// Assign anonymous function to a variable
var multiply = (int a, int b) {
return a * b;
}
// Call a function variable
multiply(14, 3); // 42
// Closures
Function applyMultiplier(num multiplier){
// Return value has access to multiplier
return (num value) => value * multiplier;
}
var triple = applyMultiplier(3);
triple(14.0); // 42.0
Collections: Lists
// Fixed-size list
var pastries = List<String>(3);
// Element access by index
pastries[0] = 'cookies';
pastries[1] = 'cupcakes';
pastries[2] = 'donuts';
// Growable list
List<String> desserts = [];
desserts.add('cookies');
// Initialize by growable list
var desserts = ['cookies', 'cupcakes', 'pie'];
// List properties and methods
desserts.length; // 3
desserts.first; // 'cookies'
desserts.last; // 'pie'
desserts.isEmpty; // false
desserts.isNotEmpty; // true
desserts.firstWhere((str) => str.length < 4));// pie
// Collection if
var peanutAllergy = true;
var candy = ['junior mints', 'twizzlers', if (!peanutAllergy) 'reeses'];
// Collection for
var numbers = [1, 2, 3];
var doubledNumbers = [for (var number in numbers) 2 * number]; // [2, 4, 6]
Collections: List Operations
// Spread Operator and null-spread operator
var pastries = ['cookies', 'cupcakes'];
var desserts = ['donuts', ...pastries, ...?candy];
// Map to transform list
var numbers = [1, 2, 3, 4];
var squares = numbers.map((number) => number * number).toList(); // [1, 4, 9, 16]
// Filter list using where
var evens = squares.where((square) => square.isEven); // (4, 16)
// Reduce list to combined value
var amounts = [199, 299, 299, 199, 499];
var total = amounts.reduce((value, element) => value + element); // 1495
Collections: Sets
// Create set of int
var someSet = <int>{};
// Set type inference
var anotherSet = {1, 2, 3, 1};
// Check for element
anotherSet.contains(1); // true
anotherSet.contains(99); // false
// Adding and removing elements
someSet.add(42);
someSet.add(2112);
someSet.remove(2112);
// Add to set from list
someSet.addAll([1, 2, 3, 4]);
// Intersection
var intersection = someSet.intersection(anotherSet);
// Union
var union = someSet.union(anotherSet);
Collections: Maps
// Map from String to int
var emptyMap = Map<String, int>();
// Map from String to String
var avengers = {"Iron Man": "Suit", "Captain America": "Shield", "Thor": "Hammer"};
// Element access by key
var ironManPower = avengers["Iron Man"]; // Suit
avengers.containsKey("Captain America"); // true
avengers.containsValue("Arrows"); // false
// Access all keys and values
avengers.keys.forEach(print); // Iron Man, Captain America, Thor
avengers.values.forEach(print); // Suit, Shield, Hammer
// Loop over key-value pairs
avengers.forEach((key, value) => print('$key -> $value'));
Classes and Objects
class Actor {
// Properties
String name;
var filmography = <String>[];
// Short-form constructor
Actor(this.name, this.filmography);
// Named constructor
Actor.rey({this.name = "Daisy Ridley"}) {
filmography = ['The Force Awakens', 'Murder on the Orient Express'];
}
// Calling other constructors
Actor.inTraining(String name) : this(name, []);
// Constructor with initializer list
Actor.gameOfThrones(String name): this.name = name, this.filmography = ['Game of Thrones'] {
print('My name is ${this.name}');
}
// Getters and Setters
String get debut => '$name debuted in ${filmography.first}';
set debut(String value) => filmography.insert(0, value);
// Methods
void signOnForSequel(String franchiseName) {
filmography.add('Upcoming $franchiseNamesequel');
}
// Override from Object
String toString() => "${[name, ...filmography].join("\n- ")}\n";
}
var gotgStar = Actor('Zoe Saldana', []);
gotgStar.name = 'Zoe Saldana';
gotgStar.filmography.add('Guardians of the Galaxy');
gotgStar.debut = 'Center Stage';
print(Actor.rey().debut); // The Force Awakens
var kit = Actor.gameOfThrones('Kit Harington');
var star = Actor.inTraining('Super Star');
// Cascade syntax ..
gotgStar // Get an object
..name = 'Zoe' // Use property
..signOnForSequel('Star Trek'); // Call method
Static Class Members
enum PhysicistType { theoretical, experimental, both
}
class Physicist {
String name;
PhysicistType type;
// Internal constructor
Physicist._internal(this.name, this.type);
// Static property
static var physicistCount = 0;
// Static method
static Physicist newPhysicist(
String name,
PhysicistType type) {
physicistCount++;
return Physicist._internal(name, type);
}
}
final emmy = Physicist.newPhysicist(
"Emmy Noether", PhysicistType.theoretical);
final lise = Physicist.newPhysicist(
"Lise Meitner", PhysicistType.experimental);
print(Physicist.physicistCount); //2
Class Inheritance
// Base aka parent class
class Person {
// Parent properties inherited by child
String firstName;
String lastName;
// Parent class constructor
Person(this.firstName, this.lastName);
// Parent class method
String get fullName => '$firstName $lastName';
// Optional @override annotation
// All class hierarchies and types have Object as root class
@override
String toString() => fullName;
}
// Subclass aka child class
class Student extends Person {
// Properties specific to child
var grades = <String>[];
// Call super on parent constructor
Student(String firstName, String lastName): super(firstName, lastName);
// Optional override annotation on parent method override
@override
String get fullName => '$lastName, $firstName';
}
final jon = Person('Jon', 'Snow');
final jane = Student('Jane', 'Snow'); // Calls parent constructor
print(jon); // Jon Snow
// Use toString in parent, in turn using subclass override of fullName
print(jane); // Snow, Jane
Abstract Classes, Interfaces, Mixins
enum BloodType { warm, cold }
abstract class Animal {
BloodType bloodType; // Base class property
void goSwimming(); // Abstract method without implementation
}
mixin Milk {
bool hasMilk;
bool doIHaveMilk() => hasMilk;
}
// Concrete class inheriting from abstract class
class Cat extends Animal with Milk {
BloodType bloodType = BloodType.warm; // Set value for property
Cat() { hasMilk = true; } // Set mixin property
// Concrete subclass must implement abstract methods
@override
void goSwimming() { print("No thanks!"); }
}
// Concrete class that also implements Comparable interface
class Dolphin extends Animal implements
Comparable<Dolphin> {
BloodType bloodType = BloodType.warm;
double length; // Concrete sublcass property
Dolphin(this.length); // Concrete subclass constructor
// Concrete subclass must implement abstract methods
@override
void goSwimming() { print("Click! Click!"); }
// Also must implement interface methods
@override
int compareTo(other) =>
length.compareTo(other.length);
@override
String toString() => '$length meters';
}
class Reptile extends Animal with Milk {
BloodType bloodType = BloodType.cold;
Reptile() { hasMilk = false; }
@override
void goSwimming() { print("Sure!"); }
}
// var snake = Animal(); // error: can't instantiate abstract class
// Can instantiate concrete classes
var garfield = Cat();
var flipper = Dolphin(4.0);
var snake = Reptile();
// Call concrete methods
flipper.goSwimming(); // Click! Click!
garfield.goSwimming(); // No thanks!
// Use interface implementation
var orca = Dolphin(8.0); var alpha = Dolphin(5.0);
var dolphins = [alpha, orca, flipper];
dolphins.sort();
print(dolphins); // [4 meters, 5 meters, 8 meters]
print(snake.doIHaveMilk()); // false
print(garfield.doIHaveMilk()); // true
