The unique features of Dart that may not be commonly found in other programming languages make it a powerful and flexible language. Here is a summary of the features discussed (2024-05-24) :
Optional Typing with Strong Mode
Null Safety
Collection if and Collection for
Extension Methods
Async-Await and Isolates
Factory Constructors
Mixins
Spread Operator
Cascade Notation
Top-Level Functions
Named Parameters
Optional Positional Parameters
Getters and Setters
const Constructors
Symbols
Typedefs
Operator Overloading
Static Methods and Variables
Late Variables
Enum
Asynchronous Generators
Implicit Interfaces
Deferred Loading
Meta-Programming with Annotations
Generics with Type Bounds
Safe String Interpolation
Synchronous and Asynchronous Exception Handling
Initializer Lists
Constant Constructors
Generators with sync* and async*
Metadata with Annotations
noSuchMethod for Handling Missing Methods
Tear-Offs for Functions
Built-in Isolates for Concurrency
Deferred Loading for Code Splitting
Built-in Collections Libraries
Function as First-Class Objects
Spread Operator with Null-aware (...?)
Super-Initializer Parameters
Enhanced Enums
No-name Declarations
Zones
runZonedGuarded
These features make Dart an appealing choice for application development, especially with the Flutter framework that leverages many of these features to provide an efficient and effective development experience.
The unique features of Dart that may not be commonly found in other programming languages:
1. Optional Typing with Strong Mode
Dart supports optional typing with strong mode, providing flexibility and type safety at compile time.
var name = 'John';
int age = 30;
2. Null Safety
This feature ensures that variables cannot be null unless explicitly specified.
String? nullableString;
String nonNullableString = 'Hello';
3. Collection if and Collection for
Allows conditions and loops directly within collection literals.
var isLoggedIn = true;
var nav = [
'Home',
'About',
if (isLoggedIn) 'Logout'
];
4. Extension Methods
Allows adding new methods to existing types without modifying their definitions.
extension StringExtension on String {
String toUpperCaseFirst() {
return this[0].toUpperCase() + this.substring(1);
}
}
5. Async-Await and Isolates
Dart supports asynchronous programming and isolates for concurrency without shared memory.
Future<void> fetchData() async {
var data = await fetchDataFromNetwork();
print(data);
}
6. Factory Constructors
Provides full control over object instantiation, including returning existing instances.
class Logger {
static final Logger _instance = Logger._internal();
factory Logger() => _instance;
Logger._internal();
}
7. Mixins
Used for sharing code between classes without using inheritance.
mixin Logger {
void log(String message) {
print('Log: $message');
}
}
8. Spread Operator
Allows spreading elements from one collection into another.
var list1 = [1, 2, 3];
var list2 = [0, ...list1, 4];
9. Cascade Notation
Allows performing a sequence of operations on the same object with the cascade notation (..).
var buffer = StringBuffer()
..write('Hello')
..write(' ')
..write('World!');
10. Top-Level Functions
Supports functions declared outside of classes.
void topLevelFunction() {
print('This is a top-level function.');
}
11. Named Parameters
Allows named parameters to enhance code readability.
void greet({required String name, int age = 0}) {
print('Hello, $name! You are $age years old.');
}
12. Optional Positional Parameters
Allows optional positional parameters enclosed in square brackets ([]).
void greet(String name, [int age = 0]) {
print('Hello, $name! You are $age years old.');
}
13. Getters and Setters
Supports creating getters and setters for controlled access to object properties.
class Rectangle {
double width;
double height;
double get area => width * height;
}
14. const Constructors
Allows creating immutable objects at compile time with the const constructor.
class Point {
final double x, y;
const Point(this.x, this.y);
}
15. Symbols
Supports using symbols for unique identification.
Symbol symbol1 = #mySymbol;
16. Typedefs
Allows defining type aliases for functions, improving readability and code management.
typedef IntToIntFunction = int Function(int);
17. Operator Overloading
Allows overloading operators for specific types.
class Vector {
final int x, y;
Vector(this.x, this.y);
Vector operator +(Vector v) => Vector(x + v.x, y + v.y);
}
18. Static Methods and Variables
Supports static methods and variables that can be accessed without creating an instance of the class.
class MathUtils {
static double pi = 3.14159;
static double calculateArea(double radius) => pi * radius * radius;
}
19. Late Variables
Allows deferred initialization of variables until they are first accessed using the late keyword.
class Example {
late String description;
}
20. Enum
Supports enumerations to define a set of fixed values.
enum Color { red, green, blue }
21. Asynchronous Generators
Supports asynchronous generators using async* and yield.
Stream<int> asyncGenerator(int n) async* {
for (int i = 0; i < n; i++) {
await Future.delayed(Duration(seconds: 1));
yield i;
}
}
22. Implicit Interfaces
All classes implicitly define the same interface as the class itself.
class Animal {
void makeSound() => print('Animal sound');
}
23. Deferred Loading
Supports deferred loading to optimize application size and load time.
import 'deferred_library.dart' deferred as deferredLibrary;
Supports annotations to add metadata to code.
class MyAnnotation {
final String description;
const MyAnnotation(this.description);
}
25. Generics with Type Bounds
Allows using generics with type bounds to ensure the generic type meets certain criteria.
class Box<T extends num> {
final T value;
}
26. Safe String Interpolation
Supports safe and easy string interpolation.
void main() {
String name = 'World';
print('Hello, $name!');
}
27. Synchronous and Asynchronous Exception Handling
Supports consistent syntax for synchronous and asynchronous exception handling.
void main() async {
try {
var result = await asyncFunction();
print(result);
} catch (e) {
print('Caught error: $e');
}
}
28. Initializer Lists
Allows initializing instance properties before the constructor body runs.
class Point {
final double x, y;
Point(double x, double y)
: x = x,
y = y;
}
29. Constant Constructors
Allows creating immutable objects at compile time.
class ImmutablePoint {
final double x, y;
const ImmutablePoint(this.x, this.y);
}
30. Generators with sync* and async*
Supports synchronous and asynchronous generators.
Iterable<int> syncGenerator(int n) sync* {
for (int i = 0; i < n; i++) {
yield i;
}
}
Supports using annotations for meta-programming.
class MyAnnotation {
final String description;
const MyAnnotation(this.description);
}
32. noSuchMethod for Handling Missing Methods
Allows dynamic handling of calls to non-existent methods.
class A {
@override
void noSuchMethod(Invocation invocation) {
print('Tried to call ${invocation.memberName}');
}
}
33. Tear-Offs for Functions
Allows referencing functions or methods as objects.
void printElement(int element) {
print(element);
}
34. Built-in Isolates for Concurrency
Uses isolates for parallel execution without shared memory.
import 'dart:isolate';
35. Deferred Loading for Code Splitting
Supports deferred loading to load code only when needed.
import 'deferred_library.dart' deferred as deferredLibrary;
36. Built-in Collections Libraries
Has a rich collection library including List, Set, Map, and various utilities for collection manipulation.
void main() {
var list = [1, 2, 3];
var set = {1, 2, 3};
var map = {'a': 1, 'b': 2};
}
37. Function as First-Class Objects
Functions are first-class objects, meaning they can be stored in variables, passed as arguments, and returned from other functions.
void main() {
Function add = (int a, int b) => a + b;
}
38. Spread Operator with Null-aware (...?)
Allows adding elements from a collection only if the collection is not null.
void main() {
List<int>? numbers;
var list = [0, 1, 2, ...?numbers, 3];
print(list);
}
39. Super-Initializer Parameters
Allows initializing superclass parameters in a subclass constructor (Dart 2.17+).
class Base {
final int x;
Base(this.x);
}
class Derived extends Base {
Derived(super.x);
}
void main() {
var obj = Derived(5);
print(obj.x);
}
40. Enhanced Enums
Extends enum capabilities with additional properties and methods (Dart 2.17+).
enum Color {
red,
green,
blue;
void describe() {
print('This is color $name');
}
}
void main() {
Color.red
41. No-name Declarations
Supports no-name declarations for variables that are only used once.
void main() {
final _ = someFunction();
print(_);
}
42. Zones
Provides an execution context to handle errors and propagate information automatically.
void main() {
runZonedGuarded(() {
}, (error, stackTrace) {
print('Caught error in zone: $error');
});
}
43. runZonedGuarded
Updates and replaces runZoned for better error handling.
void main() {
runZonedGuarded(() {
}, (error, stackTrace) {
print('Caught error: $error');
});
}
![[Indonesian] Prinsip Hidup AhliWeb Versi 2](/_next/image?url=https%3A%2F%2Fcdn.hashnode.com%2Fuploads%2Fcovers%2F6608de5cd660c76b8626061d%2F8a6aa718-4fc2-493c-86ad-5f26b1dcaf99.png&w=3840&q=75)
![[Indonesian] Memahami Wiki AW Non-Commercial License 1.0](/_next/image?url=https%3A%2F%2Fcdn.hashnode.com%2Fuploads%2Fcovers%2F6608de5cd660c76b8626061d%2Ff2bf3812-7079-4c4f-a6f9-fe2ba1c0aa06.png&w=3840&q=75)
