Category: Examples

This example shows how to transform data in a stream.

import 'dart:async';

void main() {
  var controller = StreamController<int>();

  // Listen to the stream
  controller.stream
  .map((number) => number * number) // Transform numbers to their squares
  .listen((squared) {
print('Squared: $squared');
  });

  // Add data to the stream
  for (var i = 1; i <= 5; i++) {
controller.add(i);
  }

  controller.close();
}

This example demonstrates how to use isolates for parallel execution in Dart.

import 'dart:async';
import 'dart:io';
import 'dart:convert';

void isolateEntry(SendPort sendPort) {
  var receivePort = ReceivePort();
  sendPort.send(receivePort.sendPort);
  
  receivePort.listen((message) {
if (message is int) {
  var result = message * message;
  sendPort.send(result);
}
  });
}

Future<void> main() async {
  var receivePort = ReceivePort();
  await Isolate.spawn(isolateEntry, receivePort.sendPort);

  var sendPort = await receivePort.first as SendPort;

  print('Sending numbers to isolate for squaring:');
  for (var i = 1; i <= 5; i++) {
sendPort.send(i);
var squared = await receivePort.first;
print('Squared: $squared');
  }
}

This example creates a simple command-line calculator.

import 'dart:io';

double add(double a, double b) => a + b;
double subtract(double a, double b) => a - b;
double multiply(double a, double b) => a * b;
double divide(double a, double b) {
  if (b == 0) {
throw Exception('Cannot divide by zero');
  }
  return a / b;
}

void main() {
  print('Simple Calculator');
  print('Enter two numbers:');
  
  var input1 = stdin.readLineSync();
  var input2 = stdin.readLineSync();
  
  double num1 = double.parse(input1!);
  double num2 = double.parse(input2!);
  
  print('Choose an operation: +, -, *, /');
  var operation = stdin.readLineSync();
  
  double result;
  switch (operation) {
case '+':
  result = add(num1, num2);
  break;
case '-':
  result = subtract(num1, num2);
  break;
case '*':
  result = multiply(num1, num2);
  break;
case '/':
  result = divide(num1, num2);
  break;
default:
  print('Invalid operation');
  return;
  }
  
  print('Result: $result');
}

This example demonstrates how to make an HTTP GET request and handle JSON data.

import 'dart:convert';
import 'dart:io';

Future<void> fetchPosts() async {
  var url = 'https://jsonplaceholder.typicode.com/posts';
  var httpClient = HttpClient();

  try {
var request = await httpClient.getUrl(Uri.parse(url));
var response = await request.close();
if (response.statusCode == 200) {
  var jsonData = await response.transform(utf8.decoder).join();
  var posts = json.decode(jsonData);
  print('Fetched ${posts.length} posts:');
  for (var post in posts) {
    print('Title: ${post&#91;'title']}');
  }
} else {
  print('Error: ${response.statusCode}');
}
  } catch (e) {
print('Exception: $e');
  } finally {
httpClient.close();
  }
}

void main() {
  fetchPosts();
}

This example demonstrates the use of generics to create a stack data structure.

class Stack<T> {
  List<T> _elements = [];

  void push(T element) {
_elements.add(element);
print('Pushed: $element');
  }

  T pop() {
if (_elements.isEmpty) {
  throw Exception('Stack is empty');
}
var element = _elements.removeLast();
print('Popped: $element');
return element;
  }

  bool get isEmpty => _elements.isEmpty;
}

void main() {
  var intStack = Stack<int>();
  intStack.push(1);
  intStack.push(2);
  intStack.pop();

  var stringStack = Stack<String>();
  stringStack.push('Hello');
  stringStack.push('World');
  print('Popped from string stack: ${stringStack.pop()}');
}

This example shows how to create and handle custom exceptions.

class InsufficientFundsException implements Exception {
  final String message;

  InsufficientFundsException(this.message);

  @override
  String toString() => 'InsufficientFundsException: $message';
}

class BankAccount {
  double balance;

  BankAccount(this.balance);

  void withdraw(double amount) {
if (amount > balance) {
  throw InsufficientFundsException('Cannot withdraw \$${amount.toStringAsFixed(2)} with balance of \$${balance.toStringAsFixed(2)}');
}
balance -= amount;
print('Withdrawn: \$${amount.toStringAsFixed(2)}. New balance: \$${balance.toStringAsFixed(2)}');
  }
}

void main() {
  var account = BankAccount(100);

  try {
account.withdraw(50);
account.withdraw(60);
  } catch (e) {
print(e);
  }
}

This example demonstrates the use of Futures and Streams for asynchronous programming.

import 'dart:async';

void main() {
  // Using a Future
  print('Fetching data...');
  fetchData().then((data) {
print('Data received: $data');
  });

  // Using a Stream
  var numberStream = generateNumbers();
  numberStream.listen((number) {
print('Received number: $number');
  });
}

Future<String> fetchData() async {
  await Future.delayed(Duration(seconds: 2));
  return 'Sample Data';
}

Stream<int> generateNumbers() async* {
  for (var i = 1; i <= 5; i++) {
await Future.delayed(Duration(seconds: 1));
yield i;
  }
}

This example illustrates how to use mixins to share behavior between classes.

mixin Logger {
  void log(String message) {
print('LOG: $message');
  }
}

class User with Logger {
  String name;

  User(this.name);

  void sayHello() {
log('User $name says hello!');
  }
}

class Admin with Logger {
  String adminName;

  Admin(this.adminName);

  void performAdminTask() {
log('Admin $adminName is performing an admin task.');
  }
}

void main() {
  var user = User('Alice');
  user.sayHello();

  var admin = Admin('Bob');
  admin.performAdminTask();
}

This example demonstrates how to read from and write to files in Dart.

import 'dart:io';

void main() async {
  // Writing to a file
  var file = File('example.txt');
  await file.writeAsString('Hello, Dart!\nThis is a file I/O example.\n');

  print('File written: ${file.path}');

  // Reading from the file
  String contents = await file.readAsString();
  print('File contents:\n$contents');

  // Appending to the file
  await file.writeAsString('Appending new content.\n', mode: FileMode.append);
  contents = await file.readAsString();
  print('Updated file contents:\n$contents');
}

This example shows how to manipulate collections and use higher-order functions.

void main() {
  List<int> numbers = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];

  // Filtering even numbers
  var evenNumbers = numbers.where((number) => number.isEven).toList();
  print('Even Numbers: $evenNumbers');

  // Squaring the numbers
  var squaredNumbers = numbers.map((number) => number * number).toList();
  print('Squared Numbers: $squaredNumbers');

  // Summing all numbers
  var sum = numbers.reduce((a, b) => a + b);
  print('Sum of Numbers: $sum');

  // Finding the maximum number
  var maxNumber = numbers.reduce((a, b) => a > b ? a : b);
  print('Maximum Number: $maxNumber');
}