Blog

The String data type represents a sequence of characters. A Dart string is a sequence of UTF 16 code units.

String values in Dart can be represented using either single or double or triple quotes. Single line strings are represented using single or double quotes. Triple quotes are used to represent multi-line strings.

The syntax of representing string values in Dart is as given below −

Syntax

String  variable_name = 'value'  

OR  

String  variable_name = ''value''  

OR  

String  variable_name = '''line1 
line2'''  

OR  

String  variable_name= ''''''line1 
line2''''''

The following example illustrates the use of String data type in Dart.

void main() { 
   String str1 = 'this is a single line string'; 
   String str2 = "this is a single line string"; 
   String str3 = '''this is a multiline line string'''; 
   String str4 = """this is a multiline line string"""; 
   
   print(str1);
   print(str2); 
   print(str3); 
   print(str4); 
}

It will produce the following Output −

this is a single line string 
this is a single line string 
this is a multiline line string 
this is a multiline line string 

Strings are immutable. However, strings can be subjected to various operations and the resultant string can be a stored as a new value.

String Interpolation

The process of creating a new string by appending a value to a static string is termed as concatenation or interpolation. In other words, it is the process of adding a string to another string.

The operator plus (+) is a commonly used mechanism to concatenate / interpolate strings.

Example 1

void main() { 
   String str1 = "hello"; 
   String str2 = "world"; 
   String res = str1+str2; 
   
   print("The concatenated string : ${res}"); 
}

It will produce the following output −

The concatenated string : Helloworld

Example 2

You can use “${}” can be used to interpolate the value of a Dart expression within strings. The following example illustrates the same.

void main() { 
   int n=1+1; 
   
   String str1 = "The sum of 1 and 1 is ${n}"; 
   print(str1); 
   
   String str2 = "The sum of 2 and 2 is ${2+2}"; 
   print(str2); 
}

It will produce the following output −

The sum of 1 and 1 is 2 
The sum of 2 and 2 is 4

String Properties

The properties listed in the following table are all read-only.

Methods to Manipulate Strings

The String class in the dart: core library also provides methods to manipulate strings. Some of these methods are given below −

Dart numbers can be classified as −

• int − Integer of arbitrary size. The int data type is used to represent whole numbers.
• double − 64-bit (double-precision) floating-point numbers, as specified by the IEEE 754 standard. The double data type is used to represent fractional numbers

The num type is inherited by the int and double types. The dart core library allows numerous operations on numeric values.

The syntax for declaring a number is as given below −

int var_name;      // declares an integer variable 
double var_name;   // declares a double variable 

Example

void main() {
   // declare an integer
   int num1 = 10;             
 
   // declare a double value
   double num2 = 10.50;  

   // print the values
   print(num1);
   print(num2);
}

It will produce the following output −

10 
10.5 

Note − The Dart VM will throw an exception if fractional values are assigned to integer variables.

Parsing

The parse() static function allows parsing a string containing numeric literal into a number. The following illustration demonstrates the same −

void main() { 
   print(num.parse('12')); 
   print(num.parse('10.91')); 
}

The above code will result in the following output −

12 
10.91

The parse function throws a FormatException if it is passed any value other than numerals. The following code shows how to pass an alpha-numeric value to the parse() function.

Example

void main() { 
   print(num.parse('12A')); 
   print(num.parse('AAAA')); 
}

The above code will result in the following output −

Unhandled exception: 
FormatException: 12A 
#0 num.parse (dart:core/num.dart:446) 
#1 main (file:///D:/Demos/numbers.dart:4:13) 
#2 _startIsolate.<anonymous closure> (dart:isolatepatch/isolate_patch.dart:261) 
#3 _RawReceivePortImpl._handleMessage (dart:isolatepatch/isolate_patch.dart:148)

Number Properties

The following table lists the properties supported by Dart numbers.

Number Methods

Given below are a list of commonly used methods supported by numbers −

A conditional/decision-making construct evaluates a condition before the instructions are executed.

Conditional constructs in Dart are classified in the following table.

At times, certain instructions require repeated execution. Loops are an ideal way to do the same. A loop represents a set of instructions that must be repeated. In a loop’s context, a repetition is termed as an iteration.

The following figure illustrates the classification of loops −

Let’s start the discussion with Definite Loops. A loop whose number of iterations are definite/fixed is termed as a definite loop.

Moving on, let’s now discuss the indefinite loops. An indefinite loop is used when the number of iterations in a loop is indeterminate or unknown. Indefinite loops can be implemented using −

Let us now move on and discuss the Loop Control Statements of Dart.

Using Labels to Control the Flow

A label is simply an identifier followed by a colon (:) that is applied to a statement or a block of code. A label can be used with break and continue to control the flow more precisely.

Line breaks are not allowed between the ‘continue’ or ‘break’ statement and its label name. Also, there should not be any other statement in between a label name and an associated loop.

Example: Label with Break

void main() { 
   outerloop: // This is the label name 
   
   for (var i = 0; i < 5; i++) { 
  print("Innerloop: ${i}"); 
  innerloop: 
  
  for (var j = 0; j &lt; 5; j++) { 
     if (j &gt; 3 ) break ; 
     
     // Quit the innermost loop 
     if (i == 2) break innerloop; 
     
     // Do the same thing 
     if (i == 4) break outerloop; 
     
     // Quit the outer loop 
     print("Innerloop: ${j}"); 
  } 
   } 
}

The following output is displayed on successful execution of the above code.

Innerloop: 0
Innerloop: 0
Innerloop: 1
Innerloop: 2
Innerloop: 3
Innerloop: 1
Innerloop: 0
Innerloop: 1
Innerloop: 2
Innerloop: 3
Innerloop: 2
Innerloop: 3
Innerloop: 0
Innerloop: 1
Innerloop: 2
Innerloop: 3
Innerloop: 4

Example: Label with continue

void main() { 
   outerloop: // This is the label name 
   
   for (var i = 0; i < 3; i++) { 
  print("Outerloop:${i}"); 
  
  for (var j = 0; j &lt; 5; j++) { 
     if (j == 3){ 
        continue outerloop; 
     } 
     print("Innerloop:${j}"); 
  } 
   } 
}

The following output is displayed on successful execution of the above code.

Outerloop: 0 
Innerloop: 0 
Innerloop: 1 
Innerloop: 2 

Outerloop: 1 
Innerloop: 0 
Innerloop: 1 
Innerloop: 2 

Outerloop: 2 
Innerloop: 0 
Innerloop: 1 
Innerloop: 2 

An expression is a special kind of statement that evaluates to a value. Every expression is composed of −

• Operands − Represents the data
• Operator − Defines how the operands will be processed to produce a value.

Consider the following expression – “2 + 3”. In this expression, 2 and 3 are operands and the symbol “+” (plus) is the operator.

In this chapter, we will discuss the operators that are available in Dart.

• Arithmetic Operators
• Equality and Relational Operators
• Type test Operators
• Bitwise Operators
• Assignment Operators
• Logical Operators

Arithmetic Operators

The following table shows the arithmetic operators supported by Dart.

Equality and Relational Operators

Relational Operators tests or defines the kind of relationship between two entities. Relational operators return a Boolean value i.e. true/ false.

Assume the value of A is 10 and B is 20.

Type test Operators

These operators are handy for checking types at runtime.

Bitwise Operators

The following table lists the bitwise operators available in Dart and their role −

Assignment Operators

The following table lists the assignment operators available in Dart.

Note − Same logic applies to Bitwise operators, so they will become ≪=, ≫=, ≫=, ≫=, |= and ^=.

Logical Operators

Logical operators are used to combine two or more conditions. Logical operators return a Boolean value. Assume the value of variable A is 10 and B is 20.

Conditional Expressions

Dart has two operators that let you evaluate expressions that might otherwise require ifelse statements −

condition ? expr1 : expr2

If condition is true, then the expression evaluates expr1 (and returns its value); otherwise, it evaluates and returns the value of expr2.

expr1 ?? expr2

If expr1 is non-null, returns its value; otherwise, evaluates and returns the value of expr2

Example

The following example shows how you can use conditional expression in Dart −

void main() { 
   var a = 10; 
   var res = a > 12 ? "value greater than 10":"value lesser than or equal to 10"; 
   print(res); 
} 

It will produce the following output −

value lesser than or equal to 10

Example

Let’s take another example −

void main() { 
   var a = null; 
   var b = 12; 
   var res = a ?? b; 
   print(res); 
}

It will produce the following output −

12

A variable is “a named space in the memory” that stores values. In other words, it acts a container for values in a program. Variable names are called identifiers. Following are the naming rules for an identifier −

• Identifiers cannot be keywords.
• Identifiers can contain alphabets and numbers.
• Identifiers cannot contain spaces and special characters, except the underscore (_) and the dollar ($) sign.
• Variable names cannot begin with a number.

Type Syntax

A variable must be declared before it is used. Dart uses the var keyword to achieve the same. The syntax for declaring a variable is as given below −

var name = 'Smith';

All variables in dart store a reference to the value rather than containing the value. The variable called name contains a reference to a String object with a value of “Smith”.

Dart supports type-checking by prefixing the variable name with the data type. Type-checking ensures that a variable holds only data specific to a data type. The syntax for the same is given below −

String name = 'Smith'; 
int num = 10;

Consider the following example −

void main() { 
   String name = 1; 
}

The above snippet will result in a warning since the value assigned to the variable doesn’t match the variable’s data type.

Output

Warning: A value of type 'String' cannot be assigned to a variable of type 'int' 

All uninitialized variables have an initial value of null. This is because Dart considers all values as objects. The following example illustrates the same −

void main() { 
   int num; 
   print(num); 
}

Output

Null 

The dynamic keyword

Variables declared without a static type are implicitly declared as dynamic. Variables can be also declared using the dynamic keyword in place of the var keyword.

The following example illustrates the same.

void main() { 
   dynamic x = "tom"; 
   print(x);  
}

Output

tom

Final and Const

The final and const keyword are used to declare constants. Dart prevents modifying the values of a variable declared using the final or const keyword. These keywords can be used in conjunction with the variable’s data type or instead of the var keyword.

The const keyword is used to represent a compile-time constant. Variables declared using the const keyword are implicitly final.

Syntax: final Keyword

final variable_name

OR

final data_type  variable_name

Syntax: const Keyword

const variable_name

OR

const data_type variable_name

Example – final Keyword

void main() { 
   final val1 = 12; 
   print(val1); 
}

Output

12

Example – const Keyword

void main() { 
   const pi = 3.14; 
   const area = pi*12*12; 
   print("The output is ${area}"); 
}

The above example declares two constants, pi and area, using the const keyword. The area variable’s value is a compile-time constant.

Output

The output is 452.15999999999997

Note − Only const variables can be used to compute a compile time constant. Compile-time constants are constants whose values will be determined at compile time

Example

Dart throws an exception if an attempt is made to modify variables declared with the final or const keyword. The example given below illustrates the same −

void main() { 
   final v1 = 12; 
   const v2 = 13; 
   v2 = 12; 
}

The code given above will throw the following error as output −

Unhandled exception: 
cannot assign to final variable 'v2='.  
NoSuchMethodError: cannot assign to final variable 'v2=' 
#0  NoSuchMethodError._throwNew (dart:core-patch/errors_patch.dart:178) 
#1      main (file: Test.dart:5:3) 
#2    _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:261) 
#3    _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)