Dart - Data Types

Like other languages (C, C++, Java), whenever a variable is created, each variable has an associated data type. In Dart language, there are the types of values that can be represented and manipulated in a programming language. 

In this article, we will learn about Dart Programming Language Data Types.

Data Types in Dart

The data type classification is as given below: 

1. Number (int, double, num, BigInt)

The number in Dart Programming is the data type that is used to hold the numeric value. Dart numbers can be classified as: 

• int: It is used to represent whole numbers (64-bit Max).
• double: It is used to represent 64-bit precise floating-point numbers.
• num: It is an inherited data type of the int and double types.
• BigInt: For very large integers that exceed int limits, use BigInt.

Declaring Integer (int)

// Method 1: Declaring an integer variable int age = 25; // Method 2: Nullable integer declaration int? count; // Method 3: Using 'var' keyword (automatically detects type) // Dart infers it as int var year = 2024; 

Declaring Decimal Numbers (double)

// Method 1: Explicit declaration double pi = 3.1415; // Method 2: Nullable double double? percentage; // Method 3: Using 'var' keyword // Dart infers it as double var temperature = 36.6; 

Using num for Both Integer and Decimal Values

num value = 10; // Allowed because 'num' supports both int and double value = 10.5; 

Declaring Large Integers Using BigInt

BigInt bigNumber = BigInt.parse('987654321098765432109876543210');

Below is the implementation of Numbers in Dart:

// Dart program to demonstrate // Number Data Type void main() {    // Declare an integer  int num1 = 2;    // Declare a double value  double num2 = 1.5;    // Print the integer and  // double values  print("$num1");  print("$num2");    // Perform addition  // (int + double results in a double)  var sum = num1 + num2;    // Print the sum of  // num1 and num2  print("Sum = $sum"); } 

 Output: 

2 1.5 Sum = 3.34

2. Strings (String )

It used to represent a sequence of characters. It is a sequence of UTF-16 code units. The keyword string is used to represent string literals. String values are embedded in either single or double-quotes.

Declaring String in Dart:

String str_name;

Below is the implementation of String data type in Dart:

// Dart program to demonstrate // String Data Type void main() {    // Declare and initialize a string  String string = "Geeks for Geeks";    // Declare two separate string variables  String str = 'Coding is ';  String str1 = 'Fun';    // Print the string variable  print(string);    // Concatenate and print the two strings  print(str + str1);     // Output: Coding is Fun } 

 
Output: 

GeeksforGeeks Coding is Fun

3. Boolean (bool)

It represents Boolean values true and false. The keyword bool is used to represent a Boolean literal in dart. 

Declaring Boolean in Dart

bool var_name;

Below is the implementation of Boolean in Dart:

// Dart program to demonstrate // Boolean Data Type void main() {    // Declare a boolean variable  // with a true value  bool val1 = true;    // Declare two string variables  String str = 'Coding is ';  String str1 = 'Fun';    // Compare the two strings  // (returns false)  bool val2 = (str == str1);    // Print boolean values  print(val1); // Output: true  print(val2); // Output: false } 

 
Output: 

true false

4. Lists (List)

List data type is similar to arrays in other programming languages. A list is used to represent a collection of objects. It is an ordered group of objects. 

Declaring List in Dart

There are multiple methods to declare List in Dart as mentioned below:

1. Variable Size List

// Empty growable list (preferred way) List<int> var_name1 = []; // Alternative: Declaring a list but not initializing (null safety requires ? if uninitialized) List<int>? var_name2; // Another way using List constructor List<int> var_name3 = List.empty(growable: true);

2. Fixed Size List

Fixed Size doesn't mean that we can't change the size of List, but we have predefined that the List has this much elements while declaring.

// Creates a fixed-size list with default values (0 in this case) List<int> var_name1 = List<int>.filled(5, 0); // Generates a fixed-size list where each element is `index * 2` List<int> var_name2 = List<int>.generate(5, (index) => index * 2);

Below is the implementation of List in Dart:

void main() {    // Creating a fixed-size list with  // 3 elements, each initialized to "default"  List<String> gfg = List<String>.filled(3, "default");    // Updating elements in the list  // (modifying values is allowed,  // but resizing is not)  gfg[0] = 'Geeks';  gfg[1] = 'For';  gfg[2] = 'Geeks';    // Printing the entire list to  // verify the changes  print(gfg); // Output: [Geeks, For, Geeks]    // Accessing and printing a  // specific element by its index  print(gfg[0]); // Output: Geeks } 

 
Output:

[Geeks, For, Geeks] Geeks

5. Sets (Set)

A Set is an unordered collection of unique elements.

Declaring Set in Dart

// Method 1: Using curly braces Set<int> uniqueNumbers = {1, 2, 3, 3, 4}; // Method 2: Using Set constructor Set<String> cities = Set(); cities.add("New York"); cities.add("London");

Below is the implementation of Set in Dart:

void main() {    // Declaring a Set of Strings containing country names  // Sets in Dart do not allow duplicate values  Set<String> countries = {"USA", "India", "USA"};   // Printing the set  // Since sets store only unique values, "USA" appears only once  print(countries);     // Output: {USA, India} } 

Output:

{USA, India}

6. Maps (Map)

The Map object is a key and value pair. Keys and values on a map may be of any type. It is a dynamic collection.

Declaring Map in Dart

While Declaring Map there can be only two cases one where declared Map is empty and another where declared Map contains elements in it. Both Cases are mentioned below:

1. Declaring Empty Map

// Method 1: Nullable Map declaration (can be assigned later) Map? mapName; // Method 2: Explicitly specifying key-value data types Map<String, int>? mapName2; // Method 3: Using the 'var' keyword with Map constructor // Defaults to Map<dynamic, dynamic> var mapName3 = Map(); // Method 4: Using a type-safe empty map
// Recommended approach
Map<String, int> mapName4 = {}; 

2. Declaring Map with Elements inside it.

/// Method 1: Using curly braces (preferred way) Map<String, String> myMap = { "First": "Geeks", "Second": "For", "Third": "Geeks", }; // Method 2: Using Map constructor Map<String, int> mapExample = Map(); mapExample["One"] = 1; mapExample["Two"] = 2; // Method 3: Using 'var' with implicit typing var anotherMap = { "A": 10, "B": 20, "C": 30, };

Below is the implementation of Map in Dart:

void main() {     // Creating a map using the preferred syntax  Map<String, String> gfg = {};     // Adding key-value pairs  gfg['First'] = 'Geeks';   gfg['Second'] = 'For';   gfg['Third'] = 'Geeks';    // Printing the map  print(gfg); } 

 
Output: 

{First: Geeks, Second: For, Third: Geeks}

7. Runes (Runes)

Dart utilizes Runes to represent Unicode characters that fall outside the standard ASCII character set. Since Dart strings are encoded in UTF-16, certain special characters such as emojis and non-English scripts must be expressed using runes.

Declaring Runes in Dart

String heart = '\u2665'; // Unicode for ♥

Below is the implementation of Runes in Dart:

void main() {  // Unicode for heart symbol (♥)  String heart = '\u2665';     // Unicode for smiley face (☺)  String smiley = '\u263A';    // Unicode for star symbol (★)  String star = '\u2605';    // Unicode for musical note (♫)  String musicNote = '\u266B';    // Printing all Unicode symbols  print(heart); // Output: ♥  print(smiley); // Output: ☺  print(star); // Output: ★  print(musicNote); // Output: ♫ } 

 
Output: 

♥ ☺ ★ ♫

8. Symbols (Symbol)

A Symbol in Dart is an immutable identifier that represents variable names, method names, or metadata at runtime. Symbols are primarily used in reflection and are helpful for dynamic programming.

Declaring Symbols in Dart

Symbol sym1 = #mySymbol; Symbol sym2 = Symbol("anotherSymbol");

Below is the implementation of Symbols in Dart:

void main() {    // Declaring a Symbol  // using the # syntax  Symbol sym1 = #dart;    // Declaring another Symbol  // with a different identifier  Symbol sym2 = #flutter;    // Printing the Symbols  print(sym1); // Output: Symbol("dart")  print(sym2); // Output: Symbol("flutter")    // Using Symbol in a map  // (useful for metadata or reflection)  Map<Symbol, String> symbolMap = {  #language: "Dart",  #framework: "Flutter",  };    // Printing values using Symbols as keys  print(symbolMap[#language]); // Output: Dart  print(symbolMap[#framework]); // Output: Flutter } 

Output: 

Symbol("dart") Symbol("flutter") Dart Flutter

9. Null (Null)

Dart uses null to indicate the absence of a value. It has null safety, which means variables must be either nullable (?) or initialized before they can be used.

Declaring Null in Dart

String? name; // Can be null

Below is the implementation of Null in Dart:

void main() {    // Nullable variables (can be assigned null)  String? name;  int? age;    // Assigning values  name = "GFG";  age = null;    // Checking for null values  // using null-aware operators  print(name ?? "Unknown"); // Output: Vinay  print(age ?? "No age provided"); // Output: No age provided    // Using null-aware access (?.)  // and null assertion (!)  int? length = name?.length;    print(length);     // Output: 5 } 

Output: 

GFG No age provided 3

Note: If the type of a variable is not specified, the variable’s type is dynamic. The dynamic keyword is used as a type annotation explicitly.