What are the data types and variables in Dart?

In Dart, a programming language developed by Google, there are several built-in data types available. Here are the most common data types in Dart:

When a variable is created in Dart, it has an associated data type, just like in other languages (C, Python, Java).

Data types for a variable specifies the following:

  1. The amount of space to be allocated
  2. Possible values
  3. The operation to be performed on the variable

Dart is a statically-typed language, which means that variables must have a specific data type assigned to them. Here’s an explanation of the basic data types in Dart, along with examples:

  1. Numbers:
    • int: Represents integer values.
    • Example: int age = 25;
    • double: Represents floating-point numbers with decimal places.
    • Example: double height = 1.75;
  2. Strings:
    • String: Represents a sequence of characters.
    • Example: String name = "John Doe";
  3. Booleans:
    • bool: Represents a logical value, either true or false.
    • Example: bool isStudent = true;
  4. Lists:
    • List: Represents an ordered collection of objects.
    • Example: List<int> numbers = [1, 2, 3, 4, 5];
  5. Maps:
    • Map: Represents a collection of key-value pairs.
    • Example: Map<String, int> studentGrades = {'John': 85, 'Jane': 92};
  6. Sets:
    • Set: Represents an unordered collection of unique objects.
    • Example: Set<int> uniqueNumbers = {1, 2, 3, 4, 5};
  7. Runes:
    • Runes: Represents a Unicode character or sequence of characters.
    • Example: Runes heart = Runes('\u2764');
  8. Symbols:
    • Symbol: Represents an identifier or operator that can be used in Dart.
    • Example: Symbol symbol = #mySymbol;

These examples showcase the different data types in Dart and demonstrate how to declare variables with their respective data types. Dart’s static typing helps catch errors during development and provides clarity on the type of data being used.

In Dart, variables can be categorized as either mutable or immutable, depending on whether their values can be changed after they are assigned. Here’s an explanation of mutable and immutable variables in Dart:

  1. Mutable Variables:
    • Mutable variables can have their values changed or reassigned after they are declared.
    • They are created using the var keyword or by explicitly specifying the type (e.g., int, String, etc.) followed by the variable name.
    • Mutable variables are declared using the var keyword, and their type is inferred based on the assigned value.
    • Example:
var count = 0; // Mutable variable
count = 10; // Value reassigned

Immutable Variables:

  • Immutable variables, once assigned a value, cannot be changed or reassigned.
  • They are created using the final or const keyword followed by the variable name.
  • Immutable variables must be initialized at the time of declaration.
  • final variables are evaluated at runtime and can have different values in different executions.
  • const variables are evaluated at compile-time and have the same value across all executions.
  • Example:
final pi = 3.14159; // Immutable variable
const greeting = 'Hello'; // Immutable variable

Immutable variables are useful when you have values that should not be modified, providing safety and ensuring that their values remain constant throughout the program. Mutable variables, on the other hand, offer flexibility for values that can change during the execution of the program. It’s important to choose the appropriate type of variable based on your requirements to write efficient and bug-free code.

Which data types are supported by Dart?

Dart Programming – Data Types

Is Dart dynamically typed or statically typed?

Is Dart a statically typed language? Yes, Dart 2 is statically typed. For more information, read about Dart’s type system. With its combination of static and runtime checks, Dart has a sound type system, which guarantees that an expression of one type cannot produce a value of another type.

What is type safe in Dart?

The Dart language is type safe: it uses a combination of static type checking and runtime checks to ensure that a variable’s value always matches the variable’s static type, sometimes referred to as sound typing.

What is future datatype in Dart?

What is a future? A future (lower case “f”) is an instance of the Future (capitalized “F”) class. A future represents the result of an asynchronous operation, and can have two states: uncompleted or completed. Note: Uncompleted is a Dart term referring to the state of a future before it has produced a value.

This website uses cookies to improve your experience. We'll assume you're ok with this, but you can opt-out if you wish. Accept Read More