• used to make multi-platform applications
• statically typed language
• Java + JS = Dart

Learn about the available commands and how to use them.

dart --help

Create a new project.

dart create -t console-simple my_app

# OR use the current directory (if it's empty)

dart create -t console-simple . --force

Run the application

dart run

Compile dart code to executable

dart compile exe bin/dart.dart
bin/dart.exe

Compile your code to JavaScript and run it with Node.js.

dart compile js bin/dart.dart
node out.js

We add packages from pub.dev to pubspec.yaml file

Source code is available inside bin directory

Declare a variable by putting the data type in front of the variable name.

int num1 = 2;
double num2 = 3.0;
bool isTrue = true;
String str = 'Hello';

You can check the runtime type of a variable using the is keyword, or via its runtimeType property.

(num1 + num2) is int
(num1 + num2).runtimeType

The var keyword is like saying I don’t care to annotate the variable with a type. If you don’t specify a value, it will be automatically inferred as dynamic (try to avoid this).

var username; // dynamic
var username = 'trishan'; // String

The final keyword is used to declare a variable that cannot be reassigned. It’s a good practice to use final whenever possible.

final String fullname = 'Trishan';
fullname = 'Trishan' // error;

The const keys is almost identical to final, but it creates an immutable compile-time constant. It may improve app performance, but can only be used for values known at compile time.

const int age = 75;
const int favNumber = num1 + 5; // error

Null safety is a feature added to Dart 2.0. It means variables can no longer be assigned null by default. This reduces the risk of runtime bugs and general makes our code more concise because “null checking” is no longer necessary.

Variables cannot be null by default. Attempting to assign a null value will result in a compile-time error.

int age = 75; // non-nullable
int age = null; // error

In some cases, it is useful to allow a variable to be null, which is achieved by adding question mark to the end of the variable’s type.

int? age; // nullable

Another possible situation is that you want to assign a nullable value TO a non-nullable variable. Dart will not allow this by default, but you can use the assertion operator ! to force the compiler to think the value it is non-null.

String? answer;

String result = answer; // error

String result = answer!; // works

In many cases, we can’t set the value of a variable during initialization, BUT we know that it WILL be assigned at runtime. This is known as late variable initialization and can be achieved by adding an late keyword to the variable’s declaration. This is also known as a “lazy” variable and should only be used when absolutely necessary.

class Animal {
  late final String _size;

  void goBig() {
    _size = 'big';
    print(_size);
  }
}

String color = 'blue';

if (color == 'blue') {
//
} else if (color == 'green') {
//
} else {
// default
}

// One liner
if (color == 'red') print('hello red!');

// For Loop
for (var i = 0; i < 5; i++) {
    print(i);
    // break;
    // continue;
}

// For In Loop
List<int> numbers = [1, 2, 3, 4, 5];
for (int number in numbers.where((n) => n > 1)) {
    print(number.isEven ? "Even" : "Odd");
}

// While Loop
int i = 0;
while (i < 5) {
    print(i);
    i++;
}

// Do-While Loop
i = 0;
do {
    print(i);
} while (i < 5);

// Assert
var txt = 'good';
assert(txt != 'bad');

Use the assignment operator to assign a value to a variable, ONLY if it’s not already assigned.

String? name;
name ??= 'Guest';
var z = name ?? 'Guest';

Use the cascade operator to call methods on an object without having to create a new line of code. It can often eliminate the need to create a temporary variable, which is especially useful in with working in Flutter’s widget tree.

// var paint = Paint();
// paint.color = 'black';
// paint.strokeCap = 'round';
// paint.strokeWidth = 5.0;

var paint = Paint()
    ..color = 'black'
    ..strokeCap = 'round'
    ..strokeWidth = 5.0;q

In rare cases, you may need to cast a value to a different type.

var number = 23 as String;
number is String; // true

Function with positional parameters:

// Basic Function
String takeFive(int number) {
return '$number minus five equals ${number - 5}';
}

Function with named parameters:

// Named parameters
namedParams({required int a, int b = 5}) {
return a - b;
}

namedParams(a: 23, b: 10);

Arrow functions are useful when passing functions as parameters to other functions.

// Arrow Function
String takeFive(int number) => '$number minus five equals ${number - 5}';

Many APIs in Dart use callback functions, often to handle events or gestures in Flutter.

// First-class functions
callIt(Function callback) {
    var result = callback();

    return 'Result: $result';
}

callIt(() => "Hello World");

  Map<String, dynamic> book = {
    'title': 'Moby Dick',
    'author': 'Herman Melville',
    'pages': 752,
  };

  book['title'];
  book['published'] = 1851;

  book.keys;
  book.values;
  book.values.toList();

  for (MapEntry b in book.entries) {
    print('Key ${b.key}, Value ${b.value}');
  }

  book.forEach((k, v) => print("Key : $k, Value : $v"));

Classes are a way to group data and behavior together, like a blueprint for an Object.

class Basic {
  int id;

  Basic(this.id);

  doStuff() {
    print('Hello my ID is $id');
  }
}

Use the class to instantiate an Object. The new keyword is optional.

Basic thing = new Basic(55);
thing.id;
thing.doStuff();

You can call static methods on the class itself without creating a new object.

class Basic {

  static globalData = 'global';
  static helper() {
      print('helper');
  }
}

Basic.globalData;
Basic.helper();

The this keyword is used to refer to the current instance of a class and is optional unless there is a name collision.

class Rectangle {
  final int width;
  final int height;
  String? name;
  late final int area;

  Rectangle(this.width, this.height, [this.name]) {
    area = width * height;
  }
}

In Flutter, all widgets used named parameters.

class Circle {
  const Circle({required int radius, String? name});
}

const cir = Circle(radius: 50, name: 'foo');

It is also possible for a class to have multiple named constructors. This is useful when different datatypes can be used to initialize the same class.

class Point {
  double lat = 0;
  double lng = 0;

  // Named constructor
  Point.fromMap(Map data) {
    lat = data['lat'];
    lng = data['lng'];
  }

  Point.fromList(List data) {
    lat = data[0];
    lng = data[1];
  }
}

var p1 = Point.fromMap({'lat': 23, 'lng': 50});
var p2 = Point.fromList([23, 50]);

An interface is a contract that a class must follow. Prefixing a method or variable with _ makes it private, so it won’t be visible when imported from a different file.

class Elephant {
  // Public interface
  final String name;

  // In the interface, but visible only in this library. (private)
  final int _id = 23;

  // Not in the interface, since this is a constructor.
  Elephant(this.name);

  // Public method.
  sayHi() => 'My name is $name.';

  // Private method.
  _saySecret() => 'My ID is $_id.';
}

The superclass or parent class contains the behaviors that is shared by all subclasses. The abstract keyword is used to indicate that the class is not meant to be instantiated, but rather to be inherited from.

abstract class Dog {
  void walk() {
    print('walking...');
  }
}

The subclass can @override the behavior of the superclass.

class Pug extends Dog {
  String breed = 'pug';

  @override
  void walk() {
    super.walk();
    print('I am tired. Stopping now.');
  }
}

A mixin is just like a class, it can have methods and properties, but it can’t be instantiated.

mixin Strong {
  bool doesLift = true;

  void benchPress() {
    print('doing bench press...');
  }
}

mixin Fast {
  bool doesRun = true;

  void sprint() {
    print('running fast...');
  }
}

Mixins are used to extend specific behaviors to classes with the with keyword. Certain Flutter libaries use mixins to extend shared behaviors to classes.

class Human {}

class SuperHuman extends Human with Strong, Fast {}

Generics are a way to parameterize types. They allow a class to wrap a type, and then use that type in multiple places. For example, we can have a Box class that wraps an double or String type.

Box<String> box1 = Box('cool');
Box<double> box2 = Box(2.23);

A generic type is a type that can be used as a substitute for a type parameter.

class Box<T> {
  T value;

  Box(this.value);

  T openBox() {
    return value;
  }
}

The easiest way to deal with name conflicts is to use a namespace package.

import 'somewhere.dart' as External;

Exclude code from a package with the hide keyword.

import 'somewhere.dart' hide Circle;

Import individual classes from a package with the show keyword.

import 'somewhere.dart' show Rectangle;

Many APIs in Dart/Flutter return Futures. To simulate an async event, we can create a future that will resolve after a 5 second delay.

var delay = Future.delayed(Duration(seconds: 5), cb);

A future can either be a success or a error. Use then then to handle a successful resolution and catchError to handle an error.

  delay
      .then((value) => print('I have been waiting'))
      .catchError((err) => print(err));

Async-await provides a cleaner (arguably) syntax for writing asynchronous code. The async keyword tells Dart to return a Future, while await pauses the execution of the function until the Future resolves.

Future<String> runInTheFuture() async {
  var data = await Future.value('world');

  return 'hello $data';
}