🎯

var name = "Dart";  // type inferred
String name = "Dart";  // explicit type

final name = "Dart";

const pi = 3.14159;

late String description;

String? nullableName;

int, double, String, bool, List, Map, Set

dynamic value = 42;
value = "now string";

if (value is String) { ... }

"Hello, $name!"
"Sum: ${1 + 2}"

"""
Multi
Line
"""

r"No escape \n here"

str.toUpperCase()
str.toLowerCase()
str.trim()
str.split(",")

var list = [1, 2, 3];
List<int> list = [1, 2, 3];

list.add(4);
list.addAll([5, 6]);
list.remove(1);
list.length;

var set = {1, 2, 3};
Set<int> set = {1, 2, 3};

var map = {"key": "value"};
Map<String, int> ages = {"Alice": 30};

var combined = [...list1, ...list2];

[1, 2, if (condition) 3]

[for (var i in items) i.toUpperCase()]

if (condition) {
  // code
} else if (other) {
  // code
} else {
  // code
}

var result = condition ? "yes" : "no";

value ?? defaultValue  // if null
value ??= defaultValue  // assign if null
object?.method()  // null-safe call

switch (value) {
  case 1:
    // code
    break;
  default:
    // code
}

for (var i = 0; i < 10; i++) {
  print(i);
}

for (var item in items) {
  print(item);
}

while (condition) {
  // code
}

do {
  // code
} while (condition);

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

int add(int a, int b) => a + b;

void greet(String name, [String? title]) {
  // title is optional
}

void greet({required String name, int age = 0}) {
  // named params
}

greet(name: "Alice", age: 30);

var add = (int a, int b) => a + b;

void execute(Function callback) {
  callback();
}

class Person {
  String name;
  int age;
  
  Person(this.name, this.age);
}

class Person {
  Person.guest() : name = "Guest", age = 0;
}

class Circle {
  double radius;
  double get area => 3.14 * radius * radius;
  set diameter(double d) => radius = d / 2;
}

class Person {
  String _secret;  // private (file-scoped)
}

class Counter {
  static int count = 0;
  static void increment() => count++;
}

class Student extends Person {
  String school;
  Student(String name, int age, this.school)
    : super(name, age);
}

abstract class Animal {
  void speak();
}

class Dog implements Animal {
  @override
  void speak() => print("Woof!");
}

mixin Swimming {
  void swim() => print("Swimming");
}

class Duck extends Bird with Swimming {}

extension StringExtension on String {
  String get reversed => split('').reversed.join();
}

Future<String> fetchData() {
  return Future.delayed(
    Duration(seconds: 1),
    () => "Data"
  );
}

Future<void> loadData() async {
  var data = await fetchData();
  print(data);
}

try {
  var data = await fetchData();
} catch (e) {
  print("Error: $e");
}

fetchData()
  .then((data) => print(data))
  .catchError((e) => print(e));

await Future.wait([future1, future2]);

Stream<int> countStream() async* {
  for (var i = 0; i < 5; i++) {
    yield i;
  }
}

stream.listen((data) {
  print(data);
});

await for (var value in stream) {
  print(value);
}

stream.map((x) => x * 2)
stream.where((x) => x > 5)
stream.first

String? name;  // can be null

String name = "Required";  // cannot be null

if (name != null) {
  print(name.length);  // promoted to non-null
}

name?.length  // null if name is null

object?..method1()..method2()

name!.length  // throws if null

name ?? "Unknown"

late String name;  // initialized later