A Tour of the Dart Language

String methods

Each string literal has the type String. String has some handy methods, including some that let you determine whether a string starts with, ends with, or contains another string.

var fullName = 'Cuthbert Musgrave Girdlestone, III';

fullName.startsWith('Cuthbert');            // true
fullName.endsWith('III');                   // true
fullName.contains(new RegExp('Musgrave'));  // true

Strings are immutable objects, which means you can create them but you can't change them. If you look closely at the String API docs, you'll notice that none of the methods actually changes the state of a String. For example, the method replaceAll() returns a new String without changing the original String.

var greetingTemplate = 'Hello, NAME!';
var greeting = greetingTemplate.replaceAll(new RegExp("NAME"), 'Bob');
print(greeting == greetingTemplate); // false; greetingTemplate didn't change

var sb = new StringBuffer();

sb.add("Use a StringBuffer");
sb.addAll(["for ", "efficient ", "string ", "creation "]);
sb.add("if you are ").add("building lots of strings.");

var fullString = sb.toString();

print(fullString); // Use a StringBuffer for efficient string creation
                   // if you are building lots of strings.

sb.clear();        // All gone!

Numbers

Dart numbers come in two flavors:

int

Integers of arbitrary size

double

Decimal 64-bit doubles, as specified by the IEEE 754 standard

Both int and double are subinterfaces of num. The num interface defines basic operators such as +, -, /, and *, as well as bitwise operators such as >>. The num interface is also where you'll find abs(), ceil(), and floor(), among other methods. If num and its subinterfaces don't have what you're looking for, the Math class might.

Integers are numbers without a decimal point. Here are some examples of defining integer literals:

var x = 1;
var hex = 0xDEADBEEF;
var bigInt = 3465346583465243765923847659234765928347659567398475647495873984572947593470294387093493456870849216348723763945678236420938467345762304958724596873045876234572037862934765294365243652548673456705673465273465246734506873456729457623845623456234650457693475603768922346728346256;

If a number includes a decimal, it is a double. Here are some examples of defining double literals:

var y = 1.1;
var exponents = 1.42e5;

Here's how you turn a string into a number, or vice versa:

// string -> int
var one = Math.parseInt("1");                   // 1

// string -> double
var onePointOne = Math.parseDouble("1.1");      // 1.1

// int -> string
String oneAsString = 1.toString();              // "1"

// double -> string
String piAsString = 3.14159.toStringAsFixed(2); // "3.14"

Booleans

Dart has a formal boolean type, named bool. Only two objects have type bool: the boolean literals, true and false.

When Dart expects a boolean value, if that value isn't true, then it is false. Unlike in JavaScript, values such as 1 or non-null objects are not treated as true.

For example, consider the following code:

var name = 'Bob';
if (name) {
  print("You have a name!"); // Prints in JavaScript, not in Dart
}

In JavaScript, this code prints "You have a name!" because name is a non-null object. However, in Dart, the above doesn't print at all because name is converted to false because name != true.

Here's another example of code that behaves differently in JavaScript and Dart:

if (1) {
  print("JavaScript prints this line because it thinks 1 is true.");
} else {
  print("Dart prints this line because it thinks 1 is NOT true.");
}

Dart's treatment of booleans is designed to avoid the strange behaviors that can arise when many values can be treated as true. What this means for you is that, instead of using code like if (nonboolean_value), you should instead explicitly check for values. For example:

// Check for an empty string.
var fullName = '';
if (fullName.isEmpty()) {
  print("Please enter a full name");
}

// Check for zero.
var hitPoints = 0;
if (hitPoints == 0) {
  print("Uh oh! Looks like you died.");
}

// Check for null.
var unicorn = null;
if (unicorn == null) {
  print("You didn't wish hard enough. Wish harder.");
}

// Check for NaN.
var iMeantToDoThis = 0/0;
if (iMeantToDoThis.isNaN()) {
  print("0/0 is not a number.");
}

Lists (also known as arrays)

Perhaps the most common collection in nearly every programming language is the array, or ordered set of objects. In Dart, arrays are List objects, so we usually just call them lists. When you compile Dart to JavaScript, a Dart list compiles to a JavaScript array.

Dart list literals look like JavaScript array literals. Here's a simple Dart list:

var list = [1,2,3];

You can get a list's length and refer to list elements just as you would in JavaScript:

var list = [1,2,3];
print(list.length); // the # of elements: 3
print(list[1]);     // the second item: 2

You can add an element to a list using the add() method:

var list = [1,2,3];
list.add(4);

To remove elements from a list (reducing the list's size), use the removeRange() method:

var list = [1,2,3,4];
list.removeRange(2, 1); // remove the third element

So far, we've only talked about extendable lists, but you can also create lists with a fixed size, using the List() constructor:

var list = new List(3); //fixed-size list (full of null values)

var list = [1,2,3];
for (var x = 0; x < list.length; x++) {
  print('$x: ${list[x]}');
}

var list = [1,2,3];
for (final x in list) {
  print(x);
}

var list = [1,2,3];
void printElement(element) => print(element);
list.forEach(printElement);

var list = [1,2,3];
list.forEach((element) => print(element));

Maps

In general, a map is an object that associates keys to values. Dart support for maps is provided by map literals and the Map interface.

Here's a simple Dart map:

var gifts = {                         // a map literal
// keys       values
  "first"  : "partridge",
  "second" : "turtledoves",
  "fifth"  : "golden rings"};

In map literals, each key must be a string. If you use a Map constructor, then you have more options: the key can be a string, a number, or any other object that implements the Hashable interface.

var map = new Map();                  // use a Map constructor
map[1] = "partridge";                 // key is 1; value is "partridge"
map[2] = "turtledoves";               // key is 2; value is "turtledoves"
map[5] = "golden rings";              // key is 5; value is "golden rings"

A map value can be any object or null.

You add a new key-value pair to an existing map just as you would in JavaScript:

var gifts = { "first": "partridge" };
gifts["fourth"] = "calling birds";    // add a key-value pair

You retrieve a value from a map the same way you would in JavaScript:

var gifts = { "first": "partridge" };
print(gifts['first']);                // partridge

If you look for a key that isn't in a map, you get a null in return. However, because values can be null, you might need to use a method such as containsKey() or putIfAbsent() to make sure you interpret null correctly.

var gifts = { "first": "partridge" };
print(gifts['fifth']);                // null

Use .length to get the number of key-value pairs in the map:

var gifts = { "first": "partridge" };
gifts["fourth"] = "calling birds";
print(gifts.length);                  // 2

To remove a key-value pair from a map, use the remove() method:

var gifts = { "first": "partridge" };
gifts["fourth"] = "calling birds";
gifts.remove('first');
print(gifts.length);                  // 1
print(gifts['first']);                // null

You can copy a map using the Map.from() constructor:

var gifts = { "first": "partridge" };
var regifts = new Map.from(gifts);
print(regifts['first']);              // partridge

var gifts = {
  "first" : "partridge",
  "second": "turtledoves",
  "fifth" : "golden rings"};
gifts.forEach((k,v) => print('$k : $v'));

var gifts = {"first": "partridge", "second": "turtledoves"};
var values = gifts.getValues();
values.forEach((v) => print(v));      //partridge, turtledoves

Summary of built-in types

Dart's built-in types all have special literals and implement a built-in interface. For example, numbers have literals such as 1 and 1.1, and they implement the num interface.

You often use literals to create objects of most built-in types, but you can also use constructors. Booleans are unusual because you can't create new objects of type bool; you're stuck with true and false.

Arithmetic operators

Dart supports the usual arithmetic operators.

Example:

int a = 2;
int b = 3;

print('${a + b}');  //5
print('${a - b}');  //-1
print('${a * b}');  //6
print('${a / b}');  //0.6666666666666666
print('${a ~/ b}'); //0 (quotient)
print('${a % b}');  //2 (remainder)

Dart also supports both prefix and postfix increment and decrement operators.

Example:

int a = 2;

print('${ ++a }'); //3 (increment before returning a value)
print('${ a++ }'); //3 (increment after returning a value)
print('${ a-- }'); //4 (decrement after returning a value)
print('${ --a }'); //2 (decrement before returning a value)

Equality and relational operators

To test whether two objects x and y represent the same thing, use the == operator. You don't usually need to use the === operator, which tests whether two objects are, in fact, the exact same object. Here's how the == operator will work:

1. If x===y, return true.
2. Otherwise, if either x or y is null, return false.
3. Otherwise, return the result of x.equals(y).

The is and is! operators are handy for checking types. The result of obj is T is true if obj implements the interface specified by T. For example, obj is Object is always true.

Here's an example of using each of the equality and relational operators:

int a = 2;
int b = 3;
int c = a;

print(a == 2);       //true; 2 and 2 are equal
print(a != b);       //true; 2 and 3 aren't equal
print(a === c);      //true; a and c are the same object
print(a !== b);      //true; 2 and 3 aren't the same object
print(b > a);        //true; 3 is more than 2
print(a < b);        //true; 2 is less then 3
print(b >= b);       //true; 3 is greater than or equal to 3
print(a <= b);       //true; 2 is less than or equal to 3
print(a is num);     //true; 2 is a number
print(a is! String); //true; 2 is an int, not a string

Assignment operators

You assign values using the = operator. You can also use compound assignment operators, which combine an operation with an assignment.

Here's a full list of the assignment operators:

=
+=
–=
*=
/=
~/=
%=
<<=
>>=
&=
^=
|=

The following example uses both assignment and compound assignment operators:

int a = 2;           //Assign using =

a *= 3;              //Assign and multiply: a = a * 3
print('a *= 3: $a'); //a *= 3: 6

Logical operators

You can invert or combine boolean expressions using the logical operators.

if (!done && (col == 0 || col == 3)) {
  //...do something
}

Bitwise and shift operators

You can manipulate the individual bits of objects in Dart. Usually, you'd use these operators with integers.

Here's an example of using bitwise and shift operators.

int value = 0x22;
int bitmask = 0x0F;

print(value);                                //34 (0x22)
print(value.toRadixString(16));              //22
print(value.toRadixString(2));               //100010
print((value & bitmask).toRadixString(16));  //2  (AND)
print((value & ~bitmask).toRadixString(16)); //20 (AND NOT)
print((value | bitmask).toRadixString(16));  //2f (OR)
print((value ^ bitmask).toRadixString(16));  //2d (XOR)
print((value << 4).toRadixString(16));       //220
print((value >> 4).toRadixString(16));       //2

Other operators

Operators are methods

Operators are just instance methods with special names. For example, the expression 1 + 2 invokes the + method on 1, with the argument 2—something like 1.+(2). This has a couple of consequences:

• Dart lets you override many operators. For example, if you define a Vector class, you might define a + method to add two vectors.
• For operators that work on two operands, the leftmost operand determines which version of the operator is used. For example, if you define a Vector class and a Point class, aVector + aPoint uses the Vector version of +.