Dart Programming Basics: Variables, Data Types, final, const & var (2026 Guide)

Dart is the programming language behind Flutter, Google’s cross-platform UI framework for building applications for Android, iOS, web, and desktop.

Before learning advanced Flutter widgets, state management, networking, and application architecture, it is important to understand Dart variables and data types.

Variables allow applications to store and manage information, while data types determine what kinds of values those variables can hold.

Dart also provides powerful language features such as type inference, sound null safety, compile-time constants, and immutable references that help developers write reliable and maintainable applications.

In this beginner-friendly tutorial, we’ll explore Dart programming fundamentals through practical examples and build a small Flutter application that demonstrates how variables and data types work in real mobile development.

This is Flutter Article 5 in the Moiks Developer Blog Flutter Tutorials series.

What You’ll Learn

By the end of this tutorial, you’ll understand:

  • What variables are in Dart.
  • How to declare and initialize variables.
  • The differences between var, final, and const.
  • Dart’s built-in data types.
  • How type inference works.
  • How to use nullable and non-nullable variables.
  • When to use late variables.
  • The differences between Object, Object?, and dynamic.
  • How collections store multiple values.
  • How Dart records and patterns work.
  • How to use variables inside Flutter widgets.
  • Common mistakes, testing techniques, and best practices.

1. What Is Dart Programming Language?

Dart is a modern, object-oriented, strongly typed programming language developed by Google.

It is the primary programming language used to build Flutter applications.

Dart supports features such as:

  • Static typing with type inference.
  • Sound null safety.
  • Object-oriented programming.
  • Asynchronous programming using Future and Stream.
  • Generics and collections.
  • Pattern matching and records.
  • Compile-time constants.
  • Just-in-time compilation for supported development workflows.
  • Ahead-of-time compilation for supported production targets.

One of Dart’s advantages is its integration with Flutter’s development workflow, including hot reload.

Example: Your First Dart Program

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

Output:

Welcome to Dart Programming!

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

The print() function displays a value in the console.

You can execute this example using DartPad:

https://dartpad.dev

Alternatively, create a file named main.dart and run:

dart run main.dart

2. What Are Variables in Dart?

A variable is a named reference used to access a value in a program.

For example, a Flutter application might store a user’s name, age, account balance, or selected theme.

void main() {
  String userName = 'Krishna';
  int age = 28;
  double accountBalance = 1250.75;
  bool isLoggedIn = true;

  print(userName);
  print(age);
  print(accountBalance);
  print(isLoggedIn);
}

Output:

Krishna
28
1250.75
true

Each variable has a type that determines which values can be assigned to it.

For example, an int variable stores integer values, while a String variable stores text.

Dart is statically typed, which means its type system checks assignments and operations for compatibility.

3. How to Declare Variables in Dart

There are several ways to declare variables.

Explicit Type Declaration

String appName = 'Moiks Flutter';
int downloadCount = 150;
double rating = 4.8;
bool isPremium = false;

Here, the variable types are explicitly declared.

Using var

var appName = 'Moiks Flutter';
var downloadCount = 150;
var rating = 4.8;
var isPremium = false;

Dart automatically infers the type from the assigned value.

For example:

var appName = 'Moiks Flutter';

Dart infers that appName is a String.

The variable cannot later hold an incompatible type.

var appName = 'Flutter';

// Compilation error:
appName = 100;

Important: var does not mean the variable is dynamically typed.

Once Dart infers its static type, normal type checking applies.

4. Dart Built-in Data Types

Dart provides several built-in types for storing different kinds of information.

Data typePurposeExample
intInteger numbers42
doubleDecimal numbers4.75
numInteger or double10, 3.5
StringText'Flutter'
boolBoolean valuestrue
ListOrdered collection[1, 2, 3]
SetUnique elements{1, 2, 3}
MapKey-value pairs{'name': 'Dart'}
RecordFixed-shape grouped values('Dart', 3)
NullNull value typenull

Let’s understand the most frequently used types.

5. Integer Data Type — int

The int type represents integer values.

void main() {
  int userAge = 25;
  int totalDownloads = 10000;
  int remainingLives = 3;

  print(userAge);
  print(totalDownloads);
  print(remainingLives);
}

Integers are commonly used for counters, indexes, quantities, and identifiers.

Arithmetic Operations

void main() {
  int a = 20;
  int b = 6;

  print(a + b);  // 26
  print(a - b);  // 14
  print(a * b);  // 120
  print(a / b);  // 3.333...
  print(a ~/ b); // 3
  print(a % b);  // 2
}

The / operator performs division and returns a double.

The ~/ operator performs truncating division and returns an integer.

The % operator calculates the remainder.

6. Decimal Data Type — double

The double type represents double-precision floating-point numbers.

void main() {
  double productPrice = 499.99;
  double appRating = 4.7;
  double screenWidth = 393.0;

  print(productPrice);
  print(appRating);
  print(screenWidth);
}

Doubles are useful for measurements, UI dimensions, animation values, and approximate numeric calculations.

Important: Floating-Point Precision

Binary floating-point arithmetic can produce small rounding differences.

void main() {
  print(0.1 + 0.2);
}

The result may be:

0.30000000000000004

For financial calculations requiring exact decimal amounts, consider representing money in integer minor units, such as paise or cents, or using a suitable decimal arithmetic library.

Do not assume double is appropriate for every financial calculation.

7. Using the num Data Type

The num type is a common numeric supertype of int and double.

void main() {
  num value = 100;

  print(value);

  value = 99.5;

  print(value);
}

Output:

100
99.5

Use num when an API genuinely needs to accept both integer and floating-point values.

Prefer int or double when the expected numeric representation is known.

8. String Data Type

A String represents text.

void main() {
  String firstName = 'Moiks';
  String lastName = "Studio";

  print(firstName);
  print(lastName);
}

Dart supports single and double quotation marks.

String Interpolation

String interpolation allows variables and expressions to be inserted into text.

void main() {
  String appName = 'Flutter';
  int version = 3;

  print('Welcome to $appName');
  print('Major version: $version');
  print('Next major version: ${version + 1}');
}

Output:

Welcome to Flutter
Major version: 3
Next major version: 4

Use $variable for simple variable references and ${expression} for more complex expressions.

Multiline Strings

void main() {
  String description = '''
Flutter supports
Android and iOS
development using Dart.
''';

  print(description);
}

Useful String Operations

void main() {
  String title = 'Flutter Development';

  print(title.length);
  print(title.toUpperCase());
  print(title.toLowerCase());
  print(title.contains('Flutter'));
  print(title.replaceAll('Flutter', 'Dart'));
}

String operations are frequently used in search, forms, validation, and UI formatting.

9. Boolean Data Type — bool

The bool type represents true or false.

void main() {
  bool isLoggedIn = true;
  bool isPremiumUser = false;

  print(isLoggedIn);
  print(isPremiumUser);
}

Booleans are useful for conditional application behavior.

For example:

void main() {
  bool isPremium = true;

  if (isPremium) {
    print('Premium features enabled');
  } else {
    print('Free version enabled');
  }
}

Unlike some languages, Dart does not implicitly convert integers or strings into Boolean values.

Conditions must evaluate to bool.

10. Understanding var in Dart

The var keyword lets Dart infer a variable’s type.

void main() {
  var name = 'Flutter';
  var age = 10;
  var rating = 4.9;
  var isActive = true;

  print(name.runtimeType);
  print(age.runtimeType);
  print(rating.runtimeType);
  print(isActive.runtimeType);
}

Output:

String
int
double
bool

When Should You Use var?

Use var when the type is obvious from the initializer.

var userName = 'Alex';
var totalItems = 20;

An explicit type can be useful when it communicates important intent.

num amount = 100;

Dart’s effective style guidance generally favors inferred types for local variables when the type is already clear.

11. Understanding final in Dart

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

void main() {
  final userId = 'USER_1001';

  print(userId);
}

Attempting to reassign the variable causes a compile-time error.

final userId = 'USER_1001';

// Error:
userId = 'USER_1002';

final with Runtime Values

A final variable can be initialized using a value calculated at runtime.

void main() {
  final currentTime = DateTime.now();

  print(currentTime);
}

This works because final does not require compile-time constant initialization.

final Does Not Automatically Make Objects Immutable

Consider:

void main() {
  final numbers = <int>[1, 2, 3];

  numbers.add(4);

  print(numbers);
}

Output:

[1, 2, 3, 4]

The variable cannot be reassigned, but the referenced list remains mutable.

This distinction is especially important when working with Flutter state.

12. Understanding const in Dart

The const keyword creates a compile-time constant variable or constant value.

void main() {
  const appName = 'Moiks Flutter';
  const maxAttempts = 3;
  const piValue = 3.14159;

  print(appName);
  print(maxAttempts);
  print(piValue);
}

A const variable must be initialized using a compile-time constant expression.

const with Collections

void main() {
  const supportedPlatforms = [
    'Android',
    'iOS',
  ];

  print(supportedPlatforms);
}

You cannot modify this constant list.

const platforms = ['Android', 'iOS'];

// Runtime error if executed:
platforms.add('Web');

The attempted mutation throws an UnsupportedError because the constant collection is unmodifiable.

const with Runtime Values

This is invalid:

// Compilation error:
const currentTime = DateTime.now();

DateTime.now() is evaluated at runtime.

Use final instead.

13. Dart final vs const vs var

Understanding these keywords is essential for writing clean Dart and Flutter code.

Featurevarfinalconst
Type inferenceYesYesYes
ReassignmentAllowedNot allowedNot allowed
Runtime initializationYesYesNo
Compile-time constant requiredNoNoYes
Mutable referenced objects possibleYesYesConstant values are immutable

Practical Example

void main() {
  var counter = 0;
  final startedAt = DateTime.now();
  const maximumCount = 10;

  counter++;

  print(counter);
  print(startedAt);
  print(maximumCount);
}

Best Practice

Use const for compile-time constants.

Use final for values that should be assigned only once.

Use var for local variables that need reassignment.

Choose based on intended behavior, not merely personal preference.

14. Understanding late Variables

Dart requires non-nullable variables to be initialized before they are used.

The late modifier allows initialization to happen later.

late String userName;

void main() {
  userName = 'Flutter Developer';

  print(userName);
}

Lazy Initialization

A late variable with an initializer is initialized when first accessed.

String loadConfiguration() {
  print('Loading configuration...');
  return 'Production';
}

void main() {
  late final configuration = loadConfiguration();

  print('Application started');

  print(configuration);
}

Output:

Application started
Loading configuration...
Production

Important Warning

Accessing an uninitialized late variable causes a runtime error.

Use late only when delayed initialization is intentional and safe.

Avoid using it simply to silence initialization errors.

15. Understanding Dart Null Safety

Dart uses sound null safety.

By default, a variable with a non-nullable type cannot contain null.

String userName = 'Flutter';

This variable cannot be assigned null.

Nullable Variables

Add ? to allow a variable to contain null.

String? userName;

Now the variable can contain either a String or null.

void main() {
  String? userName;

  print(userName);

  userName = 'Moiks';

  print(userName);
}

Null-Aware Access

Use ?. to access a property only when the value is non-null.

void main() {
  String? name;

  print(name?.length);
}

Output:

null

Null-Coalescing Operator

The ?? operator provides a fallback value.

void main() {
  String? displayName;

  String result = displayName ?? 'Guest';

  print(result);
}

Output:

Guest

Null Assertion Operator

The ! operator tells Dart to treat a nullable expression as non-null.

String? name = 'Flutter';

print(name!.length);

Use ! carefully.

If the value is actually null, the operation throws at runtime.

Prefer explicit null checks, null-aware operators, or appropriate default values.

16. Object, Object? and dynamic

Dart provides different ways to represent values when the exact type is not known.

Object

An Object variable can reference non-null objects of different types.

void main() {
  Object value = 'Flutter';

  value = 100;
  value = true;

  print(value);
}

However, Dart still enforces static type checking when accessing members.

Object?

Object? allows any object reference, including null.

Object? value = null;

value = 'Dart';
value = 25;

dynamic

dynamic allows operations to bypass many static type checks.

void main() {
  dynamic value = 'Flutter';

  value = 100;

  print(value);
}

Be careful when invoking members on dynamic values.

dynamic value = 100;

// May throw at runtime:
value.toUpperCase();

Best Practice

Prefer specific types.

Use Object? when a value may have different types and requires runtime validation.

Use dynamic only when its flexibility is genuinely necessary, such as at certain dynamic data boundaries.

17. Dart Lists

A List stores an ordered collection of values.

void main() {
  List<String> platforms = [
    'Android',
    'iOS',
    'Web',
  ];

  print(platforms);
  print(platforms.first);
  print(platforms.length);
}

Modifying a List

void main() {
  final languages = <String>[
    'Dart',
    'Kotlin',
  ];

  languages.add('Swift');

  print(languages);
}

Output:

[Dart, Kotlin, Swift]

The list remains mutable even though the variable is declared final.

Immutable List

const languages = <String>[
  'Dart',
  'Kotlin',
  'Swift',
];

A constant list cannot be modified.

18. Dart Sets

A Set stores unique elements.

void main() {
  final numbers = <int>{
    1,
    2,
    3,
  };

  numbers.add(2);

  print(numbers);
}

The set still contains only one occurrence of 2.

Sets are useful for tracking unique identifiers, selected filters, and distinct values.

19. Dart Maps

A Map stores key-value pairs.

void main() {
  final user = <String, Object>{
    'name': 'Alex',
    'age': 25,
    'premium': true,
  };

  print(user['name']);
  print(user['age']);
}

Maps are frequently used when working with JSON responses and application configuration.

Typed Maps

For more predictable values, use explicit key and value types.

final scores = <String, int>{
  'Level 1': 100,
  'Level 2': 250,
};

print(scores['Level 1']);

When handling real API responses, validate incoming data before assuming that it contains the expected types.

20. Dart Records and Pattern Destructuring

Modern Dart supports records, which group multiple typed values without defining a separate class.

void main() {
  final user = (
    name: 'Alex',
    age: 25,
    premium: true,
  );

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

Records are immutable and have a fixed shape.

Returning Multiple Values

(String, int) getUserInfo() {
  return ('Flutter Developer', 5);
}

void main() {
  final (name, experience) = getUserInfo();

  print(name);
  print(experience);
}

This uses record destructuring with a variable pattern.

Records and patterns are useful for small structured results and modern Dart control flow.

For larger business entities, dedicated classes or models may be more appropriate.

21. Practical Flutter Example: Dart Variables Dashboard

Let’s build a small Flutter application that demonstrates variables, final, const, nullable values, and state updates.

The application will display a user’s profile and allow the user to increase a points counter.

Create a Flutter Project

Run:

flutter create dart_variables_demo
cd dart_variables_demo

Open lib/main.dart and replace the generated code with the following:

import 'package:flutter/material.dart';

void main() {
  runApp(const VariablesDemoApp());
}

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

  @override
  Widget build(BuildContext context) {
    return MaterialApp(
      title: 'Dart Variables Demo',
      debugShowCheckedModeBanner: false,
      theme: ThemeData(
        colorScheme: ColorScheme.fromSeed(
          seedColor: const Color(0xFF004B64),
        ),
      ),
      home: const VariablesDashboard(),
    );
  }
}

class VariablesDashboard extends StatefulWidget {
  const VariablesDashboard({super.key});

  @override
  State<VariablesDashboard> createState() =>
      _VariablesDashboardState();
}

class _VariablesDashboardState
    extends State<VariablesDashboard> {
  static const int maximumPoints = 100;

  final String userName = 'Flutter Developer';
  final DateTime sessionStarted = DateTime.now();

  String? userBio;
  int points = 0;
  bool isPremium = false;

  void increasePoints() {
    setState(() {
      if (points < maximumPoints) {
        points += 10;
      }
    });
  }

  void togglePremium() {
    setState(() {
      isPremium = !isPremium;
    });
  }

  @override
  Widget build(BuildContext context) {
    return Scaffold(
      appBar: AppBar(
        title: const Text('Dart Variables'),
      ),
      body: Center(
        child: SingleChildScrollView(
          padding: const EdgeInsets.all(24),
          child: Column(
            mainAxisSize: MainAxisSize.min,
            children: [
              const Icon(
                Icons.account_circle,
                size: 90,
                color: Color(0xFF004B64),
              ),
              const SizedBox(height: 16),
              Text(
                userName,
                style: Theme.of(context)
                    .textTheme
                    .headlineSmall,
              ),
              const SizedBox(height: 8),
              Text(userBio ?? 'No bio available'),
              const SizedBox(height: 16),
              Text(
                'Points: $points / $maximumPoints',
              ),
              const SizedBox(height: 8),
              Text(
                'Account: '
                '${isPremium ? "Premium" : "Free"}',
              ),
              const SizedBox(height: 8),
              Text(
                'Session: '
                '${sessionStarted.hour}:'
                '${sessionStarted.minute.toString().padLeft(2, "0")}',
              ),
              const SizedBox(height: 24),
              FilledButton.icon(
                onPressed: points < maximumPoints
                    ? increasePoints
                    : null,
                icon: const Icon(Icons.add),
                label: const Text('Add 10 Points'),
              ),
              const SizedBox(height: 12),
              OutlinedButton(
                onPressed: togglePremium,
                child: const Text('Toggle Premium'),
              ),
            ],
          ),
        ),
      ),
    );
  }
}

Understanding the Application

This example demonstrates several Dart concepts.

const: maximumPoints is a compile-time constant.

final: userName and sessionStarted are assigned once.

Nullable String: userBio can contain a string or null.

int: points stores a whole-number score.

bool: isPremium controls the account label.

setState(): Notifies Flutter that local state has changed and the widget needs rebuilding.

Expected Result

The application displays:

  • User profile icon.
  • Flutter Developer name.
  • Optional biography.
  • Points counter.
  • Premium account status.
  • Session start time.
  • Add 10 Points button.
  • Toggle Premium button.

Each tap on Add 10 Points increases the counter until it reaches 100.

The points button is disabled once the maximum is reached.

Tapping Toggle Premium switches the displayed account type.

The same application code can run on Android and iOS.

22. Why final and const Matter in Flutter

Flutter applications are built using widgets.

Widgets are immutable configuration objects, and many widgets support const constructors.

Example:

const Text('Welcome to Flutter');

When all constructor arguments are compile-time constants, using const can allow Flutter to reuse canonicalized widget instances and avoid unnecessary allocations.

However, const does not automatically prevent every widget rebuild or guarantee better performance in every situation.

Example

Column(
  children: [
    const Text('Account Details'),
    const SizedBox(height: 16),
    Text('Points: $points'),
  ],
)

The heading and spacing are constant.

The points label is dynamic because its text changes with application state.

Best Practice

Use const when the constructor and its arguments support it.

Avoid forcing const onto values that depend on runtime state.

For performance-sensitive applications, profile real behavior using Flutter DevTools.

23. Testing Dart Variables and Flutter State

Dart supports automated unit tests, while Flutter provides widget testing tools.

Let’s test the variables dashboard.

Create or replace:

test/widget_test.dart

Add:

import 'package:flutter/material.dart';
import 'package:flutter_test/flutter_test.dart';
import 'package:dart_variables_demo/main.dart';

void main() {
  testWidgets(
    'Points increase when button is tapped',
    (WidgetTester tester) async {
      await tester.pumpWidget(
        const VariablesDemoApp(),
      );

      expect(
        find.text('Points: 0 / 100'),
        findsOneWidget,
      );

      await tester.tap(
        find.widgetWithText(
          FilledButton,
          'Add 10 Points',
        ),
      );

      await tester.pump();

      expect(
        find.text('Points: 10 / 100'),
        findsOneWidget,
      );
    },
  );

  testWidgets(
    'Premium status toggles correctly',
    (WidgetTester tester) async {
      await tester.pumpWidget(
        const VariablesDemoApp(),
      );

      expect(
        find.text('Account: Free'),
        findsOneWidget,
      );

      await tester.tap(
        find.text('Toggle Premium'),
      );

      await tester.pump();

      expect(
        find.text('Account: Premium'),
        findsOneWidget,
      );
    },
  );
}

Run:

flutter test

Also run:

flutter analyze

If you use a different project name, update the package import in the test file.

Additional Testing Recommendations

For production applications:

  • Test nullable values.
  • Test minimum and maximum numeric boundaries.
  • Test invalid user input.
  • Test state transitions.
  • Validate external data before assigning it to models.
  • Test important workflows on both Android and iOS.

24. Common Dart Variable Errors and Troubleshooting

Error 1: A Value Can’t Be Assigned to a Variable of Another Type

int age = 25;

// Error:
age = 'Twenty Five';

Solution: Assign a compatible value or explicitly convert data when appropriate.

For example:

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

When parsing untrusted input, prefer int.tryParse() and handle invalid values.

Error 2: Cannot Assign to a final Variable

final userName = 'Alex';

// Error:
userName = 'Sam';

Solution: Use a non-final variable if reassignment is intentional.

Error 3: const Requires a Constant Value

// Error:
const currentTime = DateTime.now();

Solution:

final currentTime = DateTime.now();

Error 4: Non-Nullable Variable Is Not Initialized

A non-nullable instance field must be initialized before use.

class User {
  String name;

  User(this.name);
}

Use constructor initialization, an initializer, or another valid initialization strategy.

Error 5: LateInitializationError

late String token;

void main() {
  print(token);
}

This throws at runtime because token has not been initialized.

Solution: Initialize the variable before accessing it, or redesign the code to avoid unsafe delayed initialization.

Error 6: Null Check Operator Used on a Null Value

String? name;

print(name!.length);

This throws at runtime.

Solution:

print(name?.length ?? 0);

Error 7: Unsupported Operation on a const List

const numbers = [1, 2, 3];

numbers.add(4);

This throws an UnsupportedError.

Solution: Use a mutable list when modifications are required.

25. Dart Variable Best Practices

Prefer Strong Typing

Use specific types when possible.

Avoid unnecessary use of dynamic.

Use final by Default for Stable References

When a variable does not need reassignment, final communicates that intention clearly.

Use const for Compile-Time Constants

Use const for fixed configuration values and eligible Flutter widgets.

Handle Nullable Values Explicitly

Use ?, ?., and ?? appropriately.

Avoid excessive null assertions.

Avoid Unnecessary late Variables

Prefer constructor initialization or direct initialization whenever possible.

Use Meaningful Variable Names

Good:

final userEmail = 'user@example.com';
final totalDownloads = 1500;

Less descriptive:

final x = 'user@example.com';
final y = 1500;

Keep Business Logic Separate from Widgets

For larger Flutter applications, move complex business calculations into dedicated classes or state management components.

Avoid Premature Optimization

Correct typing, clear state ownership, and predictable data flow matter more than micro-optimizing simple variable declarations.

26. Frequently Asked Questions

What is a variable in Dart?

A variable is a named reference that allows a program to access a value.

What is the difference between var and dynamic in Dart?

var uses static type inference when an initializer provides a type. dynamic relaxes static checking of operations and may defer errors until runtime.

What is the difference between final and const?

final allows assignment once, including runtime initialization. const requires a compile-time constant value.

Should I use var or final in Dart?

Use final when reassignment is unnecessary. Use var when a local variable needs to change.

Can a final List be modified?

Yes, if the referenced list is mutable. final prevents reassignment of the variable, not mutation of the object.

Is Dart a strongly typed language?

Yes. Dart has a sound static type system, with type inference and support for dynamic operations when explicitly requested.

What is null safety in Dart?

Null safety helps prevent accidental access to null values by making types non-nullable by default and requiring explicit nullable declarations.

What is late in Dart?

late supports delayed initialization and lazy initialization. Accessing an uninitialized late variable can cause a runtime error.

What are Dart records?

Records are immutable, fixed-shape values that can group multiple typed fields without defining a dedicated class.

Does Flutter use the same Dart data types on Android and iOS?

Yes. Shared Dart code uses the same language types on both platforms, although native interoperability and platform APIs may require additional conversions.

27. Conclusion

Understanding Dart variables and data types is essential for building reliable Flutter applications.

In this tutorial, we explored Dart’s built-in types, variable declarations, type inference, var, final, const, late, null safety, collections, and records.

We also built a practical Flutter variables dashboard and added widget tests to verify state updates.

The key lesson is simple: choose types and variable modifiers that clearly express how your data should behave.

These fundamentals will help you write safer Dart code, manage Flutter widget state, and prepare for more advanced programming concepts.

What’s Next in the Flutter Tutorials Series?

Flutter Article 6: Dart Operators Explained — Arithmetic, Comparison, Logical, Null-Aware & Cascade Operators

In the next tutorial, we’ll explore Dart operators with practical examples, including calculations, comparisons, Boolean expressions, null-aware operations, and cascade notation.

Continue learning Flutter and Dart at:

Moiks Developer Blog: https://moiks.com/blog/

Official Documentation and References

  1. Dart Language Overview — https://dart.dev/language
  2. Dart Variables — https://dart.dev/language/variables
  3. Dart Built-in Types — https://dart.dev/language/built-in-types
  4. Dart Null Safety — https://dart.dev/null-safety
  5. Dart Collections — https://dart.dev/language/collections
  6. Dart Records — https://dart.dev/language/records
  7. Dart Patterns — https://dart.dev/language/patterns
  8. Dart Effective Style — https://dart.dev/effective-dart/style
  9. Flutter State Management Fundamentals — https://docs.flutter.dev/data-and-backend/state-mgmt/ephemeral-vs-app
  10. Flutter Testing Overview — https://docs.flutter.dev/testing/overview
  11. DartPad — https://dartpad.dev/

Moiks Developer Blog — Practical Flutter, Dart, Android, and iOS development tutorials.

Explore Apps by Moiks Studio

Discover our Android apps and games on Google Play.

View All Android Apps →

Leave a Comment