Dart Syntax and Basic Concepts

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

1. Basic Declaration and Initialization
In Dart, variables can be declared using either explicit type annotations or the var keyword for type inference.
• Type Annotation:

String name = 'Alice';
int age = 30;

• Type Inference with var:

var city = 'New York'; // Inferred as String
var distance = 100;   // Inferred as int

2. Final, Const, and Late
Dart provides final, const, and late keywords for special variable declarations.
• final: For values that are set once and are immutable.

final String greeting = 'Hello';

• const: Declares compile-time constants.

const double pi = 3.14159;

💡
In dart there is no convention of using UPPERCASE letters when using constant variable. Instead dart uses k letter at the beginning of variable name.
ex:
kAnimationDuration = Default Animation Duration in Flutter
 
• late: Indicates delayed initialization.

late String description; // can be reassigned
late final int calculatedValue; // once set vaue
late String? nullOrStringValue; // must be either null or String value.

🚧
Using late keyword is risky, if variable does not assigned(even it’s nullable - String?) and being used, dart throws compile-time error.
 
Code examples

 	late String description;
  late String? nullableDescription;
  late dynamic dynamicValue;
  late var lateVariable;
  late final String finalVariable;
  late final String? nullableFinalVariable;

  ///! Error late variable must be initialized before use
  // print(description);
  // print(nullableDescription);

  description = 'Hello';
  print(description); //* OK => prints Hello

  nullableDescription = null;
  print(nullableDescription); //* OK => prints null

  nullableDescription = 'Hello';
  print(nullableDescription); //* OK => prints Hello

  dynamicValue = 'Hello';
  print(dynamicValue); //* OK => prints Hello
  dynamicValue = 1;
  print(dynamicValue); //* OK => prints 1
  dynamicValue = null;
  print(dynamicValue); //* OK => prints null

  lateVariable = 'Hello';
  print(lateVariable); //* OK => prints Hello
  lateVariable = 2; //* OK
  print(lateVariable); //* OK => prints 2

  finalVariable = 'Hello';
  print(finalVariable); //* OK => prints Hello
  // finalVariable = 2; //! Error => The final variable 'finalVariable' can only be set once.

  nullableFinalVariable = null;
  print(nullableFinalVariable); //* OK => prints null
  // nullableFinalVariable = 'Hello'; //! Error => The final variable 'nullableFinalVariable' can only be set once.

3. Dynamic vs Var
Dart offers two dynamic types: dynamic and var. The difference lies in type checking:
• dynamic: Explicitly disables static type checking. The type can change over time.

dynamic variable = 'Hello';
variable = 100; // Allowed

• var: Maintains static type checking. Once set, the type cannot change.

var variable = 'Hello';
// variable = 100; // Error: type 'int' is not assignable to type 'String'

Dart's Data Types

1. Numbers
• int: Represents integers.

int population = 150000;

• double: Handles floating-point numbers.

double price = 99.99;

2. Strings
Strings in Dart are sequences of UTF-16 code units.

String fullName = 'John Doe';
String multiline = '''
This is a
multiline string.
''';

String interpolation:

String greeting = "Hello, $fullName!";
String greeting = "Hello, ${getFullName()}";

String getFullName() => "YourName";

3. Booleans
The bool type represents Boolean values of true or false.

bool isVisible = false;
bool isEligible = age > 18;

4. Lists, Maps and Sets
• List: A collection of ordered objects. Dart infers the List’s type if not explicitly declared.

List<String> languages = ['Dart', 'JavaScript', 'Python'];
var numbers = [1, 2, 3, 4, 5]; // Inferred as List<int>

• Map: Key-value pairs collection.

Map<String, String> capitals = {
  'USA': 'Washington D.C.',
  'Japan': 'Tokyo',
};

• Set: A collection of unordered, unique objects.

Set<int> numbers= {1, 2, 3, 4, 5};
var numbers2 = {1, 2, 3, 4, 5}; // Inferred as Set<int>

💡
Dart also supports popular collection types like: Queue, Stack, LinkedList, Tuple etc

5. Runes and Symbols
• Runes: For representing Unicode characters in Dart.

Runes input = new Runes('\u{1F605}');
print(new String.fromCharCodes(input)); // 😅

• Symbols: Represent operators or identifiers used in Dart’s reflection capabilities.

6. Null Safety
Dart 2.12 introduced null safety, making all variables non-nullable by default.
• Nullable types with ?:

int? nullableAge;

• Null-aware operators (?., ??, ??=):

int? age;
print(age?.isEven); // Use ?. for safe access
// same as
if(age != null) {
	print(age.isEven) // prints boolean value
} else {
	print(age) // prints null
}

print(age ?? 0); // Default value if null

// same as 
if(age != null) {
	print(age); // age value
} else {
	print(0);
}

age ??= 10; // Assign value if null

// same as
if(age !=null) {} 
else { 
	age = 10;
}