Dart Variables and Types

Every variable in Dart has a type, whether you write it explicitly (int age = 25;) or let the compiler infer it (var age = 25;). Dart is statically typed, so once age is inferred as int, assigning a String to it later is a compile-time error, not a runtime surprise. This differs sharply from dynamically typed languages like plain JavaScript or Python, where a variable's type can silently change at runtime. Dart's type system exists to catch mistakes early, enable IDE autocompletion, and let the compiler generate faster machine code because it knows exactly what shape of data it's working with at every point in the program.

var declares a variable whose value can be reassigned later, with its type inferred once from the first assignment. final declares a variable that can be set only once — you can compute its value at runtime (like final now = DateTime.now();), but you can never reassign it afterward. const is stricter still: it must be a compile-time constant, meaning its value has to be known before the program even runs, so const pi = 3.14159; is valid but const now = DateTime.now(); is not, because DateTime.now() depends on runtime state. In practice, Dart style guides recommend preferring final for anything that doesn't need reassignment, and const whenever the value truly is fixed at compile time, since const objects are canonicalized and reused in memory rather than recreated.

Dart's core numeric types are int for whole numbers and double for 64-bit floating-point values; both are subtypes of the abstract num type. String represents text and supports both single and double quotes plus multi-line strings with triple quotes, and string interpolation via $variable or ${expression} inside the string. bool holds true or false only — Dart never treats 0, an empty string, or null as falsy the way JavaScript or Python does. Collection types round out the essentials: List<T> is an ordered, indexable sequence, Set<T> is an unordered collection with no duplicates, and Map<K, V> stores key-value pairs, and all three support generics so a List<int> is statically guaranteed to never accidentally contain a String.

When you write var name = 'Alice';, Dart's type inference engine looks at the right-hand side and permanently fixes name's static type as String — this is not the same as JavaScript's var, which allows the type to drift with each reassignment. Dart also has a special escape hatch, dynamic, which tells the compiler to skip static type checking for that variable entirely and defer all type checks to runtime; this is occasionally necessary when working with loosely typed JSON data, but it forfeits the compiler's safety net and IDE autocompletion, so idiomatic Dart code uses dynamic sparingly and prefers explicit types or var with inference wherever possible.