Dart is a modern, object-oriented programming language developed by Google. It is best known as the programming language used to build applications with Flutter. If you are planning to learn Flutter, understanding the basic syntax and structure of Dart is an important first step.

This guide explains Dart syntax in simple terms, including variables, data types, functions, comments, operators, control statements, classes, and the basic structure of a Dart program.

What Is Dart?

Dart is a client-optimized programming language designed for building fast applications across multiple platforms. It is commonly used with Flutter to create Android, iOS, web, desktop, and other applications from a single codebase.

Dart has a syntax that is relatively easy to learn, especially if you have experience with languages such as Java, C#, JavaScript, or C++.

A simple Dart program looks like this:

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

Here:

• void specifies that the function does not return a value.
• main() is the entry point of the Dart application.
• { } contains the statements executed by the function.
• print() displays text in the console.
• ; marks the end of a statement.

---

Basic Structure of a Dart Program

Every Dart application starts execution from the main() function.

void main() {
  print('Welcome to Dart');
}

The main() function is the starting point of a Dart application.

You can also write main() without explicitly specifying void:

main() {
  print('Hello World');
}

However, using void main() is a common and clear approach for beginner Dart programs.

Dart Program Structure

A basic Dart program generally contains:

1. Imports
2. Variables
3. Functions
4. Classes
5. The main() function
6. Program statements

For example:

import 'dart:math';

void main() {
  String name = 'Ankit';

  print('Hello $name');

  double number = sqrt(25);

  print(number);
}

The import statement allows your program to use functionality provided by another library.

---

Dart Statements

A statement is an instruction that tells Dart to perform an operation.

For example:

int age = 25;
print(age);

Each statement normally ends with a semicolon:

print('Hello');

Dart uses semicolons to indicate where statements end.

Multiple statements can be placed inside a block:

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

  print(name);
  print(age);
}

The curly braces {} define the block of code belonging to the function.

---

Dart Comments

Comments are used to explain code. Dart provides single-line and multi-line comments.

Single-Line Comments

Use // for a single-line comment:

// This is a comment
print('Hello Dart');

You can also place a comment after code:

int age = 25; // User age

Multi-Line Comments

Use /* */ for multiple lines:

/*
  This is a
  multi-line comment.
*/

print('Hello');

Documentation Comments

Dart also supports documentation comments using ///.

/// Calculates the total price.
double calculateTotal(double price, int quantity) {
  return price * quantity;
}

Documentation comments are especially useful when creating reusable classes, functions, and libraries.

---

Variables in Dart

Variables are used to store information in a program.

For example:

String name = 'John';
int age = 25;
double height = 5.9;
bool isStudent = true;

Dart supports type inference, so you can also use var:

var name = 'John';
var age = 25;

Dart automatically determines the type based on the assigned value.

---

Common Dart Data Types

Some commonly used Dart data types are:

Data Type	Example
int	int age = 25;
double	double price = 99.99;
num	num value = 10.5;
String	String name = 'John';
bool	bool active = true;
List	List<int> numbers = [1, 2, 3];
Set	Set<String> names = {'John', 'Alex'};
Map	Map<String, int> scores = {'John': 90};

String

Strings contain text:

String name = 'John';

Integer

Integers contain whole numbers:

int age = 25;

Double

double is used for decimal numbers:

double price = 49.99;

Boolean

Boolean values can be either true or false:

bool isLoggedIn = true;

---

var, final, and const

Dart provides several ways to declare variables.

Using var

var name = 'John';

The type is inferred automatically.

Using final

A final variable can only be assigned once:

final name = 'John';

You cannot later do:

name = 'Alex';

because the variable has already been assigned.

Using const

const is used for compile-time constants:

const pi = 3.14159;

A const value must be known at compile time.

Difference Between final and const

final currentTime = DateTime.now();

const appName = 'My App';

DateTime.now() is calculated at runtime, so it can be assigned to final but not directly to const.

---

Strings in Dart

Strings are used to represent text.

String firstName = 'John';
String lastName = "Smith";

Dart supports both single and double quotes.

You can combine strings using the + operator:

String firstName = 'John';
String lastName = 'Smith';

print(firstName + ' ' + lastName);

However, string interpolation is usually cleaner:

print('$firstName $lastName');

You can also use expressions inside ${}:

int age = 25;

print('Age next year: ${age + 1}');

---

Operators in Dart

Operators are symbols used to perform operations.

Arithmetic Operators

int a = 10;
int b = 3;

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

Common arithmetic operators include:

• + Addition
• - Subtraction
• * Multiplication
• / Division
• % Remainder
• ~/ Integer division

Example:

print(10 ~/ 3);

Output:

3

---

Comparison Operators

Comparison operators compare two values.

int age = 20;

print(age == 20);
print(age != 18);
print(age > 18);
print(age < 30);
print(age >= 20);
print(age <= 25);

They return a Boolean value: true or false.

---

Logical Operators

Dart supports logical operators such as:

&&
||
!

Example:

int age = 25;
bool hasId = true;

if (age >= 18 && hasId) {
  print('Access allowed');
}

Here, && means both conditions must be true.

---

Conditional Statements

Conditional statements allow your program to make decisions.

if Statement

int age = 20;

if (age >= 18) {
  print('Adult');
}

if-else Statement

int age = 16;

if (age >= 18) {
  print('Adult');
} else {
  print('Minor');
}

else-if

int marks = 75;

if (marks >= 90) {
  print('A+');
} else if (marks >= 75) {
  print('A');
} else if (marks >= 60) {
  print('B');
} else {
  print('C');
}

---

Switch Statement

The switch statement is useful when you need to compare one value against multiple possibilities.

String day = 'Monday';

switch (day) {
  case 'Monday':
    print('Start of the week');
    break;

  case 'Friday':
    print('Almost weekend');
    break;

  default:
    print('Another day');
}

Switch syntax can be particularly useful when working with fixed options or enum values.

---

Loops in Dart

Loops are used to execute code repeatedly.

for Loop

for (int i = 1; i <= 5; i++) {
  print(i);
}

Output:

1
2
3
4
5

while Loop

int count = 1;

while (count <= 5) {
  print(count);
  count++;
}

do-while Loop

int count = 1;

do {
  print(count);
  count++;
} while (count <= 5);

The do-while loop executes the code at least once before checking the condition.

---

Lists in Dart

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

You can add items:

names.add('Michael');

You can also use a loop:

for (String name in names) {
  print(name);
}

---

Maps in Dart

A Map stores data as key-value pairs.

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

You can access a value using its key:

print(user['name']);

Output:

John

Maps are commonly used when working with structured data and JSON responses in Flutter applications.

---

Functions in Dart

Functions are reusable blocks of code.

A simple function looks like this:

void greet() {
  print('Hello Dart');
}

You can call the function:

greet();

Function With Parameters

void greet(String name) {
  print('Hello $name');
}

greet('John');

Function With a Return Value

int add(int a, int b) {
  return a + b;
}

int result = add(10, 20);

print(result);

Output:

30

---

Arrow Functions

Dart supports a shorter syntax for simple functions.

Instead of:

int square(int number) {
  return number * number;
}

You can write:

int square(int number) => number * number;

Arrow functions are commonly used in Flutter for short operations and callbacks.

---

Classes and Objects

Dart is an object-oriented programming language. Classes are used to define the structure and behavior of objects.

Example:

class Person {
  String name;
  int age;

  Person(this.name, this.age);

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

You can create an object from the class:

void main() {
  Person person = Person('John', 25);

  person.introduce();
}

Classes are extremely important when developing Flutter applications because Flutter applications are largely built using classes and widgets.

---

Null Safety in Dart

Dart includes sound null safety to help prevent errors caused by unexpected null values.

Normally, a variable cannot contain null unless you explicitly allow it.

For example:

String name = 'John';

If you want the variable to accept null, use ?:

String? name;

You can safely check the value:

if (name != null) {
  print(name);
}

You can also use the null-aware operator:

print(name?.length);

Understanding null safety is important before working extensively with Flutter.

---

Common Dart Syntax Rules

When learning Dart, keep these basic syntax rules in mind:

1. Statements Usually End With a Semicolon

print('Hello');

2. Code Blocks Use Curly Braces

if (true) {
  print('Hello');
}

3. Variable Names Are Case-Sensitive

These are different variables:

String name = 'John';
String Name = 'Alex';

It is recommended to use lower camel case for variables and functions:

userName
totalPrice
getUserData()

4. Classes Usually Use Upper Camel Case

class UserProfile {
}

5. Use Meaningful Names

Instead of:

int x = 25;

Prefer:

int userAge = 25;

Meaningful names make code easier to understand and maintain.

---

A Complete Basic Dart Example

Here is a small Dart program that combines several concepts:

class Student {
  String name;
  int age;
  double marks;

  Student(this.name, this.age, this.marks);

  void displayInfo() {
    print('Name: $name');
    print('Age: $age');
    print('Marks: $marks');
  }
}

void main() {
  Student student = Student('John', 20, 85.5);

  student.displayInfo();

  if (student.marks >= 40) {
    print('Result: Pass');
  } else {
    print('Result: Fail');
  }
}

This example demonstrates:

• Classes
• Objects
• Variables
• Constructors
• Functions
• if-else
• Data types
• String interpolation
• The main() function

---

Dart Syntax vs Other Programming Languages

Developers familiar with Java, C#, or JavaScript may find Dart syntax relatively familiar.

For example, a Dart variable:

String name = 'John';

looks similar to strongly typed languages such as Java and C#.

Dart also supports features such as:

• Object-oriented programming
• Classes and inheritance
• Generics
• Functions as first-class objects
• Async and await
• Null safety
• Collections
• Extension methods
• Pattern matching

These features make Dart suitable for developing modern applications.

---

Why Learn Dart Syntax Before Flutter?

Flutter uses Dart for application logic, UI development, state management, networking, and many other tasks.

For example, a simple Flutter widget may look like:

class MyWidget extends StatelessWidget {
  const MyWidget({super.key});

  @override
  Widget build(BuildContext context) {
    return const Text('Hello Flutter');
  }
}

If you already understand Dart concepts such as classes, functions, variables, constructors, and null safety, Flutter code becomes much easier to understand.

Therefore, beginners should learn the fundamentals of Dart before moving deeply into Flutter.

---

Tips for Beginners Learning Dart

If you are new to Dart, focus on the fundamentals first.

Start With Basic Syntax

Learn:

• Variables
• Data types
• Operators
• Strings
• Comments

Learn Control Flow

Practice:

• if
• else
• switch
• for
• while

Understand Functions

Learn how to:

• Create functions
• Pass parameters
• Return values
• Use arrow functions

Learn Collections

Practice:

• Lists
• Sets
• Maps

Learn Object-Oriented Programming

Understand:

• Classes
• Objects
• Constructors
• Inheritance
• Encapsulation
• Abstract classes

Understand Null Safety

Learn how ?, !, ??, and ?. work.

Once these concepts are comfortable, moving to Flutter will be significantly easier.

---

Conclusion

Dart syntax is straightforward and beginner-friendly, especially for developers who have worked with languages such as Java, C#, JavaScript, or C++.

The most important concepts to learn first are variables, data types, functions, operators, conditions, loops, collections, classes, and null safety. These concepts form the foundation of Dart programming and are used extensively in Flutter development.

If your goal is to become a Flutter developer, learning Dart properly is one of the best places to start. Once you understand the basic Dart structure and syntax, you can move on to Flutter widgets, layouts, navigation, state management, APIs, Firebase, and complete application development.

Frequently Asked Questions

Is Dart easy to learn?

Yes. Dart has a clean and readable syntax and is relatively easy for beginners to learn, especially if they already know another programming language.

Is Dart required for Flutter?

Yes. Dart is the programming language used to develop Flutter applications, so understanding Dart is essential for Flutter development.

What is the entry point of a Dart program?

The main() function is the standard entry point of a Dart program.

Does Dart support object-oriented programming?

Yes. Dart supports object-oriented programming concepts including classes, objects, inheritance, constructors, interfaces, and polymorphism.

What should I learn after Dart basics?

After learning Dart fundamentals, you can start learning Flutter basics such as widgets, layouts, navigation, state management, forms, API integration, and Firebase.

Related Topics: Dart Programming, Flutter Development, Dart Variables, Dart Functions, Dart Classes, Flutter for Beginners, Dart Tutorial