Dart Variables and Dart data types
Dart Variables, Data Types, and Fundamentals
Introduction:
Explore the world of Dart programming language with our comprehensive tutorial. From understanding variables and data types to mastering fundamental concepts, this guide will equip you with the knowledge needed to build powerful and efficient applications. Whether you are a beginner or looking to enhance your Dart skills, dive into this lesson for step-by-step examples and explanations.
In Dart, variables are used to store and manipulate data, and data types define the type of data that a variable can hold.
Dart is a statically-typed language, meaning that the data type of a variable is known at compile-time.
Here’s an overview of Dart variables and data types:
Dart Variables:
Declaration and Initialization:
dart
// Variable declaration var variableName; // Variable initialization variableName = 10; // Combine declaration and initialization var anotherVariable = 'Hello, Dart!';
Dart Dynamic Typing:
Dart supports dynamic typing using the var keyword, where the type is inferred by the assigned value.
dart
var dynamicVariable = 3.14;
Data Type Inference:
Dart can also infer the type using the var keyword.
dart
var x = 10; // Dart infers that x is of type int
Final and Const:
final: A variable assigned with final can be set only once.
const: A variable assigned with const is a compile-time constant.
dart
final int finalVar = 42; const double pi = 3.14;
Data Types:
Dart Numbers:
int: Integer type.
double: Double-precision floating-point numbers.
dart
int age = 25; double piValue = 3.14159;
Strings:
Strings are sequences of characters.
They can be defined using single or double quotes.
dart
String message = 'Hello, Dart!';
Dart Booleans:
Represents true or false values.
dart
bool isDartFun = true;
Dart Lists:
Ordered collection of objects.
Lists in Dart are zero-indexed.
dart
List<int> numbers = [1, 2, 3, 4, 5];
Dart Maps:
Collection of key-value pairs.
dart
Map<String, dynamic> person = {
'name': 'John',
'age': 30,
'isStudent': false,
};Dart Sets:
Unordered collection of unique elements.
dart
Set<String> uniqueColors = {'red', 'green', 'blue'};Dart Runes and Symbols:
Runes represent a Unicode character.
Symbols represent identifiers.
dart
var heartSymbol = '\u2665';
This is a brief overview of Dart variables and data types. Keep in mind that Dart is a versatile language, and you can use these building blocks to create complex and dynamic programs.
complete example :Declaration and Initialization:
Let’s go through a step-by-step example of variable declaration and initialization in Dart:
dart
// Step 1: Declare a variable
var age;
void main() {
// Step 2: Initialize the variable
age = 25;
// Step 3: Print the variable
print('Age: $age');
// Step 4: Combine declaration and initialization
var name = 'John';
// Step 5: Print the combined variable
print('Name: $name');
// Step 6: Demonstrate dynamic typing
var dynamicVariable = 3.14;
// Step 7: Print the dynamically typed variable
print('Dynamic Variable: $dynamicVariable');
}Explanation:
Declare a Variable (var age;): In this step, we declare a variable named age without specifying its type. Dart will infer the type based on the value assigned later.
Initialize the Variable (age = 25;): Here, we assign the value 25 to the variable age. Dart now knows that age is of type int.
Print the Variable (print(‘Age: $age’);): We print the value of the variable age using string interpolation.
Combine Declaration and Initialization (var name = ‘John’;): In this step, we declare and initialize the variable name in a single line. Dart infers the type based on the assigned value.
Print the Combined Variable (print(‘Name: $name’);): We print the value of the variable name using string interpolation.
Demonstrate Dynamic Typing (var dynamicVariable = 3.14;): Here, we declare a variable named dynamicVariable using the var keyword without specifying the type. Dart will infer the type based on the assigned value 3.14, which is a double.
Print the Dynamically Typed Variable (print(‘Dynamic Variable: $dynamicVariable’);): We print the value of the dynamically typed variable using string interpolation.
When you run this Dart program, you should see the following output:
Age: 25
Name: John
Dynamic Variable: 3.14
This example demonstrates variable declaration, initialization, printing, and dynamic typing in Dart.
Dynamic Typing:step by step complete example
Let’s go through a step-by-step example of dynamic typing in Dart:
dart
void main() {
// Step 1: Dynamic Typing with var keyword
var dynamicVariable = 42; // Dart infers the type as int initially
// Step 2: Print the initial type
print('Initial Type: ${dynamicVariable.runtimeType}');
// Step 3: Change the type dynamically
dynamicVariable = 'Hello, Dart!'; // Now the type becomes String
// Step 4: Print the updated type
print('Updated Type: ${dynamicVariable.runtimeType}');
// Step 5: Demonstrate dynamic typing in a list
var dynamicList = [1, 'two', 3.0];
// Step 6: Print the list elements with their types
for (var element in dynamicList) {
print('Element: $element, Type: ${element.runtimeType}');
}
}Explanation:
Dynamic Typing with var (var dynamicVariable = 42;): In this step, we declare a variable named dynamicVariable using the var keyword without specifying a type. Dart initially infers the type as int based on the assigned value 42.
Print the Initial Type (print(‘Initial Type: ${dynamicVariable.runtimeType}’);): We print the initial type of the dynamicVariable using the runtimeType property.
Change the Type Dynamically (dynamicVariable = ‘Hello, Dart!’;): Here, we change the value of dynamicVariable to a string, causing Dart to dynamically update the type to String.
Print the Updated Type (print(‘Updated Type: ${dynamicVariable.runtimeType}’);): We print the updated type of the dynamicVariable after the type change.
Demonstrate Dynamic Typing in a List (var dynamicList = [1, ‘two’, 3.0];): We create a list with elements of different types (int, String, double).
Print List Elements with Their Types (for (var element in dynamicList) {…}): We use a loop to iterate through the elements of the list and print each element along with its type.
When you run this Dart program, you should see the following output:
Initial Type: int
Updated Type: String
Element: 1, Type: int
Element: two, Type: String
Element: 3.0, Type: double
This example demonstrates dynamic typing in Dart, where the type of a variable can change dynamically based on the assigned values.
Type Inference:complete example with explanation
Let’s go through a step-by-step example of type inference in Dart using the var keyword:
dart
void main() {
// Step 1: Type Inference with var keyword
var x = 10; // Dart infers the type of x as int
// Step 2: Print the inferred type
print('Type of x: ${x.runtimeType}');
// Step 3: Type Inference with double
var y = 3.14; // Dart infers the type of y as double
// Step 4: Print the inferred type of y
print('Type of y: ${y.runtimeType}');
// Step 5: Type Inference with String
var message = 'Hello, Dart!'; // Dart infers the type of message as String
// Step 6: Print the inferred type of message
print('Type of message: ${message.runtimeType}');
// Step 7: Type Inference with List<int>
var numbers = [1, 2, 3, 4, 5]; // Dart infers the type of numbers as List<int>
// Step 8: Print the inferred type of numbers
print('Type of numbers: ${numbers.runtimeType}');
}Explanation:
Type Inference with var (var x = 10;): In this step, we declare a variable named x and initialize it with the value 10. Dart infers the type of x as int based on the assigned value.
Print the Inferred Type (print(‘Type of x: ${x.runtimeType}’);): We print the inferred type of the variable x using the runtimeType property.
Type Inference with double (var y = 3.14;): Here, we declare a variable named y and initialize it with the value 3.14. Dart infers the type of y as double based on the assigned value.
Print the Inferred Type of y (print(‘Type of y: ${y.runtimeType}’);): We print the inferred type of the variable y using the runtimeType property.
Type Inference with String (var message = ‘Hello, Dart!’;): In this step, we declare a variable named message and initialize it with a string value. Dart infers the type of message as String.
Print the Inferred Type of message (print(‘Type of message: ${message.runtimeType}’);): We print the inferred type of the variable message using the runtimeType property.
Type Inference with List<int> (var numbers = [1, 2, 3, 4, 5];): Here, we declare a variable named numbers and initialize it with a list of integers. Dart infers the type of numbers as List<int>.
Print the Inferred Type of numbers (print(‘Type of numbers: ${numbers.runtimeType}’);): We print the inferred type of the variable numbers using the runtimeType property.
When you run this Dart program, you should see the following output:
Type of x: int
Type of y: double
Type of message: String
Type of numbers: List<int>
This example demonstrates type inference in Dart, where the type of a variable is automatically determined by the assigned value, and you can use the var keyword for concise and flexible variable declarations.
Final and Const:complete example with explanation
Let’s go through a step-by-step example of using final and const in Dart with explanations:
dart
void main() {
// Step 1: Using final keyword
final int finalVar = 42;
// finalVar = 24; // Uncommenting this line will result in a compilation error
// Step 2: Using const keyword
const double pi = 3.14;
// pi = 3.14159; // Uncommenting this line will result in a compilation error
// Step 3: Using final with a complex object
final List<int> finalList = [1, 2, 3];
// finalList.add(4); // Uncommenting this line will result in a compilation error
// Step 4: Using const with a constant list
const List<int> constList = [1, 2, 3];
// constList.add(4); // Uncommenting this line will result in a compilation error
// Step 5: Using const with a constant map
const Map<String, dynamic> constMap = {'name': 'Alice', 'age': 30};
// constMap['city'] = 'Wonderland'; // Uncommenting this line will result in a compilation error
// Step 6: Using const with a constant set
const Set<String> constSet = {'red', 'green', 'blue'};
// constSet.add('yellow'); // Uncommenting this line will result in a compilation error
// Step 7: Using const with a constant symbol
const Symbol symbol = #dartSymbol;
// Step 8: Print the values
print('Final Variable: $finalVar');
print('Pi Value: $pi');
print('Final List: $finalList');
print('Constant List: $constList');
print('Constant Map: $constMap');
print('Constant Set: $constSet');
print('Symbol: $symbol');
}Explanation:
Using final Keyword (final int finalVar = 42;): In this step, we declare a final variable named finalVar with the value 42. The final keyword means that the variable can be assigned only once.
Using const Keyword (const double pi = 3.14;): Here, we declare a constant variable named pi with the value 3.14. The const keyword is used for compile-time constants.
Using final with a Complex Object (final List<int> finalList = [1, 2, 3];): We declare a final list named finalList and initialize it with three integers. The final keyword applies to the reference, so you cannot reassign the variable to a new list.
Using const with a Constant List (const List<int> constList = [1, 2, 3];): In this step, we declare a constant list named constList. Since the list is declared as const, you cannot modify its contents.
Using const with a Constant Map (const Map<String, dynamic> constMap = {‘name’: ‘Alice’, ‘age’: 30};): We declare a constant map named constMap. Like the list, the map is declared as const, so you cannot add or remove key-value pairs.
Using const with a Constant Set (const Set<String> constSet = {‘red’, ‘green’, ‘blue’};): Here, we declare a constant set named constSet. Similar to the list and map, the set is declared as const, preventing modifications.
Using const with a Constant Symbol (const Symbol symbol = #dartSymbol;): We declare a constant symbol named symbol using the const keyword.
Print the Values (print(…);): We print the values of the final and constant variables, lists, maps, sets, and symbol.
When you run this Dart program, you should see the following output:
Final Variable: 42
Pi Value: 3.14
Final List: [1, 2, 3]
Constant List: [1, 2, 3]
Constant Map: {name: Alice, age: 30}
Constant Set: {red, green, blue}
Symbol: Symbol(“dartSymbol”)
This example demonstrates the use of final and const keywords in Dart for creating immutable variables, lists, maps, sets, and symbols.
Numbers data type:complete example with explanation
Let’s go through a step-by-step example of using the int and double data types for numbers in Dart:
dart
void main() {
// Step 1: Declare and Initialize an int
int age = 25;
// Step 2: Print the int value
print('Age: $age');
// Step 3: Declare and Initialize a double
double piValue = 3.14159;
// Step 4: Print the double value
print('Pi Value: $piValue');
// Step 5: Perform arithmetic operations
int x = 10;
int y = 5;
int sum = x + y;
double divisionResult = x / y;
// Step 6: Print the results of arithmetic operations
print('Sum: $sum');
print('Division Result: $divisionResult');
// Step 7: Demonstrate numerical constants
int hexValue = 0xDEADBEEF; // Hexadecimal literal
double exponentialValue = 1.42e5; // Exponential notation
// Step 8: Print the numerical constants
print('Hex Value: $hexValue');
print('Exponential Value: $exponentialValue');
}Explanation:
Declare and Initialize an int (int age = 25;):
In this step, we declare an int variable named age and initialize it with the value 25.
Print the int Value (print(‘Age: $age’);):
We print the value of the age variable.
Declare and Initialize a double (double piValue = 3.14159;):
Here, we declare a double variable named piValue and initialize it with the value 3.14159.
Print the double Value (print(‘Pi Value: $piValue’);):
We print the value of the piValue variable.
Perform Arithmetic Operations:
We declare two int variables (x and y) and perform addition (+) and division (/) operations.
Print the Results of Arithmetic Operations (print(‘Sum: $sum’); and print(‘Division Result: $divisionResult’);): We print the results of the addition and division operations.
Demonstrate Numerical Constants:
We declare an int variable (hexValue) using a hexadecimal literal (0xDEADBEEF).
We declare a double variable (exponentialValue) using exponential notation (1.42e5).
Print the Numerical Constants (print(‘Hex Value: $hexValue’); and print(‘Exponential Value: $exponentialValue’);): We print the values of the numerical constants.
When you run this Dart program, you should see the following output:
Age: 25
Pi Value: 3.14159
Sum: 15
Division Result: 2.0
Hex Value: 3735928559
Exponential Value: 142000.0
This example demonstrates the use of the int and double data types for representing integer and floating-point numbers in Dart. It also shows basic arithmetic operations and the use of numerical constants.
Strings data type:complete example with explanation
Let’s go through a step-by-step example of using the String data type in Dart:
dart
void main() {
// Step 1: Declare and Initialize a String
String greeting = 'Hello, Dart!';
// Step 2: Print the String value
print(greeting);
// Step 3: Concatenate Strings
String firstName = 'John';
String lastName = 'Doe';
String fullName = firstName + ' ' + lastName;
// Step 4: Print the concatenated String
print('Full Name: $fullName');
// Step 5: Interpolate Strings
int age = 30;
String message = 'My name is $fullName, and I am $age years old.';
// Step 6: Print the interpolated String
print(message);
// Step 7: Use Triple Quotes for Multi-line Strings
String multiLineString = '''
Dart is a powerful programming language.
It is used for building web, mobile, and desktop applications.
''';
// Step 8: Print the multi-line String
print(multiLineString);
// Step 9: Access Individual Characters
String word = 'Dart';
String firstLetter = word[0];
String lastLetter = word[word.length - 1];
// Step 10: Print individual characters
print('First Letter: $firstLetter');
print('Last Letter: $lastLetter');
}Explanation:
Declare and Initialize a String (String greeting = ‘Hello, Dart!’;):
In this step, we declare a String variable named greeting and initialize it with the value ‘Hello, Dart!’.
Print the String Value (print(greeting);):
We print the value of the greeting variable.
Concatenate Strings:
We declare two String variables (firstName and lastName).
We concatenate them using the + operator to create the fullName string.
Print the Concatenated String (print(‘Full Name: $fullName’);):
We print the concatenated fullName string using string interpolation.
Interpolate Strings:
We declare an int variable (age).
We interpolate the fullName and age variables into a new message string.
Print the Interpolated String (print(message);):
We print the interpolated message string.
Use Triple Quotes for Multi-line Strings (String multiLineString = ”’…”’;):
We use triple quotes to declare a multi-line string spanning multiple lines.
Print the Multi-line String (print(multiLineString);): We print the multi-line multiLineString.
Access Individual Characters:
We declare a String variable (word).
We access individual characters using square brackets ([]).
Print Individual Characters (print(‘First Letter: $firstLetter’); and print(‘Last Letter: $lastLetter’);):
We print the first and last letters of the word string.
When you run this Dart program, you should see the following output:
Hello, Dart!
Full Name: John Doe
My name is John Doe, and I am 30 years old.
Dart is a powerful programming language.
It is used for building web, mobile, and desktop applications.
First Letter: D
Last Letter: t
This example demonstrates the use of the String data type in Dart, including string declaration, concatenation, interpolation, handling multi-line strings, and accessing individual characters.
Booleans data type:complete example with explanation
Let’s go through a step-by-step example of using the bool (Boolean) data type in Dart:
dart
void main() {
// Step 1: Declare and Initialize Boolean Variables
bool isDartFun = true;
bool isProgrammingHard = false;
// Step 2: Print the Boolean Variables
print('Is Dart Fun? $isDartFun');
print('Is Programming Hard? $isProgrammingHard');
// Step 3: Perform Logical Operations
bool isStudent = true;
bool isWorking = false;
// Step 4: Logical AND Operation
bool isStudentAndWorking = isStudent && isWorking;
// Step 5: Logical OR Operation
bool isStudentOrWorking = isStudent || isWorking;
// Step 6: Logical NOT Operation
bool isNotStudent = !isStudent;
// Step 7: Print the Results of Logical Operations
print('Is Student and Working? $isStudentAndWorking');
print('Is Student or Working? $isStudentOrWorking');
print('Is Not Student? $isNotStudent');
}Explanation:
Declare and Initialize Boolean Variables (bool isDartFun = true; and bool isProgrammingHard = false;):
In this step, we declare and initialize two boolean variables: isDartFun is set to true, and isProgrammingHard is set to false.
Print the Boolean Variables (print(‘Is Dart Fun? $isDartFun’); and print(‘Is Programming Hard? $isProgrammingHard’);):
We print the values of the boolean variables using string interpolation.
Perform Logical Operations:
We declare two boolean variables: isStudent is set to true, and isWorking is set to false.
Logical AND Operation (bool isStudentAndWorking = isStudent && isWorking;): We perform a logical AND operation (&&) and store the result in the isStudentAndWorking variable.
Logical OR Operation (bool isStudentOrWorking = isStudent || isWorking;):
We perform a logical OR operation (||) and store the result in the isStudentOrWorking variable.
Logical NOT Operation (bool isNotStudent = !isStudent;):
We perform a logical NOT operation (!) and store the result in the isNotStudent variable.
Print the Results of Logical Operations:
We print the results of the logical AND, OR, and NOT operations using string interpolation.
When you run this Dart program, you should see the following output:
Is Dart Fun? true
Is Programming Hard? false
Is Student and Working? false
Is Student or Working? true
Is Not Student? false
This example demonstrates the use of the bool data type in Dart, including boolean variable declaration, logical AND/OR/NOT operations, and printing boolean values.
Lists data type :complete example with explanation
Let’s go through a step-by-step example of using the List data type in Dart:
dart
void main() {
// Step 1: Declare and Initialize a List of Integers
List<int> numbers = [1, 2, 3, 4, 5];
// Step 2: Print the List of Integers
print('Numbers: $numbers');
// Step 3: Access Elements of the List
int firstNumber = numbers[0];
int lastNumber = numbers[numbers.length - 1];
// Step 4: Print Individual Elements
print('First Number: $firstNumber');
print('Last Number: $lastNumber');
// Step 5: Modify Elements of the List
numbers[1] = 10;
// Step 6: Print the Modified List
print('Modified Numbers: $numbers');
// Step 7: Add Elements to the List
numbers.add(6);
// Step 8: Print the List with Added Element
print('Numbers with Added Element: $numbers');
// Step 9: Remove an Element from the List
numbers.remove(3);
// Step 10: Print the List after Removal
print('Numbers after Removal: $numbers');
// Step 11: Declare a List with Mixed Data Types
List<dynamic> mixedList = [1, 'two', 3.0, true];
// Step 12: Print the Mixed Data Type List
print('Mixed List: $mixedList');
}Explanation:
Declare and Initialize a List of Integers (List<int> numbers = [1, 2, 3, 4, 5];):
In this step, we declare a List named numbers containing integers and initialize it with a list of numbers.
Print the List of Integers (print(‘Numbers: $numbers’);):
We print the entire list using string interpolation.
Access Elements of the List:
We access individual elements of the list using square brackets ([]).
Print Individual Elements (print(‘First Number:
$firstNumber’); and print(‘Last Number: $lastNumber’);): We print the first and last elements of the list.
Modify Elements of the List (numbers[1] = 10;):
We modify the second element of the list by assigning a new value.
Print the Modified List (print(‘Modified Numbers:
$numbers’);): We print the list after modifying an element.
Add Elements to the List (numbers.add(6);):
We add a new element (6) to the end of the list.
Print the List with Added Element (print(‘Numbers with Added Element: $numbers’);):
We print the list after adding a new element.
Remove an Element from the List (numbers.remove(3);):
We remove the element 3 from the list.
Print the List after Removal (print(‘Numbers after Removal: $numbers’);):
We print the list after removing an element.
Declare a List with Mixed Data Types (List<dynamic> mixedList = [1, ‘two’, 3.0, true];):
We declare a list named mixedList with elements of different data types.
Print the Mixed Data Type List (print(‘Mixed List: $mixedList’);):
We print the list with mixed data types.
When you run this Dart program, you should see the following output:
Numbers: [1, 2, 3, 4, 5]
First Number: 1
Last Number: 5
Modified Numbers: [1, 10, 3, 4, 5]
Numbers with Added Element: [1, 10, 3, 4, 5, 6]
Numbers after Removal: [1, 10, 4, 5, 6]
Mixed List: [1, two, 3.0, true]
This example demonstrates the use of the List data type in Dart, including list declaration, accessing elements, modifying the list, adding and removing elements, and working with lists containing mixed data types.
Sets data type :complete example with explanation
Let’s go through a step-by-step example of using the Set data type in Dart:
dart
void main() {
// Step 1: Declare and Initialize a Set of Integers
Set<int> numbersSet = {1, 2, 3, 4, 5};
// Step 2: Print the Set of Integers
print('Numbers Set: $numbersSet');
// Step 3: Add Elements to the Set
numbersSet.add(6);
numbersSet.add(7);
// Step 4: Print the Set with Added Elements
print('Numbers Set with Added Elements: $numbersSet');
// Step 5: Remove an Element from the Set
numbersSet.remove(3);
// Step 6: Print the Set after Removal
print('Numbers Set after Removal: $numbersSet');
// Step 7: Check if an Element is in the Set
bool containsFive = numbersSet.contains(5);
// Step 8: Print the Result of Element Check
print('Does Set contain 5? $containsFive');
// Step 9: Declare a Set with Mixed Data Types
Set<dynamic> mixedSet = {1, 'two', 3.0, true};
// Step 10: Print the Mixed Data Type Set
print('Mixed Set: $mixedSet');
}Explanation:
Declare and Initialize a Set of Integers (Set<int> numbersSet = {1, 2, 3, 4, 5};): In this step, we declare a Set named numbersSet containing integers and initialize it with a set of numbers.
Print the Set of Integers (print(‘Numbers Set: $numbersSet’);): We print the entire set using string interpolation.
Add Elements to the Set (numbersSet.add(6); and numbersSet.add(7);): We add two new elements (6 and 7) to the set.
Print the Set with Added Elements (print(‘Numbers Set with Added Elements: $numbersSet’);): We print the set after adding new elements.
Remove an Element from the Set (numbersSet.remove(3);): We remove the element 3 from the set.
Print the Set after Removal (print(‘Numbers Set after Removal: $numbersSet’);): We print the set after removing an element.
Check if an Element is in the Set (bool containsFive = numbersSet.contains(5);): We check if the set contains the element 5 and store the result in a boolean variable.
Print the Result of Element Check (print(‘Does Set contain 5? $containsFive’);): We print the result of the element check.
Declare a Set with Mixed Data Types (Set<dynamic> mixedSet = {1, ‘two’, 3.0, true};): We declare a set named mixedSet with elements of different data types.
Print the Mixed Data Type Set (print(‘Mixed Set: $mixedSet’);): We print the set with mixed data types.
When you run this Dart program, you should see the following output:
Numbers Set: {1, 2, 3, 4, 5}
Numbers Set with Added Elements: {1, 2, 3, 4, 5, 6, 7}
Numbers Set after Removal: {1, 2, 4, 5, 6, 7}
Does Set contain 5? true
Mixed Set: {1, two, 3.0, true}
This example demonstrates the use of the Set data type in Dart, including set declaration, adding and removing elements, checking for element existence, and working with sets containing mixed data types.
Runes and Symbols data types:complete example with explanation
Let’s go through a step-by-step example of using the Runes and Symbol data types in Dart:
dart
void main() {
// Step 1: Using Runes to Represent a String with Unicode Characters
String unicodeString = '\u{1F60D} Hello, Dart!';
Runes runes = unicodeString.runes;
// Step 2: Print the Unicode String and Runes
print('Unicode String: $unicodeString');
print('Runes: $runes');
// Step 3: Convert Runes to a String
String runesToString = String.fromCharCodes(runes);
// Step 4: Print the Converted String
print('Converted String: $runesToString');
// Step 5: Using Symbol
Symbol dartSymbol = #dartSymbol;
// Step 6: Print the Symbol
print('Symbol: $dartSymbol');
}Explanation:
Using Runes to Represent a String with Unicode Characters (String unicodeString = ‘\u{1F60D} Hello, Dart!’;): In this step, we declare a string named unicodeString that contains a Unicode character represented by the escape sequence \u{1F60D} (a smiling face emoji).
Print the Unicode String and Runes (print(‘Unicode String: $unicodeString’); and print(‘Runes: $runes’);): We print the original Unicode string and the corresponding runes. The runes variable contains the Unicode code points of each character in the string.
Convert Runes to a String (String runesToString = String.fromCharCodes(runes);): We use the String.fromCharCodes constructor to convert the runes back to a string.
Print the Converted String (print(‘Converted String: $runesToString’);): We print the converted string, which should be the same as the original Unicode string.
Using Symbol (Symbol dartSymbol = #dartSymbol;): In this step, we declare a Symbol named dartSymbol using the # symbol literal.
Print the Symbol (print(‘Symbol: $dartSymbol’);): We print the dartSymbol.
When you run this Dart program, you should see the following output:
Unicode String: 😀 Hello, Dart!
Runes: (128525, 32, 72, 101, 108, 108, 111, 44, 32, 68, 97, 114, 116, 33)
Converted String: 😀 Hello, Dart!
Symbol: Symbol(“dartSymbol”)
This example demonstrates the use of the Runes data type for handling Unicode characters in a string and the Symbol data type for representing symbols in Dart.
Quiz about this lesson :20 questions with explanation
Here’s a quiz with 20 questions related to the Dart programming language, covering the concepts discussed in the examples.
Each question is followed by an explanation of the correct answer.
Quiz: Dart Programming Language
1-What keyword is used for declaring a variable with dynamic typing in Dart?
a) final
b) const
c) dynamic
d) var
Explanation: The correct answer is (d) var. The var keyword is used for dynamic typing in Dart.
2-Which Dart data type is used to represent whole numbers?
a) int
b) double
c) num
d) String
Explanation: The correct answer is (a) int. The int data type is used for representing whole numbers in Dart.
3-What is the result of the expression 5 / 2 in Dart?
a) 2.5
b) 2
c) 3
d) 2.0
Explanation: The correct answer is (a) 2.5. In Dart, the division of two integers results in a double.
4-How would you declare a constant double variable in Dart?
a) final double pi = 3.14;
b) const double pi = 3.14;
c) double const pi = 3.14;
d) const pi = 3.14;
Explanation: The correct answer is (b) const double pi = 3.14;. The const keyword is used for constant declarations.
5-What is the purpose of the runtimeType property in Dart?
a) Accessing the current time
b) Checking the type of a variable at runtime
c) Measuring the runtime of a program
d) Retrieving the current date
Explanation: The correct answer is (b) “Checking the type of a variable at runtime”. The runtimeType property is used to get the runtime type of an object.
6-Which Dart data type is used for representing floating-point numbers?
a) int
b) double
c) num
d) String
Explanation: The correct answer is (b) double. The double data type is used for representing floating-point numbers in Dart.
7-How do you declare a constant integer variable in Dart?
a) const int x = 42;
b) int const x = 42;
c) final int x = 42;
d) const x = 42;
Explanation: The correct answer is (a) const int x = 42;. The const keyword is used for constant declarations.
8-What does the += operator do in Dart?
a) Subtraction assignment
b) Multiplication assignment
c) Addition assignment
d) Division assignment
Explanation: The correct answer is (c) “Addition assignment”. The += operator adds the right operand to the left operand and assigns the result to the left operand.
9-How do you declare a list of integers in Dart?
a) List<int> numbers = [1, 2, 3];
b) List numbers = [1, 2, 3];
c) var numbers = [1, 2, 3];
d) Set<int> numbers = {1, 2, 3};
Explanation: The correct answer is (a) List<int> numbers = [1, 2, 3];. Using <int> specifies the type of elements in the list.
10-What is the result of the expression word[0] if word is a String?
a) Accessing the first character of the string
b) Concatenating the string with the number 0
c) Retrieving the length of the string
d) Accessing the last character of the string
Explanation: The correct answer is (a) “Accessing the first character of the string”. The index 0 accesses the first character of the string.
11-What is the purpose of the contains method in Dart lists?
a) Checking if a list contains a specific element
b) Checking the length of a list
c) Concatenating two lists
d) Removing an element from a list
Explanation: The correct answer is (a) “Checking if a list contains a specific element”. The contains method checks whether a specified element is present in the list.
12-How do you declare a set of mixed data types in Dart?
a) Set<int, String, bool> mixedSet = {1, ‘two’, true};
b) Set<dynamic> mixedSet = {1, ‘two’, true};
c) Set mixedSet = {1, ‘two’, true};
d) Set<num> mixedSet = {1, ‘two’, true};
Explanation: The correct answer is (b) Set<dynamic> mixedSet = {1, ‘two’, true};. Using dynamic allows the set to contain elements of different data types.
13-What is the purpose of the add method in Dart sets?
a) Adding two sets together
b) Removing an element from a set
c) Checking if a set is empty
d) Adding a new element to a set
Explanation: The correct answer is (d) “Adding a new element to a set”. The add method is used to add a new element to the set.
14-How would you remove an element from a set in Dart?
a) set.remove(3);
b) set.delete(3);
c) set.exclude(3);
d) set.discard(3);
Explanation: The correct answer is (a) set.remove(3);. The remove method is used to remove an element from a set.
15-What does the Symbol data type represent in Dart?
a) Strings
b) Numbers
c) Functions
d) Symbols
Explanation: The correct answer is (d) “Symbols”. The Symbol data type represents symbols in Dart.
16-What is the purpose of the runes property in Dart strings?
a) Running a function on the string
b) Accessing individual characters in the string
c) Checking if the string contains a specific character
d) Representing the length of the string
Explanation: The correct answer is (b) “Accessing individual characters in the string”. The runes property provides the Unicode code points of characters in a string.
17-How do you represent a multi-line string in Dart?
a) ‘This is a multi-line string.’
b) “This is a multi-line string.”
c) ”’This is a multi-line string.”’
d) “This is\na multi-line\nstring.”
Explanation: The correct answer is (c) ”’This is a multi-line string.”’. Triple single or double quotes are used for multi-line strings.
18-What is the result of the expression 1 + ‘2’ in Dart?
a) Compilation error
b) 3
c) ’12’
d) 1
Explanation: The correct answer is (a) “Compilation error”. Dart does not allow implicit conversion between different data types.
19-What does the runtimeType property return for a Set in Dart?
a) Type of the set
b) Number of elements in the set
c) Runtime of the program
d) Length of the set
Explanation: The correct answer is (a) “Type of the set”. The runtimeType property returns the type of the object.
20-Which operator is used for addition assignment in Dart?
a) +=
b) -=
c) *=
d) /=
Explanation: The correct answer is (a) +=. The += operator is used for addition assignment in Dart.
obviously like your web site but you need to check the spelling on several of your posts. A number of them are rife with spelling problems and I find it very bothersome to tell the truth nevertheless I will definitely come back again.