Programmation de fléchettes - Guide rapide

Dart est un langage orienté objet avec une syntaxe de style C qui peut éventuellement trans-compiler en JavaScript. Il prend en charge une gamme variée d'aides à la programmation comme des interfaces, des classes, des collections, des génériques et la saisie facultative.

Dart peut être largement utilisé pour créer des applications d'une seule page. Les applications d'une seule page s'appliquent uniquement aux sites Web et aux applications Web. Les applications à page unique permettent la navigation entre les différents écrans du site Web sans charger une page Web différente dans le navigateur. Un exemple classique estGMail ─ lorsque vous cliquez sur un message dans votre boîte de réception, le navigateur reste sur la même page Web, mais le code JavaScript masque la boîte de réception et affiche le corps du message à l'écran.

Google a publié une version spéciale de Chromium - la Dart VM. L'utilisation de Dartium signifie que vous n'avez pas à compiler votre code en JavaScript tant que vous n'êtes pas prêt à tester sur d'autres navigateurs.

Le tableau suivant compare les fonctionnalités de Dart et JavaScript.

Fonctionnalité	Dard	JavaScript
Système de type	En option, dynamique	Faible, dynamique
Des classes	Oui, héritage unique	Prototypique
Interfaces	Oui, plusieurs interfaces	Non
Concurrence	Oui, avec des isolats	Oui, avec les web workers HTML5

Ce didacticiel fournit une compréhension de base du langage de programmation Dart.

Ce chapitre traite de la configuration de l'environnement d'exécution de Dart sur la plate-forme Windows.

Exécution de script en ligne avec DartPad

Vous pouvez tester vos scripts en ligne en utilisant l'éditeur en ligne à l'adresse https://dartpad.dartlang.org/. L'éditeur de fléchettes exécute le script et affiche à la fois le code HTML et la sortie de la console. L'éditeur en ligne est livré avec un ensemble d'exemples de codes prédéfinis.

Une capture d'écran du Dartpad l'éditeur est donné ci-dessous -

Dartpad permet également de coder de manière plus restrictive. Cela peut être réalisé en cochant l'option Mode fort en bas à droite de l'éditeur. Le mode fort aide avec -

• Vérification statique et dynamique renforcée
• Génération de code JavaScript idiomatique pour une meilleure interopérabilité.

Vous pouvez essayer l'exemple suivant en utilisant Dartpad

void main() { 
   print('hello world'); 
}

Le code affichera la sortie suivante

hello world

Configuration de l'environnement local

Dans cette section, voyons comment configurer l'environnement local.

Utilisation de l'éditeur de texte

Des exemples de quelques éditeurs incluent le Bloc-notes Windows, Notepad ++, Emacs, vim ou vi, etc. Les éditeurs peuvent varier d'un système d'exploitation à l'autre. Les fichiers source sont généralement nommés avec l'extension ".dart".

Installation du SDK Dart

La version stable actuelle de Dart est 1.21.0. ledart sdk peut être téléchargé depuis -

• https://www.dartlang.org/install/archive

• http://www.gekorm.com/dart-windows/

Une capture d'écran de l'installation du SDK Dart est donnée ci-dessous -

À la fin de l'installation du SDK, définissez la variable d'environnement PATH sur -

<dart-sdk-path>\bin

Vérification de l'installation

Pour vérifier si Dart a été installé avec succès, ouvrez l'invite de commande et entrez la commande suivante -

Dart

Si l'installation réussit, il affichera le runtime de la fléchette.

Prise en charge IDE

Une pléthore d'EDI prend en charge les scripts dans Dart. Les exemples comprennentEclipse, IntelliJ, et WebStorm des cerveaux Jet.

Vous trouverez ci-dessous les étapes de configuration de l'environnement Dart à l'aide de WebStrom IDE.

Installation de WebStorm

Le fichier d'installation de WebStorm peut être téléchargé depuis https://www.jetbrains.com/webstorm/download/#section=windows-version.

Le fichier d'installation WebStorm est disponible pour Mac OS, Windows et Linux.

Après avoir téléchargé les fichiers d'installation, suivez les étapes ci-dessous -

• Installez le SDK Dart: reportez-vous aux étapes répertoriées ci-dessus

• Créer un nouveau projet Dart et configurer la prise en charge de Dart

• Pour créer un nouveau projet Dart,

  • Cliquez sur Create New Project depuis l'écran d'accueil

  • Dans la boîte de dialogue suivante, cliquez sur Dart

• Si aucune valeur n'est spécifiée pour le Dart SDKchemin, puis indiquez le chemin du SDK. Par exemple, le chemin du SDK peut être<dart installation directory>/dart/dartsdk.

Ajouter un fichier Dart au projet

Pour ajouter un fichier Dart au projet -

• Faites un clic droit sur le projet
• Nouveau → Fichier Dart
• Entrez le nom du script Dart

Une capture d'écran de l'éditeur WebStorm est donnée ci-dessous -

L'outil dart2js

le dart2jsL'outil compile le code Dart en JavaScript. La compilation du code Dart vers JS permet d'exécuter le script Dart sur les navigateurs qui ne prennent pas en charge la machine virtuelle Dart.

L'outil dart2js est livré avec le SDK Dart et se trouve dans le /dartsdk/bin folder.

Pour compiler Dart en JavaScript, tapez la commande suivante dans le terminal

dart2js - - out = <output_file>.js  <dart_script>.dart

Cette commande produit un fichier contenant l'équivalent JavaScript de votre code Dart. Un tutoriel complet sur l'utilisation de cet utilitaire peut être trouvé sur le site officiel de Dart.

La syntaxe définit un ensemble de règles pour l'écriture de programmes. Chaque spécification de langage définit sa propre syntaxe. Un programme Dart est composé de -

• Variables et opérateurs
• Classes
• Functions
• Expressions et constructions de programmation
• Prise de décision et constructions en boucle
• Comments
• Bibliothèques et packages
• Typedefs
• Structures de données représentées sous forme de collections / génériques

Votre premier code de fléchettes

Commençons par l'exemple traditionnel «Hello World» -

main() { 
   print("Hello World!"); 
}

le main()function est une méthode prédéfinie dans Dart. Cette méthode sert de point d'entrée à l'application. Un script Dart a besoin dumain() méthode d'exécution. print() est une fonction prédéfinie qui imprime la chaîne ou la valeur spécifiée sur la sortie standard, c'est-à-dire le terminal.

La sortie du code ci-dessus sera -

Hello World!

Exécuter un programme Dart

Vous pouvez exécuter un programme Dart de deux manières -

• Via le terminal
• Via l'IDE WebStorm

Via le terminal

Pour exécuter un programme Dart via le terminal -

• Accédez au chemin du projet en cours
• Tapez la commande suivante dans la fenêtre Terminal

dart file_name.dart

Via l'IDE WebStorm

Pour exécuter un programme Dart via l'IDE WebStorm -

• Cliquez avec le bouton droit sur le fichier de script Dart sur l'EDI. (Le fichier doit contenir lemain() fonction pour activer l'exécution)

• Clique sur le ‘Run <file_name>’option. Une capture d'écran de la même chose est donnée ci-dessous -

On peut alternativement cliquer sur le

bouton ou utiliser le raccourciCtrl+Shift+F10 pour exécuter le script Dart.

Options de ligne de commande de Dart

Les options de ligne de commande Dart sont utilisées pour modifier l'exécution du script Dart. Les options de ligne de commande courantes pour Dart sont les suivantes:

Sr.Non	Option et description de la ligne de commande
1	-c or --c Active à la fois les assertions et les vérifications de type (mode vérifié).
2	--version Affiche les informations sur la version de la VM.
3	--packages <path> Spécifie le chemin d'accès au fichier de configuration de la résolution du package.
4	-p <path> Spécifie où trouver les bibliothèques importées. Cette option ne peut pas être utilisée avec --packages.
5	-h or --help Affiche l'aide.

Activation du mode vérifié

Les programmes de fléchettes fonctionnent dans deux modes à savoir -

• Mode vérifié
• Mode de production (par défaut)

Il est recommandé d'exécuter la machine virtuelle Dart dans checked modependant le développement et les tests, car il ajoute des avertissements et des erreurs pour faciliter le processus de développement et de débogage. Le mode vérifié applique diverses vérifications comme la vérification de type, etc. Pour activer le mode vérifié, ajoutez l'option -c ou –-checked avant le nom du fichier de script lors de l'exécution du script.

Cependant, pour garantir des performances optimales lors de l'exécution du script, il est recommandé d'exécuter le script dans le production mode.

Considérer ce qui suit Test.dart fichier de script -

void main() { 
   int n = "hello"; 
   print(n); 
}

Exécutez le script en entrant -

dart Test.dart

Bien qu'il y ait une incompatibilité de type, le script s'exécute avec succès lorsque le mode vérifié est désactivé. Le script aboutira à la sortie suivante -

hello

Maintenant, essayez d'exécuter le script avec l'option "- - cochée" ou "-c" -

dart -c Test.dart

Ou,

dart - - checked Test.dart

La machine virtuelle Dart lèvera une erreur indiquant qu'il existe une incompatibilité de type.

Unhandled exception: 
type 'String' is not a subtype of type 'int' of 'n' where 
   String is from dart:core 
   int is from dart:core 
#0  main (file:///C:/Users/Administrator/Desktop/test.dart:3:9) 
#1  _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart :261) 
#2  _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

Identifiants dans Dart

Les identificateurs sont des noms donnés à des éléments d'un programme comme des variables, des fonctions, etc. Les règles pour les identificateurs sont -

Les identificateurs peuvent inclure à la fois des caractères et des chiffres. Cependant, l'identifiant ne peut pas commencer par un chiffre.

• Les identificateurs ne peuvent pas inclure de symboles spéciaux à l'exception du trait de soulignement (_) ou d'un signe dollar ($).

• Les identificateurs ne peuvent pas être des mots-clés.

• Ils doivent être uniques.

• Les identificateurs sont sensibles à la casse.

• Les identificateurs ne peuvent pas contenir d'espaces.

Les tableaux suivants répertorient quelques exemples d'identificateurs valides et non valides -

Identifiants valides	Identifiants non valides
Prénom	Var
Prénom	Prénom
num1	Prénom
$ résultat	1 numéro

Mots-clés dans Dart

Les mots clés ont une signification particulière dans le contexte d'une langue. Le tableau suivant répertorie certains mots-clés dans Dart.

résumé 1	continuer	faux	Nouveau	ce
comme 1	défaut	final	nul	jeter
affirmer	différé 1	enfin	opérateur 1	vrai
asynchrone 2	faire	pour	partie 1	essayer
asynchrone * 2	dynamique 1	obtenir 1	repousser	typedef 1
attendre 2	autre	si	revenir	var
Pause	énumération	met en œuvre 1	ensemble 1	néant
Cas	export 1	importer 1	statique 1	tandis que
capture	externe 1	dans	super	avec
classe	étend	est	commutateur	rendement 2
const	usine 1	bibliothèque 1	synchronisation * 2	rendement * 2

Espaces blancs et sauts de ligne

Dart ignore les espaces, les tabulations et les retours à la ligne qui apparaissent dans les programmes. Vous pouvez utiliser des espaces, des tabulations et des retours à la ligne librement dans votre programme et vous êtes libre de formater et d'indenter vos programmes d'une manière nette et cohérente qui rend le code facile à lire et à comprendre.

Dart est sensible à la casse

Dart est sensible à la casse. Cela signifie que Dart fait la différence entre les majuscules et les minuscules.

Les instructions se terminent par un point-virgule

Chaque ligne d'instructions est appelée une instruction. Chaque instruction dart doit se terminer par un point-virgule (;). Une seule ligne peut contenir plusieurs instructions. Cependant, ces instructions doivent être séparées par un point-virgule.

Commentaires dans Dart

Les commentaires sont un moyen d'améliorer la lisibilité d'un programme. Les commentaires peuvent être utilisés pour inclure des informations supplémentaires sur un programme comme l'auteur du code, des conseils sur une fonction / construction, etc. Les commentaires sont ignorés par le compilateur.

Dart prend en charge les types de commentaires suivants -

• Single-line comments ( // ) - Tout texte entre "//" et la fin d'une ligne est traité comme un commentaire

• Multi-line comments (/* */) - Ces commentaires peuvent s'étendre sur plusieurs lignes.

Exemple

// this is single line comment  
  
/* This is a   
   Multi-line comment  
*/

Programmation orientée objet dans Dart

Dart est un langage orienté objet. L'orientation objet est un paradigme de développement logiciel qui suit la modélisation du monde réel. L'Orientation Objet considère un programme comme une collection d'objets qui communiquent entre eux via un mécanisme appelé méthodes.

• Object- Un objet est une représentation en temps réel de toute entité. Selon Grady Brooch, chaque objet doit avoir trois caractéristiques -

  • State - décrit par les attributs d'un objet.

  • Behavior - décrit comment l'objet agira.

  • Identity - une valeur unique qui distingue un objet d'un ensemble d'objets similaires similaires.

• Class- Une classe en termes de POO est un modèle pour créer des objets. Une classe encapsule les données de l'objet.

• Method - Les méthodes facilitent la communication entre les objets.

Exemple: orientation des fléchettes et des objets

class TestClass {   
   void disp() {     
      print("Hello World"); 
   } 
}  
void main() {   
   TestClass c = new TestClass();   
   c.disp();  
}

L'exemple ci-dessus définit une classe TestClass. La classe a une méthodedisp(). La méthode imprime la chaîne «Hello World» sur le terminal. Le nouveau mot-clé crée un objet de la classe. L'objet invoque la méthodedisp().

Le code doit produire les éléments suivants output -

Hello World

L'une des caractéristiques les plus fondamentales d'un langage de programmation est l'ensemble des types de données qu'il prend en charge. Ce sont les types de valeurs qui peuvent être représentées et manipulées dans un langage de programmation.

Le langage Dart prend en charge les types suivants:

• Numbers
• Strings
• Booleans
• Lists
• Maps

Nombres

Les nombres dans Dart sont utilisés pour représenter des littéraux numériques. Le Number Dart existe en deux saveurs -

• Integer- Les valeurs entières représentent des valeurs non fractionnaires, c'est-à-dire des valeurs numériques sans point décimal. Par exemple, la valeur «10» est un entier. Les littéraux entiers sont représentés à l'aide duint mot-clé.

• Double- Dart prend également en charge les valeurs numériques fractionnaires, c'est-à-dire les valeurs avec des points décimaux. Le type de données Double dans Dart représente un nombre à virgule flottante 64 bits (double précision). Par exemple, la valeur "10.10". Le mot clédouble est utilisé pour représenter les littéraux à virgule flottante.

Cordes

Les chaînes représentent une séquence de caractères. Par exemple, si vous deviez stocker des données telles que le nom, l'adresse, etc., le type de données chaîne doit être utilisé. Une chaîne Dart est une séquence d'unités de code UTF-16.Runes sont utilisés pour représenter une séquence d'unités de code UTF-32.

Le mot clé Stringest utilisé pour représenter les littéraux de chaîne. Les valeurs de chaîne sont incorporées entre guillemets simples ou doubles.

Booléen

Le type de données Boolean représente les valeurs booléennes true et false. Dart utilise lebool mot-clé pour représenter une valeur booléenne.

Liste et carte

La liste et la carte des types de données sont utilisées pour représenter une collection d'objets. UNEListest un groupe d'objets ordonné. Le type de données List dans Dart est synonyme du concept de tableau dans d'autres langages de programmation. leMaple type de données représente un ensemble de valeurs sous forme de paires clé-valeur. ledart: core Library permet la création et la manipulation de ces collections via les classes List et Map prédéfinies respectivement.

Le type dynamique

Dart est un langage typé facultativement. Si le type d'une variable n'est pas explicitement spécifié, le type de la variable estdynamic. ledynamic Le mot clé peut également être utilisé explicitement comme annotation de type.

Une variable est «un espace nommé dans la mémoire» qui stocke des valeurs. En d'autres termes, il agit comme un conteneur de valeurs dans un programme. Les noms de variables sont appelés identificateurs. Voici les règles de dénomination d'un identifiant -

• 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)

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.

Show Examples

Sr.No	Operators & Meaning
1	+ Add
2	− Subtract
3	-expr Unary minus, also known as negation (reverse the sign of the expression)
4	* Multiply
5	/ Divide
6	~/ Divide, returning an integer result
7	% Get the remainder of an integer division (modulo)
8	++ Increment
9	-- Decrement

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.

Show Examples

Operator	Description	Example
>	Greater than	(A > B) is False
<	Lesser than	(A < B) is True
>=	Greater than or equal to	(A >= B) is False
<=	Lesser than or equal to	(A <= B) is True
==	Equality	(A==B) is False
!=	Not equal	(A!=B) is True

Type test Operators

These operators are handy for checking types at runtime.

Show Examples

Operator	Meaning
is	True if the object has the specified type
is!	False if the object has the specified type

Bitwise Operators

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

Show Examples

Operator	Description	Example
Bitwise AND	a & b	Returns a one in each bit position for which the corresponding bits of both operands are ones.
Bitwise OR	a | b	Returns a one in each bit position for which the corresponding bits of either or both operands are ones.
Bitwise XOR	a ^ b	Returns a one in each bit position for which the corresponding bits of either but not both operands are ones.
Bitwise NOT	~ a	Inverts the bits of its operand.
Left shift	a ≪ b	Shifts a in binary representation b (< 32) bits to the left, shifting in zeroes from the right.
Signpropagating right shift	a ≫ b	Shifts a in binary representation b (< 32) bits to the right, discarding bits shifted off.

Assignment Operators

The following table lists the assignment operators available in Dart.

Show Examples

Sr.No	Operator & Description
1	=(Simple Assignment ) Assigns values from the right side operand to the left side operand Ex:C = A + B will assign the value of A + B into C
2	??= Assign the value only if the variable is null
3	+=(Add and Assignment) It adds the right operand to the left operand and assigns the result to the left operand. Ex: C += A is equivalent to C = C + A
4	─=(Subtract and Assignment) It subtracts the right operand from the left operand and assigns the result to the left operand. Ex: C -= A is equivalent to C = C – A
5	*=(Multiply and Assignment) It multiplies the right operand with the left operand and assigns the result to the left operand. Ex: C *= A is equivalent to C = C * A
6	/=(Divide and Assignment) It divides the left operand with the right operand and assigns the result to the left operand.

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.

Show Examples

Operator	Description	Example
&&	And − The operator returns true only if all the expressions specified return true	(A > 10 && B > 10) is False.
||	OR − The operator returns true if at least one of the expressions specified return true	(A > 10 || B > 10) is True.
!	NOT − The operator returns the inverse of the expression’s result. For E.g.: !(7>5) returns false	!(A > 10) is True.

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

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.

Sr.No	Loop & Description
1	for loop The for loop is an implementation of a definite loop. The for loop executes the code block for a specified number of times. It can be used to iterate over a fixed set of values, such as an array
2	for…in Loop The for...in loop is used to loop through an object's properties.

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 −

Sr.No	Loop & Description
1	while Loop The while loop executes the instructions each time the condition specified evaluates to true. In other words, the loop evaluates the condition before the block of code is executed.
2	do…while Loop The do…while loop is similar to the while loop except that the do...while loop doesn’t evaluate the condition for the first time the loop executes.

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

Sr.No	Control Statement & Description
1	break Statement The break statement is used to take the control out of a construct. Using break in a loop causes the program to exit the loop. Following is an example of the break statement.
2	continue Statement The continue statement skips the subsequent statements in the current iteration and takes the control back to the beginning of the loop.

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 < 5; j++) { if (j > 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 < 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

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

Conditional constructs in Dart are classified in the following table.

Sr.No	Statement & Description
1	if statement An if statement consists of a Boolean expression followed by one or more statements.
2	If...Else Statement An if can be followed by an optional else block. The else block will execute if the Boolean expression tested by the if block evaluates to false.
3	else…if Ladder The else…if ladder is useful to test multiple conditions. Following is the syntax of the same.
4	switch…case Statement The switch statement evaluates an expression, matches the expression’s value to a case clause and executes the statements associated with that case.

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.

Sr.No	Property & Description
1	hashcode Returns a hash code for a numerical value.
2	isFinite True if the number is finite; otherwise, false.
3	isInfinite True if the number is positive infinity or negative infinity; otherwise, false.
4	isNan True if the number is the double Not-a-Number value; otherwise, false.
5	isNegative True if the number is negative; otherwise, false.
6	sign Returns minus one, zero or plus one depending on the sign and numerical value of the number.
7	isEven Returns true if the number is an even number.
8	isOdd Returns true if the number is an odd number.

Number Methods

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

Sr.No	Method & Description
1	abs Returns the absolute value of the number.
2	ceil Returns the least integer no smaller than the number.
3	compareTo Compares this to other number.
4	Floor Returns the greatest integer not greater than the current number.
5	remainder Returns the truncated remainder after dividing the two numbers.
6	Round Returns the integer closest to the current numbers.
7	toDouble Returns the double equivalent of the number.
8	toInt Returns the integer equivalent of the number.
9	toString Returns the string equivalent representation of the number.
10	truncate Returns an integer after discarding any fractional digits.

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.

Sr.No	Property & Description
1	codeUnits Returns an unmodifiable list of the UTF-16 code units of this string.
2	isEmpty Returns true if this string is empty.
3	Length Returns the length of the string including space, tab and newline characters.

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 −

Sr.No	Methods & Description
1	toLowerCase() Converts all characters in this string to lower case.
2	toUpperCase() Converts all characters in this string to upper case.
3	trim() Returns the string without any leading and trailing whitespace.
4	compareTo() Compares this object to another.
5	replaceAll() Replaces all substrings that match the specified pattern with a given value.
6	split() Splits the string at matches of the specified delimiter and returns a list of substrings.
7	substring() Returns the substring of this string that extends from startIndex, inclusive, to endIndex, exclusive.
8	toString() Returns a string representation of this object.
9	codeUnitAt() Returns the 16-bit UTF-16 code unit at the given index.

Dart provides an inbuilt support for the Boolean data type. The Boolean data type in DART supports only two values – true and false. The keyword bool is used to represent a Boolean literal in DART.

The syntax for declaring a Boolean variable in DART is as given below −

bool var_name = true;  
OR  
bool var_name = false

Example

void main() { 
   bool test; 
   test = 12 > 5; 
   print(test); 
}

It will produce the following output −

true

Example

Unlike JavaScript, the Boolean data type recognizes only the literal true as true. Any other value is considered as false. Consider the following example −

var str = 'abc'; 
if(str) { 
   print('String is not empty'); 
} else { 
   print('Empty String'); 
}

The above snippet, if run in JavaScript, will print the message ‘String is not empty’ as the if construct will return true if the string is not empty.

However, in Dart, str is converted to false as str != true. Hence the snippet will print the message ‘Empty String’ (when run in unchecked mode).

Example

The above snippet if run in checked mode will throw an exception. The same is illustrated below −

void main() { 
   var str = 'abc'; 
   if(str) { 
      print('String is not empty'); 
   } else { 
      print('Empty String'); 
   } 
}

It will produce the following output, in Checked Mode −

Unhandled exception: 
type 'String' is not a subtype of type 'bool' of 'boolean expression' where 
   String is from dart:core 
   bool is from dart:core  
#0 main (file:///D:/Demos/Boolean.dart:5:6) 
#1 _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:261) 
#2 _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

It will produce the following output, in Unchecked Mode −

Empty String

Note − The WebStorm IDE runs in checked mode, by default.

A very commonly used collection in programming is an array. Dart represents arrays in the form of List objects. A List is simply an ordered group of objects. The dart:core library provides the List class that enables creation and manipulation of lists.

The logical representation of a list in Dart is given below −

• test_list − is the identifier that references the collection.

• The list contains in it the values 12, 13, and 14. The memory blocks holding these values are known as elements.

• Each element in the List is identified by a unique number called the index. The index starts from zero and extends up to n-1 where n is the total number of elements in the List. The index is also referred to as the subscript.

Lists can be classified as −

• Fixed Length List
• Growable List

Let us now discuss these two types of lists in detail.

Fixed Length List

A fixed length list’s length cannot change at runtime. The syntax for creating a fixed length list is as given below −

Step 1 − Declaring a list

The syntax for declaring a fixed length list is given below −

var list_name = new List(initial_size)

The above syntax creates a list of the specified size. The list cannot grow or shrink at runtime. Any attempt to resize the list will result in an exception.

Step 2 − Initializing a list

The syntax for initializing a list is as given below −

lst_name[index] = value;

Example

void main() { 
   var lst = new List(3); 
   lst[0] = 12; 
   lst[1] = 13; 
   lst[2] = 11; 
   print(lst); 
}

It will produce the following output −

[12, 13, 11]

Growable List

A growable list’s length can change at run-time. The syntax for declaring and initializing a growable list is as given below −

Step 1 − Declaring a List

var list_name = [val1,val2,val3]   
--- creates a list containing the specified values  
OR  
var list_name = new List() 
--- creates a list of size zero

Step 2 − Initializing a List

The index / subscript is used to reference the element that should be populated with a value. The syntax for initializing a list is as given below −

list_name[index] = value;

Example

The following example shows how to create a list of 3 elements.

void main() { 
   var num_list = [1,2,3]; 
   print(num_list); 
}

It will produce the following output −

[1, 2, 3]

Example

The following example creates a zero-length list using the empty List() constructor. The add() function in the List class is used to dynamically add elements to the list.

void main() { 
   var lst = new List(); 
   lst.add(12); 
   lst.add(13); 
   print(lst); 
}

It will produce the following output −

[12, 13]

List Properties

The following table lists some commonly used properties of the List class in the dart:core library.

Sr.No	Methods & Description
1	first Returns the first element case.
2	isEmpty Returns true if the collection has no elements.
3	isNotEmpty Returns true if the collection has at least one element.
4	length Returns the size of the list.
5	last Returns the last element in the list.
6	reversed Returns an iterable object containing the lists values in the reverse order.
7	Single Checks if the list has only one element and returns it.

In this chapter, we will discuss how to carry out some basic operations on Lists, such as −

Sr.No	Basic Operation & Description
1	Inserting Elements into a List Mutable Lists can grow dynamically at runtime. The List.add() function appends the specified value to the end of the List and returns a modified List object.
2	Updating a list Lists in Dart can be updated by − Updating The Index Using the List.replaceRange() function
3	Removing List items The following functions supported by the List class in the dart:core library can be used to remove the item(s) in a List.

The Map object is a simple key/value pair. Keys and values in a map may be of any type. A Map is a dynamic collection. In other words, Maps can grow and shrink at runtime.

Maps can be declared in two ways −

• Using Map Literals
• Using a Map constructor

Declaring a Map using Map Literals

To declare a map using map literals, you need to enclose the key-value pairs within a pair of curly brackets "{ }".

Here is its syntax −

var identifier = { key1:value1, key2:value2 [,…..,key_n:value_n] }

Déclaration d'une carte à l'aide d'un constructeur de carte

Pour déclarer une carte à l'aide d'un constructeur de carte, nous avons deux étapes. Commencez par déclarer la carte et deuxièmement, initialisez la carte.

le syntax à declare a map est comme suit -

var identifier = new Map()

Maintenant, utilisez la syntaxe suivante pour initialize the map -

map_name[key] = value

Exemple: Map Literal

void main() { 
   var details = {'Usrname':'tom','Password':'pass@123'}; 
   print(details); 
}

Il produira ce qui suit output -

{Usrname: tom, Password: pass@123}

Exemple: ajout de valeurs à des littéraux de mappage au moment de l'exécution

void main() { 
   var details = {'Usrname':'tom','Password':'pass@123'}; 
   details['Uid'] = 'U1oo1'; 
   print(details); 
}

Il produira ce qui suit output -

{Usrname: tom, Password: pass@123, Uid: U1oo1}

Exemple: constructeur de carte

void main() { 
   var details = new Map(); 
   details['Usrname'] = 'admin'; 
   details['Password'] = 'admin@123'; 
   print(details); 
}

Il produira ce qui suit output -

{Usrname: admin, Password: admin@123}

Note - Une valeur de mappage peut être n'importe quel objet, y compris NULL.

Carte - Propriétés

le Map class dans le dart: core package définit les propriétés suivantes -

Sr.Non	Propriété et description
1	Clés Renvoie un objet itérable représentant des clés
2	Valeurs Renvoie un objet itérable représentant des valeurs
3	Longueur Renvoie la taille de la carte
4	est vide Renvoie vrai si la carte est une carte vide
5	n'est pas vide Renvoie vrai si la carte est une carte vide

Carte - Fonctions

Voici les fonctions couramment utilisées pour manipuler les cartes dans Dart.

Sr.Non	Nom et description de la fonction
1	tout ajouter() Ajoute toutes les paires clé-valeur des autres à cette carte.
2	clair() Supprime toutes les paires de la carte.
3	retirer() Supprime la clé et sa valeur associée, le cas échéant, de la carte.
4	pour chaque() Applique f à chaque paire clé-valeur de la carte.

Les symboles dans Dart sont des noms de chaîne opaques et dynamiques utilisés pour refléter les métadonnées d'une bibliothèque. En termes simples, les symboles sont un moyen de stocker la relation entre une chaîne lisible par l'homme et une chaîne optimisée pour être utilisée par les ordinateurs.

La réflexion est un mécanisme pour obtenir des métadonnées d'un type à l'exécution comme le nombre de méthodes dans une classe, le nombre de constructeurs dont elle dispose ou le nombre de paramètres dans une fonction. Vous pouvez même appeler une méthode du type qui est chargée lors de l'exécution.

Dans la réflexion Dart, des classes spécifiques sont disponibles dans le dart:mirrorspaquet. Cette bibliothèque fonctionne à la fois dans les applications Web et les applications de ligne de commande.

Syntaxe

Symbol obj = new Symbol('name');  
// expects a name of class or function or library to reflect

le name doit être un nom de membre public Dart valide, un nom de constructeur public ou un nom de bibliothèque.

Exemple

Prenons l'exemple suivant. Le code déclare une classeFoo dans une bibliothèque foo_lib. La classe définit les méthodesm1, m2, et m3.

Foo.dart

library foo_lib;   
// libarary name can be a symbol   

class Foo {         
   // class name can be a symbol  
   m1() {        
      // method name can be a symbol 
      print("Inside m1"); 
   } 
   m2() { 
      print("Inside m2"); 
   } 
   m3() { 
      print("Inside m3"); 
   } 
}

Le code suivant se charge Foo.dartbibliothèque et recherche la classe Foo, à l'aide du type Symbol. Puisque nous reflétons les métadonnées de la bibliothèque ci-dessus, le code importedart:mirrors bibliothèque.

FooSymbol.dart

import 'dart:core'; 
import 'dart:mirrors'; 
import 'Foo.dart';  

main() { 
   Symbol lib = new Symbol("foo_lib");   
   //library name stored as Symbol 
   
   Symbol clsToSearch = new Symbol("Foo");  
   // class name stored as Symbol  
   
   if(checkIf_classAvailableInlibrary(lib, clsToSearch))  
   // searches Foo class in foo_lib library 
      print("class found.."); 
}  
   
bool checkIf_classAvailableInlibrary(Symbol libraryName, Symbol className) { 
   MirrorSystem mirrorSystem = currentMirrorSystem(); 
   LibraryMirror libMirror = mirrorSystem.findLibrary(libraryName); 
      
   if (libMirror != null) { 
      print("Found Library"); 
      print("checkng...class details.."); 
      print("No of classes found is : ${libMirror.declarations.length}"); 
      libMirror.declarations.forEach((s, d) => print(s));  
         
      if (libMirror.declarations.containsKey(className)) return true; 
      return false; 
   } 
}

Notez que la ligne libMirror.declarations.forEach ((s, d) => print (s)); itérera à travers chaque déclaration de la bibliothèque au moment de l'exécution et imprimera les déclarations en tant que type deSymbol.

Ce code doit produire les éléments suivants output -

Found Library 
checkng...class details.. 
No of classes found is : 1 
Symbol("Foo") // class name displayed as symbol  
class found.

Exemple: afficher le nombre de méthodes d'instance d'une classe

Considérons maintenant l'affichage du nombre de méthodes d'instance dans une classe. La classe prédéfinieClassMirror nous aide à réaliser la même chose.

import 'dart:core'; 
import 'dart:mirrors'; 
import 'Foo.dart';  

main() { 
   Symbol lib = new Symbol("foo_lib"); 
   Symbol clsToSearch = new Symbol("Foo");  
   reflect_InstanceMethods(lib, clsToSearch); 
}  
void reflect_InstanceMethods(Symbol libraryName, Symbol className) { 
   MirrorSystem mirrorSystem = currentMirrorSystem(); 
   LibraryMirror libMirror = mirrorSystem.findLibrary(libraryName); 
   
   if (libMirror != null) { 
      print("Found Library"); 
      print("checkng...class details.."); 
      print("No of classes found is : ${libMirror.declarations.length}"); 
      libMirror.declarations.forEach((s, d) => print(s));  
      
      if (libMirror.declarations.containsKey(className)) print("found class");
      ClassMirror classMirror = libMirror.declarations[className]; 
      
      print("No of instance methods found is ${classMirror.instanceMembers.length}");
      classMirror.instanceMembers.forEach((s, v) => print(s)); 
   } 
}

Ce code doit produire les éléments suivants output -

Found Library 
checkng...class details.. 
No of classes found is : 1 
Symbol("Foo") 
found class 
No of instance methods found is 8 
Symbol("==") 
Symbol("hashCode") 
Symbol("toString") 
Symbol("noSuchMethod") 
Symbol("runtimeType") 
Symbol("m1") 
Symbol("m2") 
Symbol("m3")

Convertir le symbole en chaîne

Vous pouvez convertir le nom d'un type comme une classe ou une bibliothèque stockée dans un symbole en chaîne en utilisant MirrorSystemclasse. Le code suivant montre comment vous pouvez convertir un symbole en chaîne.

import 'dart:mirrors'; 
void main(){ 
   Symbol lib = new Symbol("foo_lib"); 
   String name_of_lib = MirrorSystem.getName(lib); 
   
   print(lib); 
   print(name_of_lib); 
}

Il devrait produire ce qui suit output -

Symbol("foo_lib")   

foo_lib

Les chaînes sont une séquence de caractères. Dart représente des chaînes sous la forme d'une séquence d'unités de code Unicode UTF-16. Unicode est un format qui définit une valeur numérique unique pour chaque lettre, chiffre et symbole.

Étant donné qu'une chaîne Dart est une séquence d'unités de code UTF-16, les valeurs Unicode 32 bits dans une chaîne sont représentées à l'aide d'une syntaxe spéciale. UNErune est un entier représentant un point de code Unicode.

La classe String dans le dart:core la bibliothèque fournit des mécanismes d'accès runes. Les unités de code de chaîne / runes sont accessibles de trois manières -

• Utilisation de la fonction String.codeUnitAt ()
• Utilisation de la propriété String.codeUnits
• Utilisation de la propriété String.runes

Fonction String.codeUnitAt ()

Les unités de code d'une chaîne sont accessibles via leurs index. Renvoie l'unité de code UTF-16 16 bits à l'index donné.

Syntaxe

String.codeUnitAt(int index);

Exemple

import 'dart:core'; 
void main(){ 
   f1(); 
} 
f1() { 
   String x = 'Runes'; 
   print(x.codeUnitAt(0)); 
}

Il produira ce qui suit output -

82

String.codeUnits, propriété

Cette propriété renvoie une liste non modifiable des unités de code UTF-16 de la chaîne spécifiée.

Syntaxe

String. codeUnits;

Exemple

import 'dart:core';  
void main(){ 
   f1(); 
}  
f1() { 
   String x = 'Runes'; 
   print(x.codeUnits); 
}

Il produira ce qui suit output -

[82, 117, 110, 101, 115]

String.runes, propriété

Cette propriété renvoie un itérable des points de code Unicode de ce string.Runes étend itérable.

Syntaxe

String.runes

Exemple

void main(){ 
   "A string".runes.forEach((int rune) { 
      var character=new String.fromCharCode(rune); 
      print(character); 
   });  
}

Il produira ce qui suit output -

A 
s 
t 
r 
i 
n 
g

Les points de code Unicode sont généralement exprimés comme \uXXXX, où XXXX est une valeur hexadécimale à 4 chiffres. Pour spécifier plus ou moins de 4 chiffres hexadécimaux, placez la valeur entre accolades. On peut utiliser le constructeur de la classe Runes dans la bibliothèque dart: core pour le même.

Exemple

main() { 
   Runes input = new Runes(' \u{1f605} '); 
   print(new String.fromCharCodes(input)); 
}

Il produira ce qui suit output -

Une énumération est utilisée pour définir des valeurs constantes nommées. Un type énuméré est déclaré à l'aide duenum mot-clé.

Syntaxe

enum enum_name {  
   enumeration list 
}

Où,

• L' énum_name spécifie le nom du type d'énumération
• La liste d'énumération est une liste d'identificateurs séparés par des virgules

Chacun des symboles de la liste d'énumération représente une valeur entière, un plus grand que le symbole qui le précède. Par défaut, la valeur du premier symbole d'énumération est 0.

Par exemple

enum Status { 
   none, 
   running, 
   stopped, 
   paused 
}

Exemple

enum Status { 
   none, 
   running, 
   stopped, 
   paused 
}  
void main() { 
   print(Status.values); 
   Status.values.forEach((v) => print('value: $v, index: ${v.index}')); print('running: ${Status.running}, ${Status.running.index}'); print('running index: ${Status.values[1]}'); 
}

Il produira ce qui suit output -

[Status.none, Status.running, Status.stopped, Status.paused] 
value: Status.none, index: 0 
value: Status.running, index: 1 
value: Status.stopped, index: 2 
value: Status.paused, index: 3 
running: Status.running, 1 
running index: Status.running

Les fonctions sont les éléments constitutifs d'un code lisible, maintenable et réutilisable. Une fonction est un ensemble d'instructions pour effectuer une tâche spécifique. Les fonctions organisent le programme en blocs logiques de code. Une fois définies, les fonctions peuvent être appelées pour accéder au code. Cela rend le code réutilisable. De plus, les fonctions facilitent la lecture et la maintenance du code du programme.

Une déclaration de fonction informe le compilateur du nom, du type de retour et des paramètres d'une fonction. Une définition de fonction fournit le corps réel de la fonction.

Sr.Non	Fonctions et description
1	Définition d'une fonction Une définition de fonction spécifie quoi et comment une tâche spécifique serait effectuée.
2	Appeler une fonction Une fonction doit être appelée pour l'exécuter.
3	Fonctions de retour Les fonctions peuvent également renvoyer une valeur avec le contrôle, à l'appelant.
4	Fonction paramétrée Les paramètres sont un mécanisme permettant de transmettre des valeurs aux fonctions.

Paramètres facultatifs

Des paramètres facultatifs peuvent être utilisés lorsque des arguments ne doivent pas être obligatoirement passés pour l'exécution d'une fonction. Un paramètre peut être marqué comme facultatif en ajoutant un point d'interrogation à son nom. Le paramètre facultatif doit être défini comme dernier argument d'une fonction.

Nous avons trois types de paramètres optionnels dans Dart -

Sr.Non	Paramètre et description
1	Paramètre de position facultatif Pour spécifier des paramètres de position facultatifs, utilisez des crochets [].
2	Paramètre nommé facultatif Contrairement aux paramètres de position, le nom du paramètre doit être spécifié lors de la transmission de la valeur. L'accolade {} peut être utilisée pour spécifier des paramètres nommés facultatifs.
3	Paramètres facultatifs avec des valeurs par défaut Les paramètres de fonction peuvent également recevoir des valeurs par défaut. Cependant, ces paramètres peuvent également être des valeurs transmises explicitement.

Fonctions de fléchettes récursives

La récursivité est une technique pour itérer sur une opération en faisant appeler une fonction à elle-même à plusieurs reprises jusqu'à ce qu'elle arrive à un résultat. La récursivité est mieux appliquée lorsque vous devez appeler la même fonction à plusieurs reprises avec différents paramètres à partir d'une boucle.

Exemple

void main() { 
   print(factorial(6));
}  
factorial(number) { 
   if (number <= 0) {         
      // termination case 
      return 1; 
   } else { 
      return (number * factorial(number - 1));    
      // function invokes itself 
   } 
}

Il devrait produire ce qui suit output -

720

Fonctions Lambda

Les fonctions Lambda sont un mécanisme concis pour représenter des fonctions. Ces fonctions sont également appelées fonctions fléchées.

Syntaxe

[return_type]function_name(parameters)=>expression;

Exemple

void main() { 
   printMsg(); 
   print(test()); 
}  
printMsg()=>
print("hello"); 

int test()=>123;                       
// returning function

Il devrait produire ce qui suit output -

hello 123

Un interfacedéfinit la syntaxe à laquelle toute entité doit adhérer. Les interfaces définissent un ensemble de méthodes disponibles sur un objet. Dart n'a pas de syntaxe pour déclarer les interfaces. Les déclarations de classe sont elles-mêmes des interfaces dans Dart.

Classesdevrait utiliser le mot-clé implements pour pouvoir utiliser une interface. Il est obligatoire pour la classe d'implémentation de fournir une implémentation concrète de toutes les fonctions de l'interface implémentée. En d'autres termes, une classe doit redéfinir chaque fonction de l'interface qu'elle souhaite implémenter.

Syntaxe: implémentation d'une interface

class identifier implements interface_name

Exemple

Dans le programme suivant, nous déclarons une classe Printer. leConsolePrinter class implémente la déclaration d'interface implicite pour le Printerclasse. lemain fonction crée un objet du ConsolePrinter classe en utilisant le newmot-clé. Cet objet est utilisé pour appeler la fonctionprint_data défini dans le ConsolePrinter classe.

void main() { 
   ConsolePrinter cp= new ConsolePrinter(); 
   cp.print_data(); 
}  
class Printer { 
   void print_data() { 
      print("__________Printing Data__________"); 
   } 
}  
class ConsolePrinter implements Printer { 
   void print_data() {  
      print("__________Printing to Console__________"); 
   } 
}

Il devrait produire ce qui suit output -

__________Printing to Console__________

Implémentation de plusieurs interfaces

Une classe peut implémenter plusieurs interfaces. Les interfaces sont séparées par une virgule. lesyntax car la même chose est donnée ci-dessous -

class identifier implements interface-1,interface_2,interface_4…….

Le suivant example montre comment vous pouvez implémenter plusieurs interfaces dans Dart -

void main() { 
   Calculator c = new Calculator(); 
   print("The gross total : ${c.ret_tot()}"); print("Discount :${c.ret_dis()}"); 
}  
class Calculate_Total { 
   int ret_tot() {} 
}  
class Calculate_Discount { 
   int ret_dis() {} 
}
class Calculator  implements Calculate_Total,Calculate_Discount { 
   int ret_tot() { 
      return 1000; 
   } 
   int ret_dis() { 
      return 50; 
   } 
}

Il devrait produire ce qui suit output -

The gross total: 1000 
Discount:50

Dart est un langage orienté objet. Il prend en charge les fonctionnalités de programmation orientées objet telles que les classes, les interfaces, etc.classen termes de POO est un modèle pour créer des objets. UNEclassencapsule les données de l'objet. Dart fournit un support intégré pour ce concept appeléclass.

Déclarer une classe

Utilisez le class mot-clé pour déclarer un classdans Dart. Une définition de classe commence par la classe de mot-clé suivie declass name; et le corps de la classe entouré par une paire d'accolades. La syntaxe pour le même est donnée ci-dessous -

Syntaxe

class class_name {  
   <fields> 
   <getters/setters> 
   <constructors> 
   <functions> 
}

le classLe mot-clé est suivi du nom de la classe. Les règles pour les identificateurs doivent être prises en compte lors de la dénomination d'une classe.

Une définition de classe peut inclure les éléments suivants -

• Fields- Un champ est une variable déclarée dans une classe. Les champs représentent les données relatives aux objets.

• Setters and Getters- Permet au programme d'initialiser et de récupérer les valeurs des champs d'une classe. Un getter / setter par défaut est associé à chaque classe. Cependant, ceux par défaut peuvent être remplacés en définissant explicitement un setter / getter.

• Constructors - responsable de l'allocation de mémoire pour les objets de la classe.

• Functions- Les fonctions représentent les actions qu'un objet peut entreprendre. Ils sont également parfois appelés méthodes.

Ces composants réunis sont appelés data members de la classe.

Exemple: déclarer une classe

class Car {  
   // field 
   String engine = "E1001";  
   
   // function 
   void disp() { 
      print(engine); 
   } 
}

L'exemple déclare une classe Car. La classe a un champ nomméengine. ledisp() est une fonction simple qui imprime la valeur du champ engine.

Créer une instance de la classe

Pour créer une instance de la classe, utilisez le newmot-clé suivi du nom de la classe. La syntaxe pour le même est donnée ci-dessous -

Syntaxe

var object_name = new class_name([ arguments ])

• le new Le mot clé est responsable de l'instanciation.

• Le côté droit de l'expression appelle le constructeur. Le constructeur doit recevoir des valeurs s'il est paramétré.

Exemple: instancier une classe

var obj = new Car("Engine 1")

Accès aux attributs et fonctions

Les attributs et fonctions d'une classe sont accessibles via l'objet. Utilisez le '.' notation par points (appeléeperiod) pour accéder aux données membres d'une classe.

//accessing an attribute 
obj.field_name  

//accessing a function 
obj.function_name()

Exemple

Jetez un œil à l'exemple suivant pour comprendre comment accéder aux attributs et fonctions dans Dart -

void main() { 
   Car c= new Car(); 
   c.disp(); 
}  
class Car {  
   // field 
   String engine = "E1001";  
   
   // function 
   void disp() { 
      print(engine); 
   } 
}

le output du code ci-dessus est comme suit -

E1001

Constructeurs de fléchettes

Un constructeur est une fonction spéciale de la classe qui est responsable de l'initialisation des variables de la classe. Dart définit un constructeur portant le même nom que celui de la classe. Un constructeur est une fonction et peut donc être paramétré. Cependant, contrairement à une fonction, les constructeurs ne peuvent pas avoir de type de retour. Si vous ne déclarez pas de constructeur, une valeur par défautno-argument constructor est fourni pour vous.

Syntaxe

Class_name(parameter_list) { 
   //constructor body 
}

Exemple

L'exemple suivant montre comment utiliser des constructeurs dans Dart -

void main() { 
   Car c = new Car('E1001'); 
} 
class Car { 
   Car(String engine) { 
      print(engine); 
   } 
}

Il devrait produire ce qui suit output -

E1001

Constructeurs nommés

Dart fournit named constructors pour activer une classe définir multiple constructors. La syntaxe des constructeurs nommés est donnée ci-dessous -

Syntaxe: définition du constructeur

Class_name.constructor_name(param_list)

Exemple

L'exemple suivant montre comment utiliser des constructeurs nommés dans Dart -

void main() {           
   Car c1 = new Car.namedConst('E1001');                                       
   Car c2 = new Car(); 
}           
class Car {                   
   Car() {                           
      print("Non-parameterized constructor invoked");
   }                                   
   Car.namedConst(String engine) { 
      print("The engine is : ${engine}");    
   }                               
}

Il devrait produire ce qui suit output -

The engine is : E1001 
Non-parameterized constructor invoked

Le mot-clé this

le thismot-clé fait référence à l'instance actuelle de la classe. Ici, le nom du paramètre et le nom du champ de la classe sont identiques. Par conséquent, pour éviter toute ambiguïté, le champ de la classe est précédé du préfixethismot-clé. L'exemple suivant explique la même chose -

Exemple

L'exemple suivant explique comment utiliser le this mot-clé dans Dart -

void main() { 
   Car c1 = new Car('E1001'); 
}  
class Car { 
   String engine; 
   Car(String engine) { 
      this.engine = engine; 
      print("The engine is : ${engine}"); 
   } 
}

Il devrait produire ce qui suit output -

The engine is : E1001

Classe de fléchettes ─ Getters et Setters

Getters et Setters, également appelé accessors et mutators, permettent au programme d'initialiser et de récupérer respectivement les valeurs des champs de classe. Les getters ou accesseurs sont définis à l'aide dugetmot-clé. Les setters ou mutators sont définis à l'aide duset mot-clé.

Un getter / setter par défaut est associé à chaque classe. Cependant, ceux par défaut peuvent être remplacés en définissant explicitement un setter / getter. Un getter n'a pas de paramètres et renvoie une valeur, et le setter a un paramètre et ne renvoie pas de valeur.

Syntaxe: Définition d'un getter

Return_type  get identifier 
{ 
}

Syntaxe: Définition d'un setter

set identifier 
{ 
}

Exemple

L'exemple suivant montre comment utiliser getters et setters dans une classe Dart -

class Student { 
   String name; 
   int age; 
    
   String get stud_name { 
      return name; 
   } 
    
   void set stud_name(String name) { 
      this.name = name; 
   } 
   
   void set stud_age(int age) { 
      if(age<= 0) { 
        print("Age should be greater than 5"); 
      }  else { 
         this.age = age; 
      } 
   } 
   
   int get stud_age { 
      return age;     
   } 
}  
void main() { 
   Student s1 = new Student(); 
   s1.stud_name = 'MARK'; 
   s1.stud_age = 0; 
   print(s1.stud_name); 
   print(s1.stud_age); 
}

Ce code de programme doit produire les éléments suivants output -

Age should be greater than 5 
MARK 
Null

Héritage de classe

Dart prend en charge le concept d'héritage qui est la capacité d'un programme à créer de nouvelles classes à partir d'une classe existante. La classe qui est étendue pour créer des classes plus récentes est appelée la classe parent / super classe. Les classes nouvellement créées sont appelées les classes enfants / sous.

Une classe hérite d'une autre classe à l'aide du mot-clé 'extend'. Child classes inherit all properties and methods except constructors from the parent class.

Syntaxe

class child_class_name extends parent_class_name

Note - Dart ne prend pas en charge l'héritage multiple.

Exemple: héritage de classe

Dans l'exemple suivant, nous déclarons une classe Shape. La classe est étendue par leCircleclasse. Puisqu'il existe une relation d'héritage entre les classes, la classe enfant, c'est-à-dire la classeCar obtient un accès implicite à son membre de données de classe parent.

void main() { 
   var obj = new Circle(); 
   obj.cal_area(); 
}  
class Shape { 
   void cal_area() { 
      print("calling calc area defined in the Shape class"); 
   } 
}  
class Circle extends Shape {}

Il devrait produire ce qui suit output -

calling calc area defined in the Shape class

Types d'héritage

L'héritage peut être des trois types suivants -

• Single - Chaque classe peut au plus s'étendre à partir d'une classe parent.

• Multiple- Une classe peut hériter de plusieurs classes. Dart ne prend pas en charge l'héritage multiple.

• Multi-level - Une classe peut hériter d'une autre classe enfant.

Exemple

L'exemple suivant montre comment fonctionne l'héritage à plusieurs niveaux -

void main() { 
   var obj = new Leaf(); 
   obj.str = "hello"; 
   print(obj.str); 
}  
class Root { 
   String str; 
}  
class Child extends Root {}  
class Leaf extends Child {}  
//indirectly inherits from Root by virtue of inheritance

La classe Leafdérive les attributs des classes Root et Child en vertu de l'héritage à plusieurs niveaux. Sesoutput est comme suit -

hello

Dart - Héritage de classe et remplacement de méthode

Le remplacement de méthode est un mécanisme par lequel la classe enfant redéfinit une méthode dans sa classe parent. L'exemple suivant illustre la même chose -

Exemple

void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   void m1(int a){ print("value of a ${a}");} } class Child extends Parent { @override void m1(int b) { print("value of b ${b}"); 
   } 
}

Il devrait produire ce qui suit output -

value of b 12

Le nombre et le type des paramètres de fonction doivent correspondre lors de la substitution de la méthode. En cas de non-concordance du nombre de paramètres ou de leur type de données, le compilateur Dart renvoie une erreur. L'illustration suivante explique la même chose -

import 'dart:io'; 
void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   void m1(int a){ print("value of a ${a}");} } class Child extends Parent { @override void m1(String b) { print("value of b ${b}");
   } 
}

Il devrait produire ce qui suit output -

value of b 12

Le mot-clé statique

le static Le mot-clé peut être appliqué aux données membres d'une classe, c'est-à-dire fields et methods. Une variable statique conserve ses valeurs jusqu'à la fin de l'exécution du programme. Les membres statiques sont référencés par le nom de la classe.

Exemple

class StaticMem { 
   static int num;  
   static disp() { 
      print("The value of num is ${StaticMem.num}")  ; 
   } 
}  
void main() { 
   StaticMem.num = 12;  
   // initialize the static variable } 
   StaticMem.disp();   
   // invoke the static method 
}

Il devrait produire ce qui suit output -

The value of num is 12

Le super mot-clé

le superLe mot clé est utilisé pour faire référence au parent immédiat d'une classe. Le mot-clé peut être utilisé pour faire référence à la version super classe d'unvariable, property, ou method. L'exemple suivant illustre la même chose -

Exemple

void main() { 
   Child c = new Child(); 
   c.m1(12); 
} 
class Parent { 
   String msg = "message variable from the parent class"; 
   void m1(int a){ print("value of a ${a}");} 
} 
class Child extends Parent { 
   @override 
   void m1(int b) { 
      print("value of b ${b}"); super.m1(13); print("${super.msg}")   ; 
   } 
}

Il devrait produire ce qui suit output -

value of b 12 
value of a 13 
message variable from the parent class

La programmation orientée objet définit un objet comme «toute entité ayant une limite définie». Un objet a ce qui suit -

• State- Décrit l'objet. Les champs d'une classe représentent l'état de l'objet.

• Behavior - Décrit ce qu'un objet peut faire.

• Identity- Une valeur unique qui distingue un objet d'un ensemble d'autres objets similaires. Deux objets ou plus peuvent partager l'état et le comportement, mais pas l'identité.

L'opérateur d'époque (.) est utilisé en conjonction avec l'objet pour accéder aux données membres d'une classe.

Exemple

Dart représente des données sous forme d'objets. Chaque classe de Dart étend la classe Object. Vous trouverez ci-dessous un exemple simple de création et d'utilisation d'un objet.

class Student { 
   void test_method() { 
      print("This is a  test method"); 
   } 
   
   void test_method1() { 
      print("This is a  test method1"); 
   } 
}  
void main()    { 
   Student s1 = new Student(); 
   s1.test_method(); 
   s1.test_method1(); 
}

Il devrait produire ce qui suit output -

This is a test method 
This is a test method1

L'opérateur Cascade (..)

L'exemple ci-dessus appelle les méthodes de la classe. Cependant, chaque fois qu'une fonction est appelée, une référence à l'objet est requise. lecascade operator peut être utilisé comme un raccourci dans les cas où il y a une séquence d'invocations.

L'opérateur cascade (..) peut être utilisé pour émettre une séquence d'appels via un objet. L'exemple ci-dessus peut être réécrit de la manière suivante.

class Student { 
   void test_method() { 
      print("This is a  test method"); 
   } 
   
   void test_method1() { 
      print("This is a  test method1"); 
   } 
}  
void main() { 
   new Student() 
   ..test_method() 
   ..test_method1(); 
}

Il devrait produire ce qui suit output -

This is a test method 
This is a test method1

La méthode toString ()

Cette fonction renvoie une représentation sous forme de chaîne d'un objet. Jetez un œil à l'exemple suivant pour comprendre comment utiliser letoString méthode.

void main() { 
   int n = 12; 
   print(n.toString()); 
}

Il devrait produire ce qui suit output -

12

Dart, contrairement aux autres langages de programmation, ne prend pas en charge les tableaux. Les collections Dart peuvent être utilisées pour répliquer des structures de données comme un tableau. La bibliothèque dart: core et d'autres classes activent la prise en charge de Collection dans les scripts Dart.

Les collections de fléchettes peuvent être essentiellement classées comme -

Sr.Non	Collection de fléchettes et description
1	liste Une liste est simplement un groupe ordonné d'objets. ledart:core La bibliothèque fournit la classe List qui permet la création et la manipulation de listes. Fixed Length List - La longueur de la liste ne peut pas changer au moment de l'exécution. Growable List - La longueur de la liste peut changer au moment de l'exécution.
2	Ensemble Set représente une collection d'objets dans laquelle chaque objet ne peut apparaître qu'une seule fois. La bibliothèque dart: core fournit la classe Set pour implémenter la même chose.
3	Plans L'objet Map est une simple paire clé / valeur. Les clés et les valeurs d'une carte peuvent être de n'importe quel type. Une carte est une collection dynamique. En d'autres termes, Maps peut croître et se réduire au moment de l'exécution. La classe Map de la bibliothèque dart: core en fournit le support.
4	Queue Une file d'attente est une collection qui peut être manipulée aux deux extrémités. Les files d'attente sont utiles lorsque vous souhaitez créer une collection premier entré, premier sorti. En termes simples, une file d'attente insère des données à une extrémité et les supprime à une autre extrémité. Les valeurs sont supprimées / lues dans l'ordre de leur insertion.

Collections itératives

La classe Iterator du dart:coreLa bibliothèque permet de parcourir facilement les collections. Chaque collection a uniteratorpropriété. Cette propriété renvoie un itérateur qui pointe vers les objets de la collection.

Exemple

L'exemple suivant illustre le parcours d'une collection à l'aide d'un objet itérateur.

import 'dart:collection'; 
void main() { 
   Queue numQ = new Queue(); 
   numQ.addAll([100,200,300]);  
   Iterator i= numQ.iterator; 
   
   while(i.moveNext()) { 
      print(i.current); 
   } 
}

le moveNext()La fonction renvoie une valeur booléenne indiquant s'il y a une entrée ultérieure. lecurrent propriété de l'objet itérateur renvoie la valeur de l'objet vers lequel l'itérateur pointe actuellement.

Ce programme devrait produire les éléments suivants output -

100 
200 
300

Dart est un optionally typed language. Les collections dans Dart sont hétérogènes par défaut. En d'autres termes, une seule collection Dart peut héberger des valeurs de différents types. Cependant, une collection Dart peut être conçue pour contenir des valeurs homogènes. Le concept de génériques peut être utilisé pour atteindre la même chose.

L'utilisation de Generics impose une restriction sur le type de données des valeurs pouvant être contenues dans la collection. Ces collections sont appelées collections de type sécurisé. La sécurité de type est une fonction de programmation qui garantit qu'un bloc de mémoire ne peut contenir que des données d'un type de données spécifique.

Toutes les collections Dart prennent en charge la mise en œuvre de la sécurité de type via des génériques. Une paire de crochets angulaires contenant le type de données est utilisée pour déclarer une collection de type sécurisé. La syntaxe pour déclarer une collection de type sécurisé est la suivante.

Syntaxe

Collection_name <data_type> identifier= new Collection_name<data_type>

Les implémentations de type sécurisé de List, Map, Set et Queue sont données ci-dessous. Cette fonctionnalité est également prise en charge par toutes les implémentations des types de collection mentionnés ci-dessus.

Exemple: liste générique

void main() { 
   List <String> logTypes = new List <String>(); 
   logTypes.add("WARNING"); 
   logTypes.add("ERROR"); 
   logTypes.add("INFO");  
   
   // iterating across list 
   for (String type in logTypes) { 
      print(type); 
   } 
}

Il devrait produire ce qui suit output -

WARNING 
ERROR 
INFO

Une tentative d'insertion d'une valeur autre que le type spécifié entraînera une erreur de compilation. L'exemple suivant illustre cela.

Exemple

void main() { 
   List <String> logTypes = new List <String>(); 
   logTypes.add(1); 
   logTypes.add("ERROR"); 
   logTypes.add("INFO"); 
  
   //iterating across list 
   for (String type in logTypes) { 
      print(type); 
   } 
}

Il devrait produire ce qui suit output -

1                                                                                     
ERROR                                                                             
INFO

Exemple: ensemble générique

void main() { 
   Set <int>numberSet = new  Set<int>(); 
   numberSet.add(100); 
   numberSet.add(20); 
   numberSet.add(5); 
   numberSet.add(60);
   numberSet.add(70); 
   
   // numberSet.add("Tom"); 
   compilation error; 
   print("Default implementation  :${numberSet.runtimeType}");  
   
   for(var no in numberSet) { 
      print(no); 
   } 
}

Il devrait produire ce qui suit output -

Default implementation :_CompactLinkedHashSet<int> 
100 
20 
5 
60 
70

Exemple: file d'attente générique

import 'dart:collection'; 
void main() { 
   Queue<int> queue = new Queue<int>(); 
   print("Default implementation ${queue.runtimeType}");  
   queue.addLast(10); 
   queue.addLast(20); 
   queue.addLast(30); 
   queue.addLast(40); 
   queue.removeFirst();  
   
   for(int no in queue){ 
      print(no); 
   } 
}

Il devrait produire ce qui suit output -

Default implementation ListQueue<int> 
20 
30 
40

Carte générique

Une déclaration de carte de type sécurisé spécifie les types de données de -

• La clé
• La valeur

Syntaxe

Map <Key_type, value_type>

Exemple

void main() { 
   Map <String,String>m={'name':'Tom','Id':'E1001'}; 
   print('Map :${m}'); 
}

Il devrait produire ce qui suit output -

Map :{name: Tom, Id: E1001}

Un package est un mécanisme pour encapsuler un groupe d'unités de programmation. Les applications peuvent parfois nécessiter l'intégration de certaines bibliothèques ou plugins tiers. Chaque langage dispose d'un mécanisme de gestion des packages externes comme Maven ou Gradle pour Java, Nuget pour .NET, npm pour Node.js, etc. Le gestionnaire de packages pour Dart estpub.

Pub aide à installer des packages dans le référentiel. Le référentiel des packages hébergés se trouve surhttps://pub.dartlang.org/.

le package metadata est défini dans un fichier, pubsec.yaml. YAML est l'acronyme deYet Another Markup Language. lepub L'outil peut être utilisé pour télécharger toutes les bibliothèques diverses requises par une application.

Chaque application Dart a un pubspec.yaml fichier qui contient les dépendances de l'application avec d'autres bibliothèques et les métadonnées des applications telles que le nom de l'application, l'auteur, la version et la description.

Le contenu d'un pubspec.yaml le fichier devrait ressembler à ceci -

name: 'vector_victor' 
version: 0.0.1 
description: An absolute bare-bones web app. 
... 
dependencies: browser: '>=0.10.0 <0.11.0'

L'important pub commands sont comme suit -

Sr.Non	Commande et description
1	‘pub get’ Aide à obtenir tous les packages dont dépend votre application.
2	‘pub upgrade’ Met à niveau toutes vos dépendances vers une version plus récente.
3	‘pub build’ Ceci est utilisé pour construire votre application Web et il créera un dossier de construction, avec tous les scripts associés.
4	‘pub help’ Cela vous aidera pour toutes les différentes commandes de pub.

Si vous utilisez un IDE comme WebStorm, vous pouvez cliquer avec le bouton droit sur pubspec.yaml pour obtenir directement toutes les commandes -

Installer un package

Prenons un exemple où une application doit analyser xml. Dart XML est une bibliothèque légère, open source et stable pour l'analyse, le parcours, l'interrogation et la création de documents XML.

Les étapes pour réaliser ladite tâche sont les suivantes -

Step 1 - Ajoutez ce qui suit au fichier pubsec.yaml.

name: TestApp 
version: 0.0.1 
description: A simple console application. 
#dependencies: 
#  foo_bar: '>=1.0.0 <2.0.0' 
dependencies: https://mail.google.com/mail/u/0/images/cleardot.gif
xml:

Faites un clic droit sur le pubsec.yamlet obtenez les dépendances. Cela déclenchera en interne lepub get command comme indiqué ci-dessous.

Les packages téléchargés et ses packages dépendants peuvent être vérifiés dans le dossier packages.

Puisque l'installation est maintenant terminée, nous devons renvoyer le dart xmldans le projet. La syntaxe est la suivante -

import 'package:xml/xml.dart' as xml;

Lire la chaîne XML

Pour lire la chaîne XML et vérifier l'entrée, Dart XML utilise un parse()méthode. La syntaxe est la suivante -

xml.parse(String input):

Exemple: analyse de l'entrée de chaîne XML

L'exemple suivant montre comment analyser une entrée de chaîne XML -

import 'package:xml/xml.dart' as xml; 
void main(){ 
   print("xml"); 
   var bookshelfXml = '''<?xml version = "1.0"?> 
   <bookshelf> 
      <book> 
         <title lang = "english">Growing a Language</title> 
         <price>29.99</price> 
      </book> 
      
      <book> 
         <title lang = "english">Learning XML</title> 
         <price>39.95</price> 
      </book> 
      <price>132.00</price> 
   </bookshelf>'''; 
   
   var document = xml.parse(bookshelfXml); 
   print(document.toString()); 
}

Il devrait produire ce qui suit output -

xml 
<?xml version = "1.0"?><bookshelf> 
   <book> 
      <title lang = "english">Growing a Language</title> 
      <price>29.99</price> 
   </book> 

   <book> 
      <title lang = "english">Learning XML</title> 
      <price>39.95</price> 
   </book> 
   <price>132.00</price> 
</bookshelf>

Une exception (ou événement exceptionnel) est un problème qui survient lors de l'exécution d'un programme. Lorsqu'une exception se produit, le déroulement normal du programme est interrompu et le programme / l'application se termine anormalement.

Les exceptions Dart intégrées incluent -

Sr.Non	Exceptions et description
1	DeferredLoadException Lancé lorsqu'une bibliothèque différée ne parvient pas à se charger.
2	FormatException Exception levée lorsqu'une chaîne ou certaines autres données n'ont pas un format attendu et ne peuvent pas être analysées ou traitées.
3	IntegerDivisionByZeroException Lancé lorsqu'un nombre est divisé par zéro.
4	IOException Classe de base pour toutes les exceptions liées à Inupt-Output.
5	IsolateSpawnException Lancé lorsqu'un isolat ne peut pas être créé.
6	Timeout Lancé lorsqu'un délai d'expiration planifié se produit en attendant un résultat asynchrone.

Chaque exception dans Dart est un sous-type de la classe prédéfinie Exception. Les exceptions doivent être gérées pour empêcher l'application de se terminer brusquement.

Les blocs try / on / catch

le tryblock incorpore du code qui pourrait éventuellement entraîner une exception. Le bloc on est utilisé lorsque le type d'exception doit être spécifié. lecatch block est utilisé lorsque le gestionnaire a besoin de l'objet d'exception.

le try le bloc doit être suivi par soit exactement un on / catch bloc ou un finallybloc (ou l'un des deux). Lorsqu'une exception se produit dans le bloc try, le contrôle est transféré vers lecatch.

le syntax pour gérer une exception est comme indiqué ci-dessous -

try { 
   // code that might throw an exception 
}  
on Exception1 { 
   // code for handling exception 
}  
catch Exception2 { 
   // code for handling exception 
}

Voici quelques points à retenir -

• Un extrait de code peut avoir plusieurs blocs on / catch pour gérer plusieurs exceptions.

• Le bloc on et le bloc catch sont mutuellement inclusifs, c'est-à-dire qu'un bloc try peut être associé à la fois au bloc on et au bloc catch.

Le code suivant illustre la gestion des exceptions dans Dart -

Exemple: utilisation du bloc ON

Le programme suivant divise deux nombres représentés par les variables x et yrespectivement. Le code lève une exception car il tente une division par zéro. leon block contient le code pour gérer cette exception.

main() { 
   int x = 12; 
   int y = 0; 
   int res;  
   
   try {
      res = x ~/ y; 
   } 
   on IntegerDivisionByZeroException { 
      print('Cannot divide by zero'); 
   } 
}

Il devrait produire ce qui suit output -

Cannot divide by zero

Exemple: utilisation du bloc catch

Dans l'exemple suivant, nous avons utilisé le même code que ci-dessus. La seule différence est que lecatch block(au lieu du bloc ON) contient ici le code pour gérer l'exception. Le paramètre decatch contient l'objet d'exception lancé lors de l'exécution.

main() { 
   int x = 12; 
   int y = 0; 
   int res;  
   
   try {  
      res = x ~/ y; 
   }  
   catch(e) { 
      print(e); 
   } 
}

Il devrait produire ce qui suit output -

IntegerDivisionByZeroException

Exemple: sur… catch

L'exemple suivant montre comment utiliser le on...catch bloquer.

main() { 
   int x = 12; 
   int y = 0; 
   int res;  
   
   try { 
      res = x ~/ y; 
   }  
   on IntegerDivisionByZeroException catch(e) { 
      print(e); 
   } 
}

Il devrait produire ce qui suit output -

IntegerDivisionByZeroException

Le bloc Final

le finallyblock inclut du code qui doit être exécuté indépendamment de l'occurrence d'une exception. L'optionfinally le bloc s'exécute sans condition après try/on/catch.

La syntaxe d'utilisation de finally bloc est comme suit -

try { 
   // code that might throw an exception 
}  
on Exception1 { 
   // exception handling code 
}  
catch Exception2 { 
   //  exception handling 
}  
finally { 
   // code that should always execute; irrespective of the exception 
}

L'exemple suivant illustre l'utilisation de finally bloquer.

main() { 
   int x = 12; 
   int y = 0; 
   int res;  
   
   try { 
      res = x ~/ y; 
   } 
   on IntegerDivisionByZeroException { 
      print('Cannot divide by zero'); 
   } 
   finally { 
      print('Finally block executed'); 
   } 
}

Il devrait produire ce qui suit output -

Cannot divide by zero 
Finally block executed

Lancer une exception

le throwLe mot clé est utilisé pour déclencher explicitement une exception. Une exception levée doit être gérée pour empêcher le programme de se fermer brusquement.

le syntax pour lever une exception explicitement est -

throw new Exception_name()

Exemple

L'exemple suivant montre comment utiliser le throw mot-clé pour lancer une exception -

main() { 
   try { 
      test_age(-2); 
   } 
   catch(e) { 
      print('Age cannot be negative'); 
   } 
}  
void test_age(int age) { 
   if(age<0) { 
      throw new FormatException(); 
   } 
}

Il devrait produire ce qui suit output -

Age cannot be negative

Exceptions personnalisées

Comme spécifié ci-dessus, chaque type d'exception dans Dart est un sous-type de la classe intégrée Exception. Dart permet de créer des exceptions personnalisées en étendant celles existantes. La syntaxe pour définir une exception personnalisée est la suivante -

Syntaxe: définition de l'exception

class Custom_exception_Name implements Exception { 
   // can contain constructors, variables and methods 
}

Les exceptions personnalisées doivent être déclenchées explicitement et la même chose doit être gérée dans le code.

Exemple

L'exemple suivant montre comment définir et gérer une exception personnalisée.

class AmtException implements Exception { 
   String errMsg() => 'Amount should be greater than zero'; 
}  
void main() { 
   try { 
      withdraw_amt(-1); 
   } 
   catch(e) { 
      print(e.errMsg()); 
   }  
finally { 
      print('Ending requested operation.....'); 
   } 
}  
void withdraw_amt(int amt) { 
   if (amt <= 0) { 
      throw new AmtException(); 
   } 
}

Dans le code ci-dessus, nous définissons une exception personnalisée, AmtException. Le code lève l'exception si le montant passé n'est pas dans la plage exceptée. lemain function englobe l'invocation de la fonction dans le try...catch bloquer.

Le code doit produire les éléments suivants output -

Amount should be greater than zero 
Ending requested operation....

De temps en temps, les développeurs commettent des erreurs lors du codage. Une erreur dans un programme est appelée bogue. Le processus de recherche et de correction des bogues s'appelle le débogage et fait partie intégrante du processus de développement. Cette section couvre les outils et techniques qui peuvent vous aider dans les tâches de débogage.

L'éditeur WebStorm active les points d'arrêt et le débogage étape par étape. Le programme s'arrêtera au point où le point d'arrêt est attaché. Cette fonctionnalité est similaire à ce que vous attendez du développement d'applications Java ou C #. Vous pouvez regarder les variables, parcourir la pile, avancer et passer aux appels de méthode et de fonction, le tout depuis l'éditeur WebStorm.

Ajout d'un point d'arrêt

Considérez l'extrait de code suivant. (TestString.dart)

void main() { 
   int a = 10, b = 20, c = 5; 
   c = c * c * c; 
   
   print("$a + $b = ${a+b}"); 
   print("$a%$b = ${a%b}"); // Add a break point here print("$a*$b = ${a*b}"); 
   print("$a/$b = ${a/b}"); 
   print(c); 
}

À add a breakpoint, cliquez sur la marge gauche pour. Dans la figure ci-dessous, la ligne numéro 7 a un point de rupture.

Run the program in debug mode. Dans l'explorateur de projet, cliquez avec le bouton droit sur le programme de fléchettes dans notre cas TestString.dart.

Une fois que le programme s'exécute en mode débogage, vous obtiendrez la fenêtre Débogueur comme indiqué dans la capture d'écran suivante. L'onglet Variables affiche les valeurs des variables dans le contexte actuel. Vous pouvez ajouter des observateurs pour des variables spécifiques et écouter les changements de valeurs à l'aide de la fenêtre de surveillance.

Step Into(F7) icône de flèche sur le menu de débogage permet d'exécuter le code une instruction à la fois. Si les méthodes principales appellent un sous-programme, celui-ci ira également dans le code du sous-programme.

Step over (F8): C'est similaire à Step Into. La différence d'utilisation se produit lorsque l'instruction courante contient un appel à un sous-programme. Si la méthode main appelle un sous-programme, pas à pas n'explorera pas le sous-programme. il sautera le sous-programme.

Step Out(Maj + F8): Exécute les lignes restantes d'une fonction dans laquelle se trouve le point d'exécution actuel. L'instruction suivante affichée est l'instruction suivant l'appel du sous-programme.

Après avoir exécuté en mode débogage, le programme donne ce qui suit output -

10 + 20 = 30 
10 % 20 = 10 
10 * 20 = 200 
10 / 20 = 0.5 
125

UNE typedef, ou un alias de type fonction, permet de définir des pointeurs vers le code exécutable dans la mémoire. En termes simples, untypedef peut être utilisé comme un pointeur qui référence une fonction.

Voici les étapes à suivre pour mettre en œuvre typedefs dans un programme Dart.

Step 1: Defining a typedef

UNE typedefpeut être utilisé pour spécifier une signature de fonction à laquelle nous voulons que des fonctions spécifiques correspondent. Une signature de fonction est définie par les paramètres d'une fonction (y compris leurs types). Le type de retour ne fait pas partie de la signature de la fonction. Sa syntaxe est la suivante.

typedef function_name(parameters)

Step 2: Assigning a Function to a typedef Variable

Une variable de typedef peut pointer vers n'importe quelle fonction ayant la même signature que typedef. Vous pouvez utiliser la signature suivante pour attribuer une fonction à untypedef variable.

type_def  var_name = function_name

Step 3: Invoking a Function

le typedefvariable peut être utilisée pour appeler des fonctions. Voici comment appeler une fonction -

var_name(parameters)

Exemple

Prenons maintenant un exemple pour en savoir plus sur typedef dans Dart.

Dans un premier temps, définissons un typedef. Ici, nous définissons une signature de fonction. La fonction prendra deux paramètres d'entrée du typeinteger. Le type de retour ne fait pas partie de la signature de la fonction.

typedef ManyOperation(int firstNo , int secondNo); //function signature

Ensuite, définissons les fonctions. Définissez certaines fonctions avec la même signature de fonction que celle duManyOperation typedef.

Add(int firstNo,int second){ 
   print("Add result is ${firstNo+second}"); 
}  
Subtract(int firstNo,int second){ 
   print("Subtract result is ${firstNo-second}"); } Divide(int firstNo,int second){ print("Add result is ${firstNo/second}"); 
}

Enfin, nous invoquerons la fonction via typedef. Déclarez une variable de type ManyOperations. Attribuez le nom de la fonction à la variable déclarée.

ManyOperation oper ;  

//can point to any method of same signature 
oper = Add; 
oper(10,20); 
oper = Subtract; 
oper(30,20); 
oper = Divide; 
oper(50,5);

le opervariable peut pointer vers n'importe quelle méthode qui prend deux paramètres entiers. leAddla référence de la fonction est affectée à la variable. Les typedefs peuvent changer les références de fonction au moment de l'exécution

Assemblons maintenant toutes les parties et voyons le programme complet.

typedef ManyOperation(int firstNo , int secondNo); 
//function signature  

Add(int firstNo,int second){ 
   print("Add result is ${firstNo+second}"); } Subtract(int firstNo,int second){ print("Subtract result is ${firstNo-second}"); 
}
Divide(int firstNo,int second){ 
   print("Divide result is ${firstNo/second}"); 
}  
Calculator(int a, int b, ManyOperation oper){ 
   print("Inside calculator"); 
   oper(a,b); 
}  
void main(){ 
   ManyOperation oper = Add; 
   oper(10,20); 
   oper = Subtract; 
   oper(30,20); 
   oper = Divide; 
   oper(50,5); 
}

Le programme doit produire les éléments suivants output -

Add result is 30 
Subtract result is 10 
Divide result is 10.0

Note - Le code ci-dessus entraînera une erreur si le typedef variable essaie de pointer vers une fonction avec une signature de fonction différente.

Exemple

Typedefspeut également être passé en paramètre à une fonction. Prenons l'exemple suivant -

typedef ManyOperation(int firstNo , int secondNo);   //function signature 
Add(int firstNo,int second){ 
   print("Add result is ${firstNo+second}"); 
}  
Subtract(int firstNo,int second){
   print("Subtract result is ${firstNo-second}"); } Divide(int firstNo,int second){ print("Divide result is ${firstNo/second}"); 
}  
Calculator(int a,int b ,ManyOperation oper){ 
   print("Inside calculator"); 
   oper(a,b); 
}  
main(){ 
   Calculator(5,5,Add); 
   Calculator(5,5,Subtract); 
   Calculator(5,5,Divide); 
}

Il produira ce qui suit output -

Inside calculator 
Add result is 10 
Inside calculator 
Subtract result is 0 
Inside calculator 
Divide result is 1.0

Une bibliothèque dans un langage de programmation représente une collection de routines (ensemble d'instructions de programmation). Dart possède un ensemble de bibliothèques intégrées utiles pour stocker les routines fréquemment utilisées. Une bibliothèque Dart comprend un ensemble de classes, constantes, fonctions, typedefs, propriétés et exceptions.

Importer une bibliothèque

L'importation rend les composants d'une bibliothèque disponibles pour le code de l'appelant. Le mot-clé import est utilisé pour réaliser la même chose. Un fichier de fléchettes peut avoir plusieurs instructions d'importation.

Les URI de bibliothèque Dart intégrés utilisent le schéma dart: pour faire référence à une bibliothèque. D'autres bibliothèques peuvent utiliser un chemin d'accès au système de fichiers ou le package: schéma pour spécifier son URI. Les bibliothèques fournies par un gestionnaire de packages tel que l'outil pub utilisent le package: schéma .

La syntaxe pour importer une bibliothèque dans Dart est donnée ci-dessous -

import 'URI'

Considérez l'extrait de code suivant -

import 'dart:io' 
import 'package:lib1/libfile.dart'

Si vous souhaitez n'utiliser qu'une partie d'une bibliothèque, vous pouvez importer la bibliothèque de manière sélective. La syntaxe pour le même est donnée ci-dessous -

import 'package: lib1/lib1.dart' show foo, bar;  
// Import only foo and bar. 

import 'package: mylib/mylib.dart' hide foo;  
// Import all names except foo

Certaines bibliothèques couramment utilisées sont données ci-dessous -

Sr.Non	Bibliothèque et description
1	dart:io Prise en charge des fichiers, socket, HTTP et autres E / S pour les applications serveur. Cette bibliothèque ne fonctionne pas dans les applications basées sur un navigateur. Cette bibliothèque est importée par défaut.
2	dart:core Types intégrés, collections et autres fonctionnalités de base pour chaque programme Dart. Cette bibliothèque est automatiquement importée.
3	dart: math Constantes et fonctions mathématiques, plus un générateur de nombres aléatoires.
4	dart: convert Encodeurs et décodeurs pour la conversion entre différentes représentations de données, y compris JSON et UTF-8.
5	dart: typed_data Listes qui gèrent efficacement des données de taille fixe (par exemple, des entiers de 8 octets non signés).

Exemple: importation et utilisation d'une bibliothèque

L'exemple suivant importe la bibliothèque intégrée dart: math. L'extrait appelle lesqrt() fonction de la mathbibliothèque. Cette fonction renvoie la racine carrée d'un nombre qui lui est passé.

import 'dart:math'; 
void main() { 
   print("Square root of 36 is: ${sqrt(36)}"); 
}

Output

Square root of 36 is: 6.0

Encapsulation dans les bibliothèques

Les scripts Dart peuvent préfixer les identificateurs avec un trait de soulignement (_) pour marquer ses composants comme privés. En termes simples, les bibliothèques Dart peuvent restreindre l'accès à son contenu par des scripts externes. Ceci est appeléencapsulation. La syntaxe pour le même est donnée ci-dessous -

Syntaxe

_identifier

Exemple

Dans un premier temps, définissez une bibliothèque avec une fonction privée.

library loggerlib;                            
void _log(msg) {
   print("Log method called in loggerlib msg:$msg");      
}

Ensuite, importez la bibliothèque

import 'test.dart' as web; 
void main() { 
   web._log("hello from webloggerlib"); 
}

Le code ci-dessus entraînera une erreur.

Unhandled exception: 
No top-level method 'web._log' declared.  
NoSuchMethodError: method not found: 'web._log' 
Receiver: top-level 
Arguments: [...] 
#0 NoSuchMethodError._throwNew (dart:core-patch/errors_patch.dart:184) 
#1 main (file:///C:/Users/Administrator/WebstormProjects/untitled/Assertion.dart:6:3) 
#2 _startIsolate.<anonymous closure> (dart:isolate-patch/isolate_patch.dart:261) 
#3 _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

Création de bibliothèques personnalisées

Dart vous permet également d'utiliser votre propre code comme bibliothèque. La création d'une bibliothèque personnalisée implique les étapes suivantes -

Step 1: Declaring a Library

Pour déclarer explicitement une bibliothèque, utilisez le library statement. La syntaxe pour déclarer une bibliothèque est la suivante -

library library_name  
// library contents go here

Step 2: Associating a Library

Vous pouvez associer une bibliothèque de deux manières -

• Dans le même répertoire

import 'library_name'

• Depuis un autre répertoire

import 'dir/library_name'

Exemple: bibliothèque personnalisée

Tout d'abord, définissons une bibliothèque personnalisée, calculator.dart.

library calculator_lib;  
import 'dart:math'; 

//import statement after the libaray statement  
int add(int firstNumber,int secondNumber){ 
   print("inside add method of Calculator Library ") ; 
   return firstNumber+secondNumber; 
}  
int modulus(int firstNumber,int secondNumber){ 
   print("inside modulus method of Calculator Library ") ; 
   return firstNumber%secondNumber; 
}  
int random(int no){ 
   return new Random().nextInt(no); 
}

Ensuite, nous allons importer la bibliothèque -

import 'calculator.dart';  
void main() {
   var num1 = 10; 
   var num2 = 20; 
   var sum = add(num1,num2); 
   var mod = modulus(num1,num2); 
   var r = random(10);  
   
   print("$num1 + $num2 = $sum"); print("$num1 % $num2= $mod"); 
   print("random no $r"); 
}

Le programme doit produire les éléments suivants output -

inside add method of Calculator Library  
inside modulus method of Calculator Library  
10 + 20 = 30 
10 % 20= 10 
random no 0

Préfixe de bibliothèque

Si vous importez deux bibliothèques avec des identificateurs en conflit, vous pouvez spécifier un préfixe pour une ou les deux bibliothèques. Utilisez le'as'mot-clé pour spécifier le préfixe. La syntaxe pour le même est donnée ci-dessous -

Syntaxe

import 'library_uri' as prefix

Exemple

Tout d'abord, définissons une bibliothèque: loggerlib.dart.

library loggerlib;  
void log(msg){ 
   print("Log method called in loggerlib msg:$msg");
}

Ensuite, nous définirons une autre bibliothèque: webloggerlib.dart.

library webloggerlib; 
void log(msg){ 
   print("Log method called in webloggerlib msg:$msg"); 
}

Enfin, nous importerons la bibliothèque avec un préfixe.

import 'loggerlib.dart'; 
import 'webloggerlib.dart' as web;  

// prefix avoids function name clashes 
void main(){ 
   log("hello from loggerlib"); 
   web.log("hello from webloggerlib"); 
}

Il produira ce qui suit output -

Log method called in loggerlib msg:hello from loggerlib 
Log method called in webloggerlib msg:hello from webloggerlib

Un asynchronous operation s'exécute dans un thread, séparé du mainfil de l'application. Lorsqu'une application appelle une méthode pour effectuer une opération de manière asynchrone, l'application peut continuer à s'exécuter pendant que la méthode asynchrone exécute sa tâche.

Exemple

Prenons un exemple pour comprendre ce concept. Ici, le programme accepte l'entrée de l'utilisateur à l'aide duIO library.

import 'dart:io'; 
void main() { 
   print("Enter your name :");            
   
   // prompt for user input 
   String name = stdin.readLineSync();  
   
   // this is a synchronous method that reads user input 
   print("Hello Mr. ${name}"); 
   print("End of main"); 
}

le readLineSync()est une méthode synchrone. Cela signifie que l'exécution de toutes les instructions qui suivent lereadLineSync() l'appel de fonction sera bloqué jusqu'à ce que readLineSync() la méthode termine l'exécution.

le stdin.readLineSyncattend l'entrée. Il s'arrête sur ses traces et ne s'exécute plus tant qu'il n'a pas reçu l'entrée de l'utilisateur.

L'exemple ci-dessus aboutira à ce qui suit output -

Enter your name :     
Tom                   

// reads user input  
Hello Mr. Tom 
End of main

En informatique, nous disons que quelque chose est synchronouslorsqu'il attend qu'un événement se produise avant de continuer. Un inconvénient de cette approche est que si une partie du code prend trop de temps à s'exécuter, les blocs suivants, bien que non liés, ne pourront pas s'exécuter. Considérez un serveur Web qui doit répondre à plusieurs demandes pour une ressource.

Un modèle d'exécution synchrone bloquera la demande de tous les autres utilisateurs jusqu'à ce qu'il termine le traitement de la demande en cours. Dans un tel cas, comme celui d'un serveur web, chaque requête doit être indépendante des autres. Cela signifie que le serveur Web ne doit pas attendre la fin de l'exécution de la demande en cours avant de répondre à la demande des autres utilisateurs.

En termes simples, il devrait accepter les demandes des nouveaux utilisateurs avant de nécessairement compléter les demandes des utilisateurs précédents. Ceci est appelé asynchrone. La programmation asynchrone signifie essentiellement pas de modèle de programmation en attente ou non bloquant. ledart:async package facilite l'implémentation de blocs de programmation asynchrones dans un script Dart.

Exemple

L'exemple suivant illustre mieux le fonctionnement d'un bloc asynchrone.

Step 1 - Créer un contact.txt fichier comme indiqué ci-dessous and enregistrez-le dans le dossier de données du projet en cours.

1, Tom 
2, John 
3, Tim 
4, Jane

Step 2 - Ecrire un programme qui lira le fichier sans bloquer les autres parties de l'application.

import "dart:async"; 
import "dart:io";  

void main(){ 
   File file = new File( Directory.current.path+"\\data\\contact.txt"); 
   Future<String> f = file.readAsString();  
  
   // returns a futrue, this is Async method 
   f.then((data)=>print(data));  
   
   // once file is read , call back method is invoked  
   print("End of main");  
   // this get printed first, showing fileReading is non blocking or async 
}

le output de ce programme sera comme suit -

End of main 
1, Tom 
2, John 
3, Tim 
4, Jan

La "fin de main" s'exécute en premier tandis que le script continue la lecture du fichier. leFuture classe, partie de dart:async, est utilisé pour obtenir le résultat d'un calcul après la fin d'une tâche asynchrone. CeFuture value est ensuite utilisée pour faire quelque chose une fois le calcul terminé.

Une fois l'opération de lecture terminée, le contrôle d'exécution est transféré dans "then()". En effet, l'opération de lecture peut prendre plus de temps et ne veut donc pas bloquer une autre partie du programme.

Dart Future

La communauté Dart définit un Futurecomme "un moyen d'obtenir une valeur dans le futur". Tout simplement,Future objectssont un mécanisme pour représenter les valeurs renvoyées par une expression dont l'exécution s'achèvera ultérieurement. Plusieurs classes intégrées de Dart renvoient unFuture lorsqu'une méthode asynchrone est appelée.

Dart est un langage de programmation à un seul thread. Si un code bloque le thread d'exécution (par exemple, en attendant une opération qui prend du temps ou en bloquant les E / S), le programme se fige effectivement.

Les opérations asynchrones permettent à votre programme de s'exécuter sans être bloqué. Dart utiliseFuture objects pour représenter des opérations asynchrones.

Concurrencyest l'exécution de plusieurs séquences d'instructions en même temps. Cela implique d'effectuer plus d'une tâche simultanément.

Dart utilise Isolatescomme outil pour faire des travaux en parallèle. ledart:isolate package est la solution de Dart pour prendre du code Dart monothread et permettre à l'application d'utiliser davantage le matériel disponible.

Isolates, comme son nom l'indique, sont des unités isolées de code en cours d'exécution. La seule façon d'envoyer des données entre eux est de passer des messages, comme la façon dont vous passez des messages entre le client et le serveur. Unisolate aide le programme à tirer parti des microprocesseurs multicœurs prêts à l'emploi.

Exemple

Prenons un exemple pour mieux comprendre ce concept.

import 'dart:isolate';  
void foo(var message){ 
   print('execution from foo ... the message is :${message}'); 
}  
void main(){ 
   Isolate.spawn(foo,'Hello!!'); 
   Isolate.spawn(foo,'Greetings!!'); 
   Isolate.spawn(foo,'Welcome!!'); 
   
   print('execution from main1'); 
   print('execution from main2'); 
   print('execution from main3'); 
}

Ici le spawn méthode de la Isolate classe facilite l'exécution d'une fonction, foo, en parallèle avec le reste de notre code. lespawn La fonction prend deux paramètres -

• la fonction à générer, et
• un objet qui sera passé à la fonction engendrée.

Dans le cas où il n'y a pas d'objet à transmettre à la fonction générée, une valeur NULL peut lui être transmise.

Les deux fonctions (foo and main)peut ne pas nécessairement fonctionner dans le même ordre à chaque fois. Il n'y a aucune garantie quant au momentfoo sera en cours d'exécution et quand main()sera en cours d’exécution. La sortie sera différente à chaque exécution.

Sortie 1

execution from main1 
execution from main2 
execution from main3 
execution from foo ... the message is :Hello!!

Sortie 2

execution from main1 
execution from main2 
execution from main3 
execution from foo ... the message is :Welcome!! 
execution from foo ... the message is :Hello!! 
execution from foo ... the message is :Greetings!!

À partir des sorties, nous pouvons conclure que le code Dart peut engendrer un nouveau isolate d'exécuter du code comme la façon dont le code Java ou C # peut démarrer un nouveau thread.

Isolates diffèrent des threads en ce qu'un isolatea sa propre mémoire. Il n'y a aucun moyen de partager une variable entreisolates—Le seul moyen de communiquer entre isolates est via la transmission de messages.

Note - La sortie ci-dessus sera différente pour différentes configurations matérielles et de système d'exploitation.

Isoler v / s Future

Effectuer un travail de calcul complexe de manière asynchrone est important pour garantir la réactivité des applications. Dart Future est un mécanisme pour récupérer la valeur d'une tâche asynchrone après son achèvement, tandis que Dart Isolates sont un outil pour résumer le parallélisme et le mettre en œuvre sur une base pratique de haut niveau.

Les tests unitaires consistent à tester chaque unité individuelle d'une application. Il aide le développeur à tester de petites fonctionnalités sans exécuter toute l'application complexe.

La fléchette external library nommé "test" fournit un moyen standard d'écrire et d'exécuter des tests unitaires.

Les tests unitaires Dart impliquent les étapes suivantes -

Step 1: Installing the "test" package

Pour installer des packages tiers dans le projet actuel, vous aurez besoin du pubspec.yamlfichier. À installertest packages, commencez par saisir l'entrée suivante dans le pubspec.yaml fichier -

dependencies: 
test:

Après avoir effectué la saisie, cliquez avec le bouton droit sur le pubspec.yamlfichier et obtenir les dépendances. Il installera le"test"paquet. Ci-dessous, une capture d'écran pour la même chose dans leWebStorm Éditeur.

Les packages peuvent être installés à partir du command lineaussi. Tapez ce qui suit dans le terminal -

pub get

Step 2: Importing the "test" package

import "package:test/test.dart";

Step 3 Writing Tests

Les tests sont spécifiés à l'aide de la fonction de niveau supérieur test(), tandis que test assertions sont fabriqués à l'aide du expect()fonction. Pour utiliser ces méthodes, elles doivent être installées en tant quepub dépendance.

Syntaxe

test("Description of the test ", () {  
   expect(actualValue , matchingValue) 
});

le group()La fonction peut être utilisée pour regrouper les tests. La description de chaque groupe est ajoutée au début des descriptions de son test.

Syntaxe

group("some_Group_Name", () { 
   test("test_name_1", () { 
      expect(actual, equals(exptected)); 
   });  
   test("test_name_2", () { 
      expect(actual, equals(expected)); 
   }); 
})

Exemple 1: Un test réussi

L'exemple suivant définit une méthode Add(). Cette méthode prend deux valeurs entières et renvoie un entier représentant lesum. Pour tester ceciadd() méthode -

Step 1 - Importez le test paquet comme indiqué ci-dessous.

Step 2 - Définissez le test à l'aide du test()fonction. Ici letest() utilise la fonction expect() fonction pour appliquer une assertion.

import 'package:test/test.dart';      
// Import the test package 

int Add(int x,int y)                  
// Function to be tested { 
   return x+y; 
}  
void main() { 
   // Define the test 
   test("test to check add method",(){  
      // Arrange 
      var expected = 30; 
      
      // Act 
      var actual = Add(10,20); 
      
      // Asset 
      expect(actual,expected); 
   }); 
}

Il devrait produire ce qui suit output -

00:00 +0: test to check add method 
00:00 +1: All tests passed!

Exemple 2: Un test échoué

le subtract()La méthode définie ci-dessous comporte une erreur logique. Le suivanttest vérifie la même chose.

import 'package:test/test.dart'; 
int Add(int x,int y){ 
   return x+y; 
}
int Sub(int x,int y){ 
   return x-y-1; 
}  
void main(){ 
   test('test to check sub',(){ 
      var expected = 10;   
      // Arrange 
      
      var actual = Sub(30,20);  
      // Act 
      
      expect(actual,expected);  
      // Assert 
   }); 
   test("test to check add method",(){ 
      var expected = 30;   
      // Arrange 
      
      var actual = Add(10,20);  
      // Act 
      
      expect(actual,expected);  
      // Asset 
   }); 
}

Output - Le cas de test de la fonction add() passe mais le test pour subtract() échoue comme indiqué ci-dessous.

00:00 +0: test to check sub 
00:00 +0 -1: test to check sub 
Expected: <10> 
Actual: <9> 
package:test  expect 
bin\Test123.dart 18:5  main.<fn> 
   
00:00 +0 -1: test to check add method 
00:00 +1 -1: Some tests failed.  
Unhandled exception: 
Dummy exception to set exit code. 
#0  _rootHandleUncaughtError.<anonymous closure> (dart:async/zone.dart:938) 
#1  _microtaskLoop (dart:async/schedule_microtask.dart:41)
#2  _startMicrotaskLoop (dart:async/schedule_microtask.dart:50) 
#3  _Timer._runTimers (dart:isolate-patch/timer_impl.dart:394) 
#4  _Timer._handleMessage (dart:isolate-patch/timer_impl.dart:414) 
#5  _RawReceivePortImpl._handleMessage (dart:isolate-patch/isolate_patch.dart:148)

Regroupement des cas de test

Vous pouvez regrouper les test casesafin qu'il ajoute plus de sens à votre code de test. Si vous en avez beaucouptest cases cela aide à écrire un code beaucoup plus propre.

Dans le code donné, nous écrivons un cas de test pour le split() fonction et le trimfonction. Par conséquent, nous regroupons logiquement ces cas de test et l'appelonsString.

Exemple

import "package:test/test.dart"; 
void main() { 
   group("String", () { 
      test("test on split() method of string class", () { 
         var string = "foo,bar,baz"; 
         expect(string.split(","), equals(["foo", "bar", "baz"])); 
      }); 
      test("test on trim() method of string class", () { 
         var string = "  foo "; 
         expect(string.trim(), equals("foo")); 
      }); 
   }); 
}

Output - La sortie ajoutera le nom du groupe pour chaque cas de test comme indiqué ci-dessous -

00:00 +0: String test on split() method of string class 
00:00 +1: String test on trim() method of string class 
00:00 +2: All tests passed

Chaque page Web réside dans une fenêtre de navigateur qui peut être considérée comme un objet.

UNE Document objectreprésente le document HTML affiché dans cette fenêtre. L'objet Document a diverses propriétés qui font référence à d'autres objets qui permettent d'accéder au contenu du document et de le modifier.

Le mode d'accès et de modification du contenu d'un document est appelé Document Object Model, ou DOM. Les objets sont organisés en hiérarchie. Cette structure hiérarchique s'applique à l'organisation des objets dans un document Web.

• Window- Haut de la hiérarchie. C'est l'élément le plus extérieur de la hiérarchie des objets.

• Document- Chaque document HTML chargé dans une fenêtre devient un objet de document. Le document contient le contenu de la page.

• Elements- représenter le contenu sur une page Web. Les exemples incluent les zones de texte, le titre de la page, etc.

• Nodes - sont souvent des éléments, mais ils peuvent aussi être des attributs, du texte, des commentaires et d'autres types DOM.

Voici une simple hiérarchie de quelques objets DOM importants -

Dart fournit le dart:htmlbibliothèque pour manipuler des objets et des éléments dans le DOM. Les applications basées sur la console ne peuvent pas utiliserdart:htmlbibliothèque. Pour utiliser la bibliothèque HTML dans les applications Web, importezdart:html -

import 'dart:html';

Passant, nous discuterons de certains DOM Operations dans la section suivante.

Recherche d'éléments DOM

le dart:html bibliothèque fournit le querySelector pour rechercher des éléments dans le DOM.

Element querySelector(String selectors);

le querySelector() La fonction renvoie le premier élément qui correspond au groupe de sélecteurs spécifié. "selectors doit être une chaîne utilisant la syntaxe du sélecteur CSS comme indiqué ci-dessous

var element1 = document.querySelector('.className'); 
var element2 = document.querySelector('#id');

Exemple: manipulation du DOM

Suivez les étapes ci-dessous, dans l'IDE Webstorm -

Step 1 - Fichier NewProject → Dans l'emplacement, indiquez le nom du projet comme DemoWebApp.

Step 1 - Dans la section "Générer un échantillon de contenu", sélectionnez SimpleWebApplication.

Il créera un exemple de projet, DemoWebApp. Il y a unpubspec.yaml fichier contenant les dépendances à télécharger.

name: 'DemoWebApp' 
version: 0.0.1 
description: An absolute bare-bones web app. 

#author: Your Name <[email protected]> 
#homepage: https://www.example.com  
environment:   
   sdk: '>=1.0.0 <2.0.0'  
dependencies:   
   browser: '>=0.10.0 <0.11.0'   dart_to_js_script_rewriter: '^1.0.1'  
transformers: 
- dart_to_js_script_rewriter

Si vous êtes connecté au Web, ceux-ci seront téléchargés automatiquement, sinon vous pouvez faire un clic droit sur le pubspec.yaml et obtenez les dépendances.

Dans le dossier Web, vous trouverez trois fichiers: Index.html, main.dart, et style.css

Index.html

<!DOCTYPE html>   
<html> 
   <head>     
      <meta charset = "utf-8">     
      <meta http-equiv = "X-UA-Compatible" content = "IE = edge">     
      <meta name = "viewport" content = "width = device-width, initial-scale = 1.0">
      <meta name = "scaffolded-by" content = "https://github.com/google/stagehand">
      <title>DemoWebApp</title>     
      <link rel = "stylesheet" href = "styles.css">     
      <script defer src = "main.dart" type = "application/dart"></script>
      <script defer src = "packages/browser/dart.js"></script> 
   </head>
   
   <body>   
      <h1>
         <div id = "output"></div> 
      </h1>  
   </body> 
</html>

Main.dart

import 'dart:html';  
void main() {   
   querySelector('#output').text = 'Your Dart web dom app is running!!!.'; 
}

Exécutez le index.htmlfichier; vous verrez la sortie suivante sur votre écran.

Gestion des événements

le dart:html bibliothèque fournit le onClickévénement pour les éléments DOM. La syntaxe montre comment un élément peut gérer un flux d'événements de clic.

querySelector('#Id').onClick.listen(eventHanlderFunction);

le querySelector() La fonction retourne l'élément du DOM donné et onClick.listen() prendra un eventHandlerméthode qui sera appelée lorsqu'un événement de clic est déclenché. La syntaxe deeventHandler est donné ci-dessous -

void eventHanlderFunction (MouseEvent event){ }

Prenons maintenant un exemple pour comprendre le concept de gestion des événements dans Dart.

TestEvent.html

<!DOCTYPE html> 
<html> 
   <head> 
      <meta charset = "utf-8"> 
      <meta http-equiv = "X-UA-Compatible" content = "IE = edge"> 
      <meta name = "viewport" content = "width = device-width, initial-scale = 1.0"> 
      <meta name = "scaffolded-by" content ="https://github.com/google/stagehand"> 
      <title>DemoWebApp</title> 
      <link rel = "stylesheet" href = "styles.css"> 
      <script defer src = "TestEvent.dart" type="application/dart"></script> 
      <script defer src = "packages/browser/dart.js"></script> 
   </head> 
   
   <body> 
      <div id = "output"></div> 
      <h1> 
         <div> 
            Enter you name : <input type = "text" id = "txtName"> 
            <input type = "button" id = "btnWish" value="Wish"> 
         </div> 
      </h1> 
      <h2 id = "display"></h2> 
   </body>
   
</html>

TestEvent.dart

import 'dart:html'; 
void main() { 
   querySelector('#btnWish').onClick.listen(wishHandler); 
}  
void wishHandler(MouseEvent event){ 
   String name = (querySelector('#txtName')  as InputElement).value; 
   querySelector('#display').text = 'Hello Mr.'+ name; 
}

Production