If you are learning Dart for Flutter development, understanding variables and data types is one of the first concepts you should master. Variables allow your program to store information, while data types define what kind of information can be stored.

Dart provides several built-in data types, including int, double, String, bool, List, Set, and Map. It also supports type inference through var, constants through final and const, and null safety through nullable types.

In this guide, we will learn Dart variables and data types step by step with simple examples.

---

What Is a Variable in Dart?

A variable is a named location used to store a value.

For example:

String name = 'John';
int age = 25;
double price = 99.99;
bool isActive = true;

Here:

• name stores a string.
• age stores an integer.
• price stores a decimal number.
• isActive stores a Boolean value.

You can later use these variables in your program:

print(name);
print(age);

Output:

John
25

---

How to Declare a Variable in Dart

A variable can be declared by specifying its data type:

String name = 'John';

The general syntax is:

DataType variableName = value;

For example:

int age = 25;
double salary = 45000.50;
String city = 'Jaipur';
bool isLoggedIn = true;

Dart is case-sensitive, so name and Name are considered different identifiers.

---

Dart Built-in Data Types

Dart provides several commonly used data types.

Data Type	Description	Example
int	Whole numbers	25
double	Decimal numbers	25.50
num	Integers and decimals	10, 10.5
String	Text	'Hello'
bool	True or false	true
List	Ordered collection	[1, 2, 3]
Set	Unique collection	{1, 2, 3}
Map	Key-value collection	{'name': 'John'}
dynamic	Can hold different types	'Hello', 10

Let’s understand each type.

---

1. int Data Type

The int data type is used for whole numbers without decimal values.

int age = 25;
int count = 100;
int temperature = -5;

You can perform mathematical operations with integers:

int a = 10;
int b = 5;

print(a + b);
print(a - b);
print(a * b);

Output:

15
5
50

The int type is commonly used for:

• Age
• Quantity
• IDs
• Counters
• Scores
• Number of items

Example:

int productQuantity = 5;

---

2. double Data Type

The double data type is used for decimal numbers.

double price = 99.99;
double height = 5.8;
double percentage = 85.5;

Example:

double productPrice = 499.99;

print(productPrice);

Output:

499.99

double is useful for values such as:

• Prices
• Measurements
• Percentages
• Coordinates
• Calculations involving decimals

---

3. num Data Type

The num type can store both integers and decimal numbers.

num number = 10;

It can also store a decimal:

num number = 10.5;

For example:

num price = 100;

price = 99.99;

print(price);

num is useful when a value may be either an integer or a decimal.

---

4. String Data Type

A String is used to store text.

String name = 'John';
String city = 'Jaipur';
String message = 'Welcome to Dart';

Dart supports both single and double quotes:

String name1 = 'John';
String name2 = "John";

Both are valid.

String Interpolation

Dart makes it easy to insert variables into strings.

String name = 'John';
int age = 25;

print('My name is $name and I am $age years old.');

Output:

My name is John and I am 25 years old.

You can use ${} when an expression is required:

int age = 25;

print('Next year I will be ${age + 1}.');

Output:

Next year I will be 26.

---

5. bool Data Type

The bool type stores one of two values:

• true
• false

Example:

bool isLoggedIn = true;
bool isAdmin = false;

Boolean values are commonly used with conditions:

bool isLoggedIn = true;

if (isLoggedIn) {
  print('Welcome back!');
}

Output:

Welcome back!

Booleans are frequently used in Flutter for things such as:

• Login status
• Loading states
• Visibility
• Permission status
• Feature flags

---

6. List Data Type

A List stores multiple values in an ordered collection.

List<String> names = [
  'John',
  'Alex',
  'David'
];

You can access an item using its index:

print(names[0]);

Output:

John

Remember that Dart list indexes start at 0.

So:

Index 0 → John
Index 1 → Alex
Index 2 → David

You can add an item:

names.add('Michael');

You can find the number of items:

print(names.length);

You can also create a list of integers:

List<int> numbers = [10, 20, 30, 40];

---

7. Set Data Type

A Set is a collection that stores unique values.

Set<String> names = {
  'John',
  'Alex',
  'David'
};

If you attempt to add a duplicate value:

names.add('John');

the set will still contain only one John.

Sets are useful when duplicate values should not be stored.

Example:

Set<int> numbers = {1, 2, 3, 3, 4};

print(numbers);

The duplicate 3 is removed from the collection.

---

8. Map Data Type

A Map stores data using key-value pairs.

For example:

Map<String, dynamic> user = {
  'name': 'John',
  'age': 25,
  'city': 'Jaipur',
};

Here:

• name is a key.
• John is its value.
• age is a key.
• 25 is its value.

You can access a value using its key:

print(user['name']);

Output:

John

Maps are especially useful when working with JSON and API responses in Flutter applications.

---

9. dynamic Data Type

The dynamic type allows a variable to contain different types of values.

dynamic value = 'Hello';

value = 100;

value = true;

The same variable can hold a string, integer, or Boolean value.

However, dynamic should be used carefully because it reduces compile-time type checking.

For example:

dynamic value = 'Hello';

print(value.length);

This works because the current value is a string.

But if the value changes:

value = 100;

print(value.length);

this can cause a runtime error.

For most application code, using specific types is safer and easier to maintain.

---

var in Dart

Dart provides the var keyword for type inference.

Instead of:

String name = 'John';

you can write:

var name = 'John';

Dart automatically understands that name is a String.

Similarly:

var age = 25;

Dart determines that age is an int.

You can check this example:

var name = 'John';

print(name);

Once Dart infers the type, you cannot assign an unrelated type to the variable:

var name = 'John';

// name = 25; // Error

So var does not mean that the variable can contain any type. It means Dart determines the type automatically.

---

final Variables

The final keyword creates a variable that can only be assigned once.

final String name = 'John';

After assigning the value, you cannot change it:

final String name = 'John';

// name = 'Alex'; // Error

You can also allow Dart to infer the type:

final name = 'John';

final is useful when a value is determined at runtime but should not change afterward.

For example:

final currentTime = DateTime.now();

The current time is determined when the application runs, so final is appropriate.

---

const Variables

The const keyword is used for compile-time constants.

const double pi = 3.14159;

Another example:

const appName = 'My Flutter App';

Constants cannot be changed:

const appName = 'My App';

// appName = 'New App'; // Error

const is particularly common in Flutter because constant widgets can improve performance and make immutable values clear.

Example:

const Text('Hello');

---

Difference Between var, final, and const

These keywords are commonly confused by beginners.

Keyword	Can change?	Type inferred?	Value determined at runtime?
var	Yes	Yes	Yes
final	No	Yes	Yes
const	No	Yes	No

Example

var name = 'John';
name = 'Alex';

This is valid.

final name = 'John';
// name = 'Alex'; // Error

This is not valid because final cannot be reassigned.

const name = 'John';
// name = 'Alex'; // Error

This is also not valid.

A simple rule to remember is:

Use var when the value needs to change, final when it should be assigned only once, and const when it is a compile-time constant.

---

Nullable Variables and Null Safety

Dart uses sound null safety to help prevent unexpected null-related errors.

By default, a variable cannot contain null.

For example:

String name = 'John';

You cannot assign null to it:

// name = null; // Error

If a variable needs to accept null, use ?:

String? name;

Now the variable can contain either a string or null.

String? name;

name = 'John';
name = null;

---

Null-Aware Operators

Dart provides several useful operators for working with nullable values.

?. Operator

The ?. operator safely accesses a property or method.

String? name;

print(name?.length);

If name is null, Dart does not attempt to access length.

?? Operator

The ?? operator provides a default value when the value is null.

String? name;

print(name ?? 'Guest');

Output:

Guest

??= Operator

The ??= operator assigns a value only if the variable is currently null.

String? name;

name ??= 'Guest';

print(name);

Output:

Guest

These operators are particularly useful when working with API data and optional fields in Flutter applications.

---

Type Conversion in Dart

Sometimes you need to convert one data type into another.

String to int

Use int.parse():

String ageText = '25';

int age = int.parse(ageText);

print(age);

String to double

Use double.parse():

String priceText = '99.99';

double price = double.parse(priceText);

print(price);

int to String

Use .toString():

int age = 25;

String ageText = age.toString();

double to String

double price = 99.99;

String priceText = price.toString();

Type conversion is frequently required when handling user input from text fields or data received from APIs.

---

Checking a Variable’s Type

Dart provides the runtimeType property.

var name = 'John';

print(name.runtimeType);

Output:

String

Another example:

var age = 25;

print(age.runtimeType);

Output:

int

This can be useful when learning Dart or debugging code.

---

Type-Safe Collections

Dart allows you to specify the type of values that a collection can contain.

For example:

List<String> names = [
  'John',
  'Alex',
  'David'
];

This list can contain only strings.

Similarly:

List<int> numbers = [1, 2, 3];

A map can also specify types:

Map<String, int> scores = {
  'John': 90,
  'Alex': 85,
};

Type-safe collections make code easier to understand and help catch mistakes during development.

---

Variables Inside Functions

Variables can be declared inside functions.

void main() {
  String name = 'John';
  int age = 25;

  print(name);
  print(age);
}

These are local variables because they exist inside the main() function.

You can also create variables inside other functions:

void greet() {
  String message = 'Hello Dart';

  print(message);
}

The variable message is available only within that function.

---

Instance Variables

Variables can also belong to a class.

class User {
  String name = 'John';
  int age = 25;
}

Here, name and age are instance variables.

You can access them through an object:

void main() {
  User user = User();

  print(user.name);
  print(user.age);
}

This concept is important for object-oriented Dart and Flutter development.

---

A Practical Dart Variables Example

Here is a simple example combining multiple data types:

void main() {
  String name = 'John';
  int age = 25;
  double salary = 45000.50;
  bool isEmployee = true;

  List<String> skills = [
    'Dart',
    'Flutter',
    'Firebase'
  ];

  Map<String, dynamic> user = {
    'name': name,
    'age': age,
    'salary': salary,
    'isEmployee': isEmployee,
  };

  print('Name: $name');
  print('Age: $age');
  print('Salary: $salary');
  print('Employee: $isEmployee');
  print('Skills: $skills');
  print('User: $user');
}

This example demonstrates:

• String
• int
• double
• bool
• List
• Map
• Variables
• String interpolation

---

Best Practices for Dart Variables

Following good naming and type practices makes Dart code easier to maintain.

Use Descriptive Names

Avoid unclear names:

var x = 25;

Prefer:

var userAge = 25;

Use camelCase

Dart commonly uses lower camel case for variables:

String firstName = 'John';
double totalPrice = 500.50;
bool isUserLoggedIn = true;

Prefer Specific Types When They Improve Clarity

Instead of:

dynamic data;

use a specific type whenever possible:

String name;

Specific types provide better type checking and make your code easier to understand.

Use final When a Value Should Not Change

Instead of:

var userId = 101;

if the value should never be reassigned:

final userId = 101;

Use const for Compile-Time Constants

const maxLoginAttempts = 3;

This clearly communicates that the value is a constant.

---

Common Mistakes Beginners Make

Mistake 1: Assigning the Wrong Type

int age = '25';

This is incorrect because '25' is a String, not an int.

Correct:

int age = 25;

Or convert the string:

int age = int.parse('25');

Mistake 2: Trying to Change a final Variable

final name = 'John';

// name = 'Alex'; // Error

A final variable cannot be reassigned.

Mistake 3: Using dynamic Everywhere

Although dynamic is useful in some situations, using it unnecessarily removes some of Dart’s type safety.

Prefer:

String name = 'John';

over:

dynamic name = 'John';

when you know the value will always be a string.

Mistake 4: Forgetting Null Safety

If a value can be missing, declare it as nullable:

String? username;

Then handle the possibility of null appropriately.

---

Why Variables and Data Types Matter in Flutter

Dart variables and data types are used throughout Flutter applications.

For example, a Flutter application may store:

String userName;
int notificationCount;
bool isLoading;
double productPrice;
List<String> categories;
Map<String, dynamic> userData;

When working with APIs, databases, forms, Firebase, and application state, you will constantly use variables and different data types.

A strong understanding of these concepts will make Flutter development much easier.

---

Conclusion

Variables and data types are fundamental concepts in Dart programming. Variables allow you to store and manipulate information, while data types define what kind of information your variables contain.

The most important Dart types to understand are:

• int
• double
• num
• String
• bool
• List
• Set
• Map
• dynamic

You should also understand the difference between var, final, and const, as well as Dart’s null safety system.

Once you are comfortable with these concepts, you will have a strong foundation for learning Dart functions, classes, object-oriented programming, asynchronous programming, and eventually Flutter development.

Frequently Asked Questions

What is a variable in Dart?

A variable is a named storage location used to hold a value, such as a number, string, Boolean value, or collection.

What are the main data types in Dart?

Common Dart data types include int, double, num, String, bool, List, Set, Map, and dynamic.

What is the difference between var and dynamic?

var allows Dart to infer a variable’s type, while dynamic allows the variable to hold values of different types.

What is the difference between final and const?

Both prevent reassignment, but const is used for compile-time constants, while final can be assigned a value at runtime.

Can a Dart variable contain null?

Yes, but it must be explicitly declared as nullable using ?.

String? name;

Should I learn Dart variables before Flutter?

Yes. Understanding variables, data types, functions, classes, and null safety will make learning Flutter considerably easier.

Related Topics: Dart Programming, Dart Syntax, Dart Data Types, Dart Variables, Dart Null Safety, Flutter Development, Flutter for Beginners, Dart Tutorial