Home > Posts > Beginner's Guide to Dart

Beginner's Guide to Dart

  ·   15 min read

Introduction to Dart #

What is Dart? #

Dart is a client-optimized programming language developed by Google. It’s used to build fast apps for any platform, from mobile and web to desktop and server. Dart is known for its ease of learning, its strong typing system that helps prevent errors, and its excellent performance. It compiles to native code (for faster execution on devices) or to JavaScript (for running in web browsers). Dart’s features include:

  • Object-Oriented: Dart is object-oriented, meaning it uses classes and objects to structure code, promoting reusability and maintainability.
  • Garbage Collected: Memory management is handled automatically, freeing developers from manual memory allocation and deallocation.
  • Ahead-of-Time (AOT) and Just-in-Time (JIT) Compilation: Dart supports both AOT and JIT compilation, allowing for fast development cycles during debugging and optimized performance in production.
  • Rich Standard Library: A comprehensive standard library provides ready-to-use functionalities for various tasks.
  • Asynchronous Programming Support: Dart features excellent support for asynchronous programming with features like async and await, making it easy to handle long-running operations without blocking the UI.

Why use Dart? #

Dart offers several advantages for developers:

  • Fast Development: The combination of JIT compilation for rapid iteration during development and AOT compilation for optimized performance in release makes the development cycle efficient.
  • Easy to Learn: Dart’s syntax is clean and relatively easy to understand, making it accessible to beginners while still being powerful enough for complex applications.
  • Cross-Platform Development: Dart allows you to build applications for multiple platforms (web, mobile, desktop) using a single codebase. Frameworks like Flutter leverage this capability.
  • Strong Performance: Dart compiles to native machine code, resulting in applications with high performance and responsiveness.
  • Large and Growing Community: A vibrant and supportive community provides ample resources, tutorials, and assistance.

Setting up your Dart environment #

Setting up your Dart environment is straightforward. The primary method is to download the Dart SDK from the official website (https://dart.dev/get-dart). The SDK includes the Dart compiler (dartc), the Dart virtual machine (dart), and various other tools.

After downloading and installing the SDK, you need to add the Dart SDK’s bin directory to your system’s PATH environment variable. This allows you to run Dart commands from your terminal or command prompt. The exact steps for adding to your PATH depend on your operating system (Windows, macOS, Linux), but generally involve adding a new entry to your system’s environment variables configuration.

Once the PATH is set, you can verify the installation by opening a new terminal and typing dart --version. This should display the installed Dart version. For IDE support, popular choices include VS Code, Android Studio, and IntelliJ IDEA, with plugins readily available to enhance Dart development.

Hello, world! Your first Dart program. #

The simplest Dart program is the classic “Hello, world!” program. Create a file named main.dart (or any name with a .dart extension) and add the following code:

void main() {
  print('Hello, world!');
}

To run this program, open your terminal, navigate to the directory containing main.dart, and type dart main.dart. The output will be:

Hello, world!

This program defines a main function, which is the entry point of every Dart program. The print() function displays the text “Hello, world!” to the console. This simple example demonstrates the basic structure of a Dart program and provides a starting point for more complex applications.

Dart Fundamentals #

Variables and Data Types #

Dart is a statically-typed language, meaning the type of a variable is known at compile time. However, Dart also offers type inference, so you often don’t need to explicitly specify the type. Dart’s core data types include:

  • int: Represents integers (whole numbers). Example: int age = 30;
  • double: Represents floating-point numbers (numbers with decimal points). Example: double price = 99.99;
  • String: Represents text. Example: String name = "Alice"; String literals can be enclosed in single or double quotes.
  • bool: Represents boolean values (true or false). Example: bool isAdult = true;
  • dynamic: A variable of type dynamic can hold values of any type. Use with caution, as type safety is lost. Example: dynamic value = 10; value = "hello";
  • List: Represents an ordered collection of objects. Example: List<int> numbers = [1, 2, 3]; Note the use of generics (<int>) to specify the type of elements in the list.
  • Map: Represents a collection of key-value pairs. Example: Map<String, int> ages = {"Alice": 30, "Bob": 25}; Again, generics are used to specify the types of keys and values.

Operators #

Dart supports a wide range of operators, including:

  • Arithmetic Operators: +, -, *, /, % (modulo), ~/ (integer division).
  • Assignment Operators: =, +=, -=, *=, /=, %=, ~/=.
  • Comparison Operators: ==, !=, >, <, >=, <=.
  • Logical Operators: && (AND), || (OR), ! (NOT).
  • Bitwise Operators: &, |, ^, ~, <<, >>, >>>.
  • Conditional Operator (Ternary Operator): condition ? valueIfTrue : valueIfFalse. Example: int age = 18; String status = (age >= 18) ? "Adult" : "Minor";
  • Null-Aware Operators: ?? (null-aware operator), ??= (null-aware assignment operator). These handle null values gracefully. Example: String name = user?.name ?? "Guest";

Control Flow (if-else, for, while) #

Dart provides standard control flow statements:

  • if-else: Used for conditional execution.
if (age >= 18) {
  print("Adult");
} else {
  print("Minor");
}
  • for loop: Used for iterating over a collection or a range of values.
for (int i = 0; i < 10; i++) {
  print(i);
}

List<String> names = ["Alice", "Bob", "Charlie"];
for (String name in names) {
  print(name);
}
  • while loop: Used for repeating a block of code as long as a condition is true.
int count = 0;
while (count < 5) {
  print(count);
  count++;
}
  • do-while loop: Similar to while, but the condition is checked at the end of the loop, guaranteeing at least one execution.
int count = 0;
do {
  print(count);
  count++;
} while (count < 5);

Functions #

Functions are blocks of reusable code. Dart supports named and anonymous functions.

// Named function
int add(int a, int b) {
  return a + b;
}

// Anonymous function (lambda expression)
int subtract(int a, int b) => a - b; // concise syntax for a single-expression function

void main() {
  print(add(5, 3)); // Output: 8
  print(subtract(5, 3)); // Output: 2
}

Functions can have optional parameters using curly braces {} and default values:

String greet({String name = "Guest", String greeting = "Hello"}) {
  return "$greeting, $name!";
}

Classes and Objects #

Dart is an object-oriented language, so classes are fundamental.

class Dog {
  String name;
  String breed;

  Dog(this.name, this.breed); // Constructor

  void bark() {
    print("Woof!");
  }
}

void main() {
  Dog myDog = Dog("Buddy", "Golden Retriever");
  print(myDog.name); // Output: Buddy
  myDog.bark(); // Output: Woof!
}

This defines a Dog class with properties (name, breed) and a method (bark). The constructor initializes the object’s properties. Objects are created using the new keyword (although new is optional in most cases). Classes can also have getters and setters for managing access to properties.

Working with Data #

Lists #

Lists in Dart are ordered collections of objects. They can contain elements of different types (though it’s generally best practice to use a typed list for better code clarity and error prevention). Lists are dynamically sized; you can add or remove elements as needed.

Creating Lists:

// List with type inference
var numbers = [1, 2, 3, 4, 5];

// Typed list
List<String> names = ["Alice", "Bob", "Charlie"];

// Empty list
List<int> emptyList = [];

Accessing Elements:

Elements are accessed using their index (starting from 0).

print(numbers[0]); // Output: 1
print(names[1]); // Output: Bob

Adding Elements:

names.add("David");
names.addAll(["Eve", "Frank"]);

Removing Elements:

names.remove("Bob");
names.removeAt(0); //Removes element at index 0

Other List Methods:

Lists have many useful methods like length, contains, indexOf, sort, reversed, etc. Refer to the Dart documentation for a complete list.

Maps #

Maps in Dart are collections of key-value pairs. Each key is unique, and maps are unordered. Maps can also be typed, specifying the types of both keys and values.

Creating Maps:

// Map with type inference
var ages = {"Alice": 30, "Bob": 25};

// Typed map
Map<String, int> agesTyped = {"Alice": 30, "Bob": 25};

// Empty map
Map<String, String> emptyMap = {};

Accessing Values:

Values are accessed using their keys.

print(ages["Alice"]); // Output: 30

Adding and Updating Entries:

ages["Charlie"] = 35; // Adds a new entry
ages["Alice"] = 31; // Updates an existing entry

Removing Entries:

ages.remove("Bob");

Other Map Methods:

Maps also offer many useful methods like length, containsKey, containsValue, keys, values, entries, etc.

Sets #

Sets in Dart are unordered collections of unique objects. They’re useful when you need to ensure that there are no duplicate elements.

Creating Sets:

// Set with type inference
var uniqueNumbers = {1, 2, 2, 3, 4, 4, 5}; // Duplicates are automatically removed.  Output: {1, 2, 3, 4, 5}

// Typed set
Set<String> uniqueNames = {"Alice", "Bob", "Alice", "Charlie"}; // Output: {"Alice", "Bob", "Charlie"}

Adding Elements:

uniqueNumbers.add(6);

Removing Elements:

uniqueNumbers.remove(2);

Checking for Existence:

print(uniqueNumbers.contains(3)); // Output: true

Other Set Methods:

Sets provide methods like length, union, intersection, difference, etc., for common set operations.

Null Safety #

Null safety is a major feature in Dart that helps prevent null pointer exceptions. It ensures that variables cannot hold null values unless explicitly allowed.

Non-nullable Types:

By default, variables are non-nullable. This means that they must be assigned a value before they can be used. Attempting to access a non-nullable variable that hasn’t been initialized will result in a compile-time error.

String name; // This will cause a compile-time error if not initialized before use.
name = "Alice"; //This is correct.

Nullable Types:

To allow a variable to hold a null value, add a question mark (?) after the type.

String? optionalName; // optionalName can be null

Null-aware Operators:

Null-aware operators help you safely handle potentially null values:

  • ?. (null-aware access operator): Safely accesses a property of an object that might be null. Example: print(optionalName?.length); (This won’t throw an error if optionalName is null).
  • ?? (null-aware operator): Provides a default value if an expression is null. Example: String displayName = optionalName ?? "Guest";
  • ??= (null-aware assignment operator): Assigns a value only if the variable is currently null. Example: optionalName ??= "Default Name";

Null safety significantly improves code robustness by helping developers avoid common runtime errors related to null values. Understanding non-nullable and nullable types and utilizing null-aware operators are crucial for writing reliable Dart code.

Advanced Dart Concepts #

Generics #

Generics allow you to write reusable code that can work with different types without losing type safety. They’re especially useful when working with collections (like lists and maps) where you want to ensure that all elements are of a specific type.

Example:

Let’s create a generic function that finds the maximum value in a list:

T findMax<T extends Comparable<T>>(List<T> list) {
  if (list.isEmpty) {
    throw ArgumentError("List cannot be empty");
  }
  T max = list[0];
  for (T item in list) {
    if (item.compareTo(max) > 0) {
      max = item;
    }
  }
  return max;
}

void main() {
  List<int> numbers = [1, 5, 2, 8, 3];
  int maxNumber = findMax(numbers);
  print("Max number: $maxNumber"); // Output: Max number: 8

  List<String> strings = ["apple", "banana", "cherry"];
  String maxString = findMax(strings);
  print("Max string: $maxString"); // Output: Max string: cherry
}

In this example, findMax is a generic function that works with any type T that implements the Comparable interface. The extends Comparable<T> clause ensures type safety – only comparable types can be used with this function.

Asynchronous Programming (async/await) #

Asynchronous programming is essential for handling operations that might take some time to complete (e.g., network requests, file I/O). Dart’s async and await keywords make asynchronous code easier to read and write.

Example:

Let’s simulate a time-consuming operation:

import 'dart:async';

Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 2)); // Simulate a 2-second delay
  return "Data from the server";
}

void main() async {
  print("Starting...");
  String data = await fetchData(); // await pauses execution until fetchData completes
  print("Data received: $data"); // Output after 2 seconds: Data received: Data from the server
  print("Finished.");
}

fetchData is an async function that returns a Future<String>. The await keyword in main pauses execution until the Future returned by fetchData completes and returns its value. Without async and await, handling asynchronous operations would require more complex callbacks or listeners.

Exception Handling #

Exception handling allows you to gracefully handle errors that might occur during program execution. Dart uses try, catch, and finally blocks for this purpose.

void main() {
  try {
    int result = 10 ~/ 0; // Integer division by zero
  } on IntegerDivisionByZeroException {
    print("Error: Cannot divide by zero.");
  } catch (e) {
    print("An unexpected error occurred: $e");
  } finally {
    print("This block always executes.");
  }
}

The try block contains code that might throw an exception. The catch block handles specific exceptions (in this case, IntegerDivisionByZeroException). A more general catch block can catch any exception. The finally block executes regardless of whether an exception was thrown or caught.

Working with JSON #

JSON (JavaScript Object Notation) is a common format for data exchange. Dart’s dart:convert library provides tools for working with JSON.

import 'dart:convert';

void main() {
  String jsonString = '{"name": "Alice", "age": 30}';

  // Decode JSON string to a Map
  Map<String, dynamic> jsonData = jsonDecode(jsonString);
  print(jsonData["name"]); // Output: Alice
  print(jsonData["age"]);  // Output: 30

  // Encode a Map to a JSON string
  Map<String, dynamic> dataToEncode = {"name": "Bob", "city": "New York"};
  String encodedJson = jsonEncode(dataToEncode);
  print(encodedJson); // Output: {"name":"Bob","city":"New York"}
}

jsonDecode converts a JSON string into a Dart object (usually a Map or List). jsonEncode converts a Dart object into a JSON string. This allows easy interaction with APIs and other systems that use JSON for data transfer.

Building a Simple App #

This section guides you through building a basic command-line application in Dart to illustrate fundamental concepts like project structure, user input/output, and interactive elements. While not a full-fledged GUI application, this example demonstrates core principles applicable to more complex projects.

Project Structure #

For a simple Dart command-line application, the project structure is straightforward. You typically have a single main Dart file (often named main.dart). For larger projects, you might organize code into packages and multiple files, but for this beginner’s example, a single file suffices.

Create a file named main.dart. All your application code will reside within this file.

User Input and Output #

Dart provides simple ways to interact with the user via the console.

  • Output: The print() function sends text to the console.

  • Input: The stdin.readLineSync() function reads a line of text from the console. This function blocks until the user presses Enter.

Example combining input and output:

import 'dart:io';

void main() {
  print("Enter your name:");
  String? name = stdin.readLineSync(); // readLineSync() returns a String? (nullable String)
  print("Hello, $name!");
}

This program prompts the user to enter their name, reads the input, and then greets the user using the entered name. Note the use of String? to indicate that name might be null (if the user doesn’t enter anything before pressing Enter). Always consider null safety when handling user input.

Creating Interactive Elements #

For a command-line application, interactivity is primarily achieved through loops and conditional statements that respond to user input. Let’s build a simple number guessing game:

import 'dart:io';
import 'dart:math';

void main() {
  int secretNumber = Random().nextInt(100) + 1; // Generates a random number between 1 and 100
  int guess;
  int attempts = 0;

  print("Welcome to the Number Guessing Game!");
  print("I'm thinking of a number between 1 and 100.");

  do {
    attempts++;
    print("\nEnter your guess:");
    String? input = stdin.readLineSync();
    try {
      guess = int.parse(input!); // Parse input as integer; throws error if not a number
    } catch (e) {
      print("Invalid input. Please enter a number.");
      continue; // Skip to next iteration of the loop
    }

    if (guess < secretNumber) {
      print("Too low!");
    } else if (guess > secretNumber) {
      print("Too high!");
    }
  } while (guess != secretNumber);

  print("\nCongratulations! You guessed the number in $attempts attempts.");
}

This game generates a random number and repeatedly prompts the user for guesses until the correct number is entered. It provides feedback (too high or too low) and counts the number of attempts. Error handling is included to manage non-numeric input. This example showcases how simple loops, conditionals, and input/output create a basic interactive experience in a command-line Dart application. More complex interactions in command-line apps might involve menus, or parsing command line arguments. For richer user interfaces, consider frameworks like Flutter.

Next Steps #

This section points you towards resources and communities to help you continue your Dart journey.

Learning Resources #

The official Dart website (https://dart.dev/) is an excellent starting point. It offers comprehensive documentation, tutorials, and guides covering various aspects of Dart programming, from the fundamentals to advanced topics.

Other valuable resources include:

  • DartPad: An online Dart editor (https://dartpad.dev/) allows you to experiment with Dart code directly in your browser without setting up a local environment. It’s perfect for quick tests and learning new concepts.

  • Online Courses: Platforms like Udemy, Coursera, and others offer Dart and Flutter courses suitable for various skill levels. Look for courses that align with your learning style and goals.

  • Books: Several books are available on Dart and Flutter, providing a more in-depth and structured learning experience.

Community and Support #

The Dart community is active and supportive. Here are some ways to connect with other Dart developers:

  • Stack Overflow: Search for Dart-related questions or ask your own. The Stack Overflow community is a valuable resource for finding solutions to common problems.

  • GitHub: Explore open-source Dart projects on GitHub. Contributing to open source is a great way to learn from others and improve your skills.

  • Dart’s Official Forums/Discussions: Check the Dart website for links to official discussion forums where you can engage with the Dart team and other developers. This is a good place for asking questions and sharing your knowledge.

  • Flutter Community (if using Flutter): Since Dart is often used with Flutter, the Flutter community offers many resources and support channels.

Exploring Dart Packages #

Dart’s package ecosystem (hosted on pub.dev, https://pub.dev/) provides access to a vast library of pre-built packages that extend Dart’s functionality. These packages offer solutions for various tasks, including:

  • HTTP requests: Packages like http simplify making HTTP requests to web servers.
  • Database interactions: Packages help interact with databases like SQLite, PostgreSQL, and others.
  • UI components (if using Flutter): If you’re building Flutter apps, many UI packages provide ready-made widgets and components to speed up development.
  • Testing: Packages provide testing frameworks to write unit tests and integration tests for your code.
  • Data serialization: Packages handle JSON, XML, and other data formats.

Using packages can significantly accelerate your development process, allowing you to focus on the unique aspects of your application rather than reinventing the wheel. Familiarize yourself with the pub.dev website and learn how to add and manage packages in your Dart projects. This will be a significant step in building more complex and robust applications.

←
Beginner's Guide to Objective-C
Beginner's Guide to MATLAB
→
back to top