Programação de dardo - Guia rápido

Dart é uma linguagem orientada a objetos com sintaxe de estilo C que pode opcionalmente ser trans-compilada para JavaScript. Ele oferece suporte a uma variedade de recursos de programação, como interfaces, classes, coleções, genéricos e digitação opcional.

O Dart pode ser amplamente usado para criar aplicativos de página única. Os aplicativos de página única se aplicam apenas a sites e aplicativos da web. Os aplicativos de página única permitem a navegação entre diferentes telas do site sem carregar uma página da Web diferente no navegador. Um exemplo clássico éGMail ─ quando você clica em uma mensagem em sua caixa de entrada, o navegador permanece na mesma página da web, mas o código JavaScript oculta a caixa de entrada e traz o corpo da mensagem na tela.

O Google lançou uma versão especial de Chromium - a Dart VM. Usar o Dartium significa que você não precisa compilar seu código em JavaScript até que esteja pronto para testar em outros navegadores.

A tabela a seguir compara os recursos do Dart e do JavaScript.

Característica	Dardo	JavaScript
Sistema de tipo	Opcional, dinâmico	Fraco, dinâmico
Aulas	Sim, herança única	Prototípico
Interfaces	Sim, várias interfaces	Não
Simultaneidade	Sim, com isolados	Sim, com funcionários da web HTML5

Este tutorial fornece uma compreensão de nível básico da linguagem de programação Dart.

Este capítulo discute a configuração do ambiente de execução do Dart na plataforma Windows.

Executando Script Online com DartPad

Você pode testar seus scripts online usando o editor online em https://dartpad.dartlang.org/. O Dart Editor executa o script e exibe tanto o HTML quanto a saída do console. O editor online é enviado com um conjunto de exemplos de códigos predefinidos.

Uma captura de tela do Dartpad editor é dado abaixo -

O Dartpad também permite codificar de maneira mais restritiva. Isso pode ser obtido marcando a opção Modo forte na parte inferior direita do editor. O modo forte ajuda com -

Verificação estática e dinâmica mais forte
Geração de código JavaScript idiomático para melhor interoperabilidade.

Você pode tentar o seguinte exemplo usando o Dartpad

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

O código exibirá a seguinte saída

hello world

Configurando o Ambiente Local

Nesta seção, vamos ver como configurar o ambiente local.

Usando o Editor de Texto

Exemplos de alguns editores incluem Windows Notepad, Notepad ++, Emacs, vim ou vi, etc. Os editores podem variar de um sistema operacional para outro. Os arquivos de origem são normalmente nomeados com a extensão ".dart".

Instalando o Dart SDK

A versão estável atual do Dart é 1.21.0. odart sdk pode ser baixado de -

https://www.dartlang.org/install/archive
http://www.gekorm.com/dart-windows/

Uma captura de tela da instalação do Dart SDK é fornecida abaixo -

Na conclusão da instalação do SDK, defina a variável de ambiente PATH para -

<dart-sdk-path>\bin

Verificando a instalação

Para verificar se o Dart foi instalado com sucesso, abra o prompt de comando e digite o seguinte comando -

Dart

Se a instalação for bem-sucedida, ele mostrará o tempo de execução do dart.

Suporte IDE

Uma infinidade de IDEs oferece suporte a scripts no Dart. Exemplos incluemEclipse, IntelliJ, e WebStorm de cérebros de jato.

A seguir estão as etapas para configurar o ambiente Dart usando WebStrom IDE.

Instalando WebStorm

O arquivo de instalação do WebStorm pode ser baixado de https://www.jetbrains.com/webstorm/download/#section=windows-version.

O arquivo de instalação do WebStorm está disponível para Mac OS, Windows e Linux.

Depois de baixar os arquivos de instalação, siga as etapas abaixo -

Instale o Dart SDK: consulte as etapas listadas acima
Crie um novo projeto Dart e configure o suporte Dart
Para criar um novo projeto Dart,
- Clique Create New Project da tela de boas-vindas
- Na próxima caixa de diálogo, clique em Dart
Se não houver valor especificado para o Dart SDKcaminho e, em seguida, forneça o caminho SDK. Por exemplo, o caminho do SDK pode ser<dart installation directory>/dart/dartsdk.

Adicionar um arquivo Dart ao projeto

Para adicionar um arquivo DART ao projeto -

Clique com o botão direito no Projeto
Novo → Arquivo Dart
Digite o nome do Dart Script

Uma captura de tela do Editor WebStorm é fornecida abaixo -

A ferramenta dart2js

o dart2jsferramenta compila o código Dart para JavaScript. Compilar o código Dart para JS permite executar o script Dart em navegadores que não oferecem suporte ao Dart VM.

A ferramenta dart2js é enviada como parte do SDK do Dart e pode ser encontrada no /dartsdk/bin folder.

Para compilar o Dart para JavaScript, digite o seguinte comando no terminal

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

Este comando produz um arquivo que contém o equivalente em JavaScript do seu código Dart. Um tutorial completo sobre como usar este utilitário pode ser encontrado no site oficial do Dart.

A sintaxe define um conjunto de regras para escrever programas. Cada especificação de linguagem define sua própria sintaxe. Um programa Dart é composto por -

Variáveis e operadores
Classes
Functions
Expressões e construções de programação
Tomada de decisão e construções de loop
Comments
Bibliotecas e Pacotes
Typedefs
Estruturas de dados representadas como coleções / genéricos

Seu primeiro código de dardo

Vamos começar com o exemplo tradicional “Hello World” -

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

o main()função é um método predefinido no Dart. Este método atua como o ponto de entrada para o aplicativo. Um script Dart precisa domain() método de execução. print() é uma função predefinida que imprime a string ou valor especificado na saída padrão, ou seja, o terminal.

A saída do código acima será -

Hello World!

Executar um programa Dart

Você pode executar um programa Dart de duas maneiras -

Via terminal
Via WebStorm IDE

Via Terminal

Para executar um programa Dart através do terminal -

Navegue até o caminho do projeto atual
Digite o seguinte comando na janela do Terminal

dart file_name.dart

Via WebStorm IDE

Para executar um programa Dart através do IDE WebStorm -

Clique com o botão direito do mouse no arquivo de script Dart no IDE. (O arquivo deve conter omain() função para permitir a execução)
Clique no ‘Run <file_name>’opção. Uma captura de tela do mesmo é fornecida abaixo -

Pode-se clicar no

botão ou usar o atalhoCtrl+Shift+F10 para executar o Dart Script.

Opções de linha de comando do Dart

As opções de linha de comando do Dart são usadas para modificar a execução do Dart Script. As opções de linha de comando comuns para Dart incluem o seguinte -

Sr. Não	Opção e descrição da linha de comando
1	-c or --c Habilita asserções e verificações de tipo (modo verificado).
2	--version Exibe informações sobre a versão da VM.
3	--packages <path> Especifica o caminho para o arquivo de configuração de resolução do pacote.
4	-p <path> Especifica onde encontrar bibliotecas importadas. Esta opção não pode ser usada com --packages.
5	-h or --help Exibe ajuda.

Habilitando o modo verificado

Os programas Dart são executados em dois modos, a saber -

Modo verificado
Modo de produção (padrão)

Recomenda-se executar o Dart VM em checked modedurante o desenvolvimento e o teste, pois adiciona avisos e erros para auxiliar no processo de desenvolvimento e depuração. O modo verificado impõe várias verificações como verificação de tipo etc. Para ativar o modo verificado, adicione a opção -c ou –-checked antes do nome do arquivo de script enquanto executa o script.

No entanto, para garantir o benefício de desempenho durante a execução do script, é recomendado executar o script no production mode.

Considere o seguinte Test.dart arquivo de script -

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

Execute o script inserindo -

dart Test.dart

Embora haja uma incompatibilidade de tipo, o script é executado com êxito quando o modo selecionado é desativado. O script resultará na seguinte saída -

hello

Agora tente executar o script com a opção "- - verificado" ou "-c" -

dart -c Test.dart

Ou,

dart - - checked Test.dart

O Dart VM lançará um erro informando que há uma incompatibilidade de tipo.

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)

Identificadores no Dart

Identificadores são nomes dados a elementos em um programa, como variáveis, funções, etc. As regras para identificadores são -

Os identificadores podem incluir caracteres e dígitos. No entanto, o identificador não pode começar com um dígito.

Os identificadores não podem incluir símbolos especiais, exceto sublinhado (_) ou um cifrão ($).
Os identificadores não podem ser palavras-chave.
Eles devem ser únicos.
Os identificadores são sensíveis a maiúsculas e minúsculas.
Os identificadores não podem conter espaços.

As tabelas a seguir listam alguns exemplos de identificadores válidos e inválidos -

Identificadores válidos	Identificadores inválidos
primeiro nome	Var
primeiro nome	primeiro nome
num1	primeiro nome
$ resultado	1 número

Palavras-chave em Dart

Palavras-chave têm um significado especial no contexto de um idioma. A tabela a seguir lista algumas palavras-chave no Dart.

resumo 1	continuar	falso	Novo	esta
como 1	padrão	final	nulo	lançar
afirmar	diferido 1	finalmente	operador 1	verdadeiro
assíncrono 2	Faz	para	parte 1	experimentar
assíncrono * 2	dinâmico 1	pegue 1	relançar	typedef 1
aguarde 2	outro	E se	Retorna	var
pausa	enum	implementa 1	conjunto 1	vazio
caso	exportar 1	importar 1	estático 1	enquanto
pegar	externo 1	dentro	super	com
classe	estende	é	interruptor	rendimento 2
const	fábrica 1	biblioteca 1	sincronizar * 2	rendimento * 2

Espaços em branco e quebras de linha

O Dart ignora os espaços, guias e novas linhas que aparecem nos programas. Você pode usar espaços, tabulações e novas linhas livremente em seu programa e está livre para formatar e recuar seus programas de uma forma limpa e consistente que torna o código fácil de ler e entender.

Dart diferencia maiúsculas de minúsculas

O Dart diferencia maiúsculas de minúsculas. Isso significa que o Dart diferencia entre caracteres maiúsculos e minúsculos.

As instruções terminam com um ponto e vírgula

Cada linha de instrução é chamada de instrução. Cada instrução de dardo deve terminar com um ponto e vírgula (;). Uma única linha pode conter várias instruções. No entanto, essas instruções devem ser separadas por ponto e vírgula.

Comentários no Dart

Os comentários são uma forma de melhorar a legibilidade de um programa. Os comentários podem ser usados para incluir informações adicionais sobre um programa como o autor do código, dicas sobre uma função / construção, etc. Os comentários são ignorados pelo compilador.

O Dart suporta os seguintes tipos de comentários -

Single-line comments ( // ) - Qualquer texto entre um "//" e o final de uma linha é tratado como um comentário
Multi-line comments (/* */) - Esses comentários podem abranger várias linhas.

Exemplo

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

Programação Orientada a Objetos no Dart

Dart é uma linguagem orientada a objetos. Orientação a Objetos é um paradigma de desenvolvimento de software que segue a modelagem do mundo real. A Orientação a Objetos considera um programa como uma coleção de objetos que se comunicam entre si por meio de mecanismos chamados métodos.

Object- Um objeto é uma representação em tempo real de qualquer entidade. De acordo com Grady Brooch, cada objeto deve ter três características -
- State - descrito pelos atributos de um objeto.
- Behavior - descreve como o objeto irá agir.
- Identity - um valor único que distingue um objeto de um conjunto de objetos semelhantes.
Class- Uma classe em termos de OOP é um projeto para a criação de objetos. Uma classe encapsula dados para o objeto.
Method - Métodos facilitam a comunicação entre objetos.

Exemplo: dardo e orientação a objetos

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

O exemplo acima define uma classe TestClass. A classe tem um métododisp(). O método imprime a string “Hello World” no terminal. A nova palavra-chave cria um objeto da classe. O objeto invoca o métododisp().

O código deve produzir o seguinte output -

Hello World

Uma das características mais fundamentais de uma linguagem de programação é o conjunto de tipos de dados que ela suporta. Esses são os tipos de valores que podem ser representados e manipulados em uma linguagem de programação.

A linguagem Dart suporta os seguintes tipos−

Numbers
Strings
Booleans
Lists
Maps

Números

Os números no Dart são usados para representar literais numéricos. O Number Dart vem em dois sabores -

Integer- Valores inteiros representam valores não fracionários, ou seja, valores numéricos sem um ponto decimal. Por exemplo, o valor "10" é um número inteiro. Literais inteiros são representados usando oint palavra-chave.
Double- O Dart também suporta valores numéricos fracionários, ou seja, valores com casas decimais. O tipo de dados Double no Dart representa um número de ponto flutuante de 64 bits (precisão dupla). Por exemplo, o valor "10,10". A palavra-chavedouble é usado para representar literais de ponto flutuante.

Cordas

Strings representam uma sequência de caracteres. Por exemplo, se você fosse armazenar alguns dados como nome, endereço, etc., o tipo de dados da string deve ser usado. Uma string Dart é uma sequência de unidades de código UTF-16.Runes são usados para representar uma sequência de unidades de código UTF-32.

A palavra-chave Stringé usado para representar literais de string. Os valores de string são incorporados em aspas simples ou duplas.

boleano

O tipo de dados Boolean representa os valores booleanos true e false. Dart usa obool palavra-chave para representar um valor booleano.

Lista e Mapa

A lista de tipos de dados e o mapa são usados para representar uma coleção de objetos. UMAListé um grupo ordenado de objetos. O tipo de dados List no Dart é sinônimo do conceito de array em outras linguagens de programação. oMaptipo de dados representa um conjunto de valores como pares de valores-chave. odart: core library enables creation and manipulation of these collections through the predefined List and Map classes respectively.

The Dynamic Type

Dart is an optionally typed language. If the type of a variable is not explicitly specified, the variable’s type is dynamic. The dynamic keyword can also be used as a type annotation explicitly.

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

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

Type Syntax

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

var name = 'Smith';

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

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

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

Consider the following example −

void main() { 
   String name = 1; 
}

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

Output

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

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

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

Output

Null

The dynamic keyword

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

The following example illustrates the same.

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

Output

tom

Final and Const

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

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

Syntax: final Keyword

final variable_name

final data_type  variable_name

Syntax: const Keyword

const variable_name

const data_type variable_name

Example – final Keyword

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

Output

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 −

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] }

Declarando um mapa usando um construtor de mapa

Para declarar um mapa usando um construtor de mapa, temos duas etapas. Primeiro, declare o mapa e, segundo, inicialize o mapa.

o syntax para declare a map é o seguinte -

var identifier = new Map()

Agora, use a seguinte sintaxe para initialize the map -

map_name[key] = value

Exemplo: Mapa Literal

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

Isso produzirá o seguinte output -

{Usrname: tom, Password: pass@123}

Exemplo: Adicionando Valores a Literais de Mapa em Tempo de Execução

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

Isso produzirá o seguinte output -

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

Exemplo: Construtor de Mapa

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

Isso produzirá o seguinte output -

{Usrname: admin, Password: admin@123}

Note - Um valor de mapa pode ser qualquer objeto, incluindo NULL.

Mapa - Propriedades

o Map classe no dart: pacote principal define as seguintes propriedades -

Sr. Não	Descrição da Propriedade
1	Chaves Retorna um objeto iterável que representa as chaves
2	Valores Retorna um objeto iterável que representa valores
3	comprimento Retorna o tamanho do mapa
4	está vazia Retorna verdadeiro se o mapa for um mapa vazio
5	não está vazio Retorna verdadeiro se o mapa for um mapa vazio

Mapa - Funções

A seguir estão as funções comumente usadas para manipular mapas no Dart.

Sr. Não	Nome e descrição da função
1	addAll () Adiciona todos os pares de valores-chave de outro a este mapa.
2	Claro() Remove todos os pares do mapa.
3	retirar() Remove a chave e seu valor associado, se presente, do mapa.
4	para cada() Aplica-se f a cada par de valores-chave do mapa.

Os símbolos no Dart são nomes de strings dinâmicos opacos usados para refletir os metadados de uma biblioteca. Simplificando, os símbolos são uma maneira de armazenar a relação entre uma string legível por humanos e uma string que é otimizada para ser usada por computadores.

Reflexão é um mecanismo para obter metadados de um tipo em tempo de execução, como o número de métodos em uma classe, o número de construtores que possui ou o número de parâmetros em uma função. Você pode até mesmo invocar um método do tipo que é carregado no tempo de execução.

Em classes específicas de reflexão Dart estão disponíveis no dart:mirrorspacote. Esta biblioteca funciona em aplicativos da web e aplicativos de linha de comando.

Sintaxe

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

o name deve ser um nome de membro Dart público válido, nome de construtor público ou nome de biblioteca.

Exemplo

Considere o seguinte exemplo. O código declara uma classeFoo numa biblioteca foo_lib. A classe define os métodosm1, m2, e 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"); 
   } 
}

O código a seguir carrega Foo.dartbiblioteca e procura pela classe Foo, com ajuda do tipo Symbol. Como estamos refletindo os metadados da biblioteca acima, o código importadart:mirrors biblioteca.

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; 
   } 
}

Observe que a linha libMirror.declarations.forEach ((s, d) => print (s)); irá iterar em cada declaração na biblioteca em tempo de execução e imprimir as declarações como tipo deSymbol.

Este código deve produzir o seguinte output -

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

Exemplo: exibir o número de métodos de instância de uma classe

Vamos agora considerar a exibição do número de métodos de instância em uma classe. A classe predefinidaClassMirror nos ajuda a conseguir o mesmo.

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)); 
   } 
}

Este código deve produzir o seguinte 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")

Converter símbolo em string

Você pode converter o nome de um tipo como classe ou biblioteca armazenada em um símbolo de volta para string usando MirrorSystemclasse. O código a seguir mostra como você pode converter um símbolo em uma string.

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

Deve produzir o seguinte output -

Symbol("foo_lib")   

foo_lib

Strings são uma sequência de caracteres. Dart representa strings como uma sequência de unidades de código Unicode UTF-16. Unicode é um formato que define um valor numérico exclusivo para cada letra, dígito e símbolo.

Como uma string Dart é uma sequência de unidades de código UTF-16, os valores Unicode de 32 bits em uma string são representados por meio de uma sintaxe especial. UMArune é um número inteiro que representa um ponto de código Unicode.

A classe String no dart:core biblioteca fornece mecanismos para acessar runes. As unidades / runas do código da string podem ser acessadas de três maneiras -

Usando a função String.codeUnitAt ()
Usando a propriedade String.codeUnits
Usando a propriedade String.runes

Função String.codeUnitAt ()

As unidades de código em uma string podem ser acessadas por meio de seus índices. Retorna a unidade de código UTF-16 de 16 bits no índice fornecido.

Sintaxe

String.codeUnitAt(int index);

Exemplo

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

Isso produzirá o seguinte output -

Propriedade String.codeUnits

Esta propriedade retorna uma lista não modificável das unidades de código UTF-16 da string especificada.

Sintaxe

String. codeUnits;

Exemplo

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

Isso produzirá o seguinte output -

[82, 117, 110, 101, 115]

Propriedade String.runes

Esta propriedade retorna um iterável de pontos de código Unicode deste string.Runes estende iterável.

Sintaxe

String.runes

Exemplo

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

Isso produzirá o seguinte output -

A 
s 
t 
r 
i 
n 
g

Os pontos de código Unicode são geralmente expressos como \uXXXX, onde XXXX é um valor hexadecimal de 4 dígitos. Para especificar mais ou menos de 4 dígitos hexadecimais, coloque o valor entre colchetes. Pode-se usar o construtor da classe Runes na biblioteca dart: core para o mesmo.

Exemplo

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

Isso produzirá o seguinte output -

Uma enumeração é usada para definir valores constantes nomeados. Um tipo enumerado é declarado usando oenum palavra-chave.

Sintaxe

enum enum_name {  
   enumeration list 
}

Onde,

O enum_name especifica o nome do tipo de enumeração
A lista de enumeração é uma lista separada por vírgulas de identificadores

Cada um dos símbolos na lista de enumeração representa um valor inteiro, um maior do que o símbolo que o precede. Por padrão, o valor do primeiro símbolo de enumeração é 0.

Por exemplo

enum Status { 
   none, 
   running, 
   stopped, 
   paused 
}

Exemplo

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]}'); 
}

Isso produzirá o seguinte 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

Funções são os blocos de construção de código legível, sustentável e reutilizável. Uma função é um conjunto de instruções para realizar uma tarefa específica. As funções organizam o programa em blocos lógicos de código. Uma vez definidas, as funções podem ser chamadas para acessar o código. Isso torna o código reutilizável. Além disso, as funções facilitam a leitura e a manutenção do código do programa.

Uma declaração de função informa ao compilador sobre o nome, o tipo de retorno e os parâmetros de uma função. Uma definição de função fornece o corpo real da função.

Sr. Não	Funções e descrição
1	Definindo uma função Uma definição de função especifica o que e como uma tarefa específica seria realizada.
2	Chamando uma função Uma função deve ser chamada para executá-la.
3	Funções de retorno As funções também podem retornar valor junto com o controle, de volta para o chamador.
4	Função Parametrizada Os parâmetros são um mecanismo para passar valores para funções.

Parâmetros Opcionais

Os parâmetros opcionais podem ser usados quando os argumentos não precisam ser passados obrigatoriamente para a execução de uma função. Um parâmetro pode ser marcado como opcional anexando um ponto de interrogação ao seu nome. O parâmetro opcional deve ser definido como o último argumento em uma função.

Temos três tipos de parâmetros opcionais no Dart -

Sr. Não	Parâmetro e Descrição
1	Parâmetro Posicional Opcional Para especificar parâmetros posicionais opcionais, use colchetes [].
2	Parâmetro nomeado opcional Ao contrário dos parâmetros posicionais, o nome do parâmetro deve ser especificado enquanto o valor está sendo passado. A chave curly {} pode ser usada para especificar parâmetros nomeados opcionais.
3	Parâmetros opcionais com valores padrão Os parâmetros de função também podem receber valores atribuídos por padrão. No entanto, esses parâmetros também podem ser valores passados explicitamente.

Funções recursivas de dardo

A recursão é uma técnica para iterar uma operação, fazendo com que uma função seja chamada a si mesma repetidamente até chegar a um resultado. A recursão é melhor aplicada quando você precisa chamar a mesma função repetidamente com diferentes parâmetros de um loop.

Exemplo

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

Deve produzir o seguinte output -

Funções Lambda

As funções lambda são um mecanismo conciso para representar funções. Essas funções também são chamadas de funções de seta.

Sintaxe

[return_type]function_name(parameters)=>expression;

Exemplo

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

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

Deve produzir o seguinte output -

hello 123

A interfacedefine a sintaxe que qualquer entidade deve seguir. As interfaces definem um conjunto de métodos disponíveis em um objeto. O Dart não tem sintaxe para declarar interfaces. As declarações de classe são, elas mesmas, interfaces no Dart.

Classesdeve usar a palavra-chave implements para poder usar uma interface. É obrigatório para a classe de implementação fornecer uma implementação concreta de todas as funções da interface implementada. Em outras palavras, uma classe deve redefinir todas as funções na interface que deseja implementar.

Sintaxe: Implementando uma Interface

class identifier implements interface_name

Exemplo

No programa a seguir, estamos declarando uma classe Printer. oConsolePrinter classe implementa a declaração de interface implícita para o Printerclasse. omain função cria um objeto do ConsolePrinter classe usando o newpalavra-chave. Este objeto é usado para invocar a funçãoprint_data definido no 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__________"); 
   } 
}

Deve produzir o seguinte output -

__________Printing to Console__________

Implementando várias interfaces

Uma classe pode implementar várias interfaces. As interfaces são separadas por uma vírgula. osyntax pois o mesmo é dado abaixo -

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

Os seguintes example mostra como você pode implementar várias interfaces no 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; 
   } 
}

Deve produzir o seguinte output -

The gross total: 1000 
Discount:50

Dart é uma linguagem orientada a objetos. Ele suporta recursos de programação orientada a objetos, como classes, interfaces, etc. Aclassem termos de OOP é um plano para a criação de objetos. UMAclassencapsula dados para o objeto. O Dart fornece suporte integrado para este conceito chamadoclass.

Declarando uma classe

Use o class palavra-chave para declarar um classem Dart. Uma definição de classe começa com a palavra-chave class seguida pelaclass name; e o corpo da classe delimitado por um par de chaves. A sintaxe para o mesmo é fornecida abaixo -

Sintaxe

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

o classpalavra-chave é seguida pelo nome da classe. As regras para identificadores devem ser consideradas ao nomear uma classe.

Uma definição de classe pode incluir o seguinte -

Fields- Um campo é qualquer variável declarada em uma classe. Os campos representam dados relativos a objetos.
Setters and Getters- Permite que o programa inicialize e recupere os valores dos campos de uma classe. Um getter / setter padrão é associado a cada classe. No entanto, os padrões podem ser substituídos definindo explicitamente um setter / getter.
Constructors - responsável por alocar memória para os objetos da classe.
Functions- Funções representam ações que um objeto pode realizar. Às vezes também são chamados de métodos.

Esses componentes juntos são chamados de data members da classe.

Exemplo: Declarando uma classe

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

O exemplo declara uma classe Car. A classe tem um campo chamadoengine. odisp() é uma função simples que imprime o valor do campo engine.

Criação de instância da classe

Para criar uma instância da classe, use o newpalavra-chave seguida do nome da classe. A sintaxe para o mesmo é fornecida abaixo -

Sintaxe

var object_name = new class_name([ arguments ])

o new palavra-chave é responsável pela instanciação.
O lado direito da expressão invoca o construtor. O construtor deve receber valores se for parametrizado.

Exemplo: instanciando uma classe

var obj = new Car("Engine 1")

Acessando atributos e funções

Os atributos e funções de uma classe podem ser acessados por meio do objeto. Use o '.' notação de ponto (chamada deperiod) para acessar os membros de dados de uma classe.

//accessing an attribute 
obj.field_name  

//accessing a function 
obj.function_name()

Exemplo

Dê uma olhada no exemplo a seguir para entender como acessar atributos e funções no Dart -

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

o output do código acima é o seguinte -

E1001

Dart Constructors

Um construtor é uma função especial da classe responsável por inicializar as variáveis da classe. O Dart define um construtor com o mesmo nome da classe. Um construtor é uma função e, portanto, pode ser parametrizado. No entanto, ao contrário de uma função, os construtores não podem ter um tipo de retorno. Se você não declarar um construtor, um padrãono-argument constructor é fornecido para você.

Sintaxe

Class_name(parameter_list) { 
   //constructor body 
}

Exemplo

O exemplo a seguir mostra como usar construtores no Dart -

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

Deve produzir o seguinte output -

E1001

Construtores Nomeados

Dart fornece named constructors para habilitar uma definição de classe multiple constructors. A sintaxe dos construtores nomeados é fornecida a seguir -

Sintaxe: Definindo o construtor

Class_name.constructor_name(param_list)

Exemplo

O exemplo a seguir mostra como você pode usar construtores nomeados no 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}");    
   }                               
}

Deve produzir o seguinte output -

The engine is : E1001 
Non-parameterized constructor invoked

Esta palavra-chave

o thispalavra-chave refere-se à instância atual da classe. Aqui, o nome do parâmetro e o nome do campo da classe são os mesmos. Portanto, para evitar ambigüidade, o campo da classe é prefixado com othispalavra-chave. O exemplo a seguir explica o mesmo -

Exemplo

O exemplo a seguir explica como usar o this palavra-chave no Dart -

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

Deve produzir o seguinte output -

The engine is : E1001

Classe Dart ─ Getters e Setters

Getters e Setters, também chamado de accessors e mutators, permite que o programa inicialize e recupere os valores dos campos de classe, respectivamente. Getters ou acessores são definidos usando ogetpalavra-chave. Setters ou mutadores são definidos usando oset palavra-chave.

Um getter / setter padrão é associado a cada classe. No entanto, os padrões podem ser substituídos definindo explicitamente um setter / getter. Um getter não tem parâmetros e retorna um valor, e o setter tem um parâmetro e não retorna um valor.

Sintaxe: Definindo um getter

Return_type  get identifier 
{ 
}

Sintaxe: Definindo um setter

set identifier 
{ 
}

Exemplo

O exemplo a seguir mostra como você pode usar getters e setters em uma aula de 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); 
}

Este código de programa deve produzir o seguinte output -

Age should be greater than 5 
MARK 
Null

Herança de classe

O Dart suporta o conceito de Herança, que é a capacidade de um programa de criar novas classes a partir de uma classe existente. A classe que é estendida para criar classes mais novas é chamada de classe pai / superclasse. As classes recém-criadas são chamadas de classes filhas / subclasses.

Uma classe herda de outra classe usando a palavra-chave 'extends'. Child classes inherit all properties and methods except constructors from the parent class.

Sintaxe

class child_class_name extends parent_class_name

Note - O Dart não oferece suporte a herança múltipla.

Exemplo: herança de classe

No exemplo a seguir, estamos declarando uma classe Shape. A aula é estendida peloCircleclasse. Uma vez que existe uma relação de herança entre as classes, a classe filha, ou seja, a classeCar obtém um acesso implícito ao membro de dados da classe pai.

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 {}

Deve produzir o seguinte output -

calling calc area defined in the Shape class

Tipos de herança

A herança pode ser dos três tipos a seguir -

Single - Cada classe pode estender no máximo a partir de uma classe pai.
Multiple- Uma classe pode herdar de várias classes. O Dart não oferece suporte a herança múltipla.
Multi-level - Uma classe pode herdar de outra classe filha.

Exemplo

O exemplo a seguir mostra como funciona a herança de vários níveis -

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

A classe Leafderiva os atributos das classes Root e Child em virtude da herança de vários níveis. Estáoutput é o seguinte -

hello

Dart - Herança de Classe e Substituição de Método

Substituição de método é um mecanismo pelo qual a classe filha redefine um método em sua classe pai. O exemplo a seguir ilustra o mesmo -

Exemplo

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}"); 
   } 
}

Deve produzir o seguinte output -

value of b 12

O número e o tipo dos parâmetros da função devem corresponder ao substituir o método. Em caso de incompatibilidade no número de parâmetros ou no tipo de dados, o compilador Dart gera um erro. A ilustração a seguir explica o mesmo -

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}");
   } 
}

Deve produzir o seguinte output -

value of b 12

A palavra-chave estática

o static palavra-chave pode ser aplicada aos membros de dados de uma classe, ou seja, fields e methods. Uma variável estática retém seus valores até que o programa termine a execução. Membros estáticos são referenciados pelo nome da classe.

Exemplo

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 
}

Deve produzir o seguinte output -

The value of num is 12

A super palavra-chave

o superpalavra-chave é usada para se referir ao pai imediato de uma classe. A palavra-chave pode ser usada para se referir à versão de superclasse de umvariable, property, ou method. O exemplo a seguir ilustra o mesmo -

Exemplo

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}")   ; 
   } 
}

Deve produzir o seguinte output -

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

A Programação Orientada a Objetos define um objeto como “qualquer entidade que possui um limite definido”. Um objeto tem o seguinte -

State- Descreve o objeto. Os campos de uma classe representam o estado do objeto.
Behavior - Descreve o que um objeto pode fazer.
Identity- Um valor exclusivo que distingue um objeto de um conjunto de outros objetos semelhantes. Dois ou mais objetos podem compartilhar o estado e o comportamento, mas não a identidade.

O operador de período (.) é usado em conjunto com o objeto para acessar os membros de dados de uma classe.

Exemplo

Dart representa dados na forma de objetos. Cada classe no Dart estende a classe Object. A seguir, é fornecido um exemplo simples de criação e uso de um objeto.

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(); 
}

Deve produzir o seguinte output -

This is a test method 
This is a test method1

O operador Cascade (..)

O exemplo acima invoca os métodos da classe. No entanto, sempre que uma função é chamada, uma referência ao objeto é necessária. ocascade operator pode ser usado como um atalho nos casos em que há uma sequência de invocações.

O operador cascade (..) pode ser usado para emitir uma sequência de chamadas por meio de um objeto. O exemplo acima pode ser reescrito da seguinte maneira.

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(); 
}

Deve produzir o seguinte output -

This is a test method 
This is a test method1

O método toString ()

Esta função retorna uma representação de string de um objeto. Dê uma olhada no exemplo a seguir para entender como usar otoString método.

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

Deve produzir o seguinte output -

O Dart, ao contrário de outras linguagens de programação, não oferece suporte a matrizes. As coleções de Dart podem ser usadas para replicar estruturas de dados como um array. A biblioteca dart: core e outras classes permitem o suporte de coleção em scripts Dart.

As coleções de dardos podem ser basicamente classificadas como -

Sr. Não	Coleção e descrição de dardos
1	Lista Uma lista é simplesmente um grupo ordenado de objetos. odart:core biblioteca fornece a classe List que permite a criação e manipulação de listas. Fixed Length List - O comprimento da lista não pode ser alterado em tempo de execução. Growable List - O comprimento da lista pode mudar em tempo de execução.
2	Conjunto Set representa uma coleção de objetos em que cada objeto pode ocorrer apenas uma vez. A biblioteca dart: core fornece a classe Set para implementar o mesmo.
3	Mapas O objeto Map é um par simples de chave / valor. Chaves e valores em um mapa podem ser de qualquer tipo. Um mapa é uma coleção dinâmica. Em outras palavras, o Maps pode aumentar e diminuir em tempo de execução. A classe Map na biblioteca dart: core fornece suporte para o mesmo.
4	Fila Uma fila é uma coleção que pode ser manipulada em ambas as extremidades. As filas são úteis quando você deseja criar uma coleção primeiro a entrar, primeiro a sair. Simplificando, uma fila insere dados de uma extremidade e exclui de outra extremidade. Os valores são removidos / lidos na ordem de sua inserção.

Iterando coleções

A classe Iterator do dart:corea biblioteca permite uma fácil travessia da coleção. Cada coleção tem umiteratorpropriedade. Esta propriedade retorna um iterador que aponta para os objetos na coleção.

Exemplo

O exemplo a seguir ilustra a passagem de uma coleção usando um objeto iterador.

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

o moveNext()função retorna um valor booleano indicando se há uma entrada subsequente. ocurrent propriedade do objeto iterador retorna o valor do objeto para o qual o iterador aponta atualmente.

Este programa deve produzir o seguinte output -

100 
200 
300

Dart é um optionally typed language. As coleções no Dart são heterogêneas por padrão. Em outras palavras, uma única coleção Dart pode hospedar valores de vários tipos. No entanto, uma coleção Dart pode ser feita para manter valores homogêneos. O conceito de genéricos pode ser usado para conseguir o mesmo.

O uso de Genéricos impõe uma restrição ao tipo de dados dos valores que podem estar contidos na coleção. Essas coleções são denominadas coleções seguras de tipo. A segurança de tipo é um recurso de programação que garante que um bloco de memória só possa conter dados de um tipo de dados específico.

Todas as coleções Dart suportam a implementação de segurança de tipo por meio de genéricos. Um par de colchetes angulares contendo o tipo de dados é usado para declarar uma coleção de tipo seguro. A sintaxe para declarar uma coleção de tipo seguro é fornecida a seguir.

Sintaxe

Collection_name <data_type> identifier= new Collection_name<data_type>

As implementações de tipo seguro de List, Map, Set e Queue são fornecidas abaixo. Esse recurso também é compatível com todas as implementações dos tipos de coleção mencionados acima.

Exemplo: Lista Genérica

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); 
   } 
}

Deve produzir o seguinte output -

WARNING 
ERROR 
INFO

Uma tentativa de inserir um valor diferente do tipo especificado resultará em um erro de compilação. O exemplo a seguir ilustra isso.

Exemplo

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); 
   } 
}

Deve produzir o seguinte output -

1                                                                                     
ERROR                                                                             
INFO

Exemplo: Conjunto Genérico

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); 
   } 
}

Deve produzir o seguinte output -

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

Exemplo: fila genérica

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); 
   } 
}

Deve produzir o seguinte output -

Default implementation ListQueue<int> 
20 
30 
40

Mapa Genérico

Uma declaração de mapa de tipo seguro especifica os tipos de dados de -

A chave
O valor que

Sintaxe

Map <Key_type, value_type>

Exemplo

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

Deve produzir o seguinte output -

Map :{name: Tom, Id: E1001}

Um pacote é um mecanismo para encapsular um grupo de unidades de programação. Às vezes, os aplicativos podem precisar da integração de algumas bibliotecas ou plug-ins de terceiros. Cada linguagem tem um mecanismo para gerenciar pacotes externos como Maven ou Gradle para Java, Nuget para .NET, npm para Node.js, etc. O gerenciador de pacotes para Dart épub.

Pub ajuda a instalar pacotes no repositório. O repositório de pacotes hospedados pode ser encontrado emhttps://pub.dartlang.org/.

o package metadata é definido em um arquivo, pubsec.yaml. YAML é a sigla paraYet Another Markup Language. opub ferramenta pode ser usada para baixar todas as várias bibliotecas que um aplicativo requer.

Cada aplicativo Dart tem um pubspec.yaml arquivo que contém as dependências do aplicativo para outras bibliotecas e metadados de aplicativos, como nome do aplicativo, autor, versão e descrição.

O conteúdo de um pubspec.yaml arquivo deve ser parecido com isto -

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

O importante pub commands são os seguintes -

Sr. Não	Comando e Descrição
1	‘pub get’ Ajuda a obter todos os pacotes dos quais seu aplicativo depende.
2	‘pub upgrade’ Atualiza todas as suas dependências para uma versão mais recente.
3	‘pub build’ Isso é usado para construir seu aplicativo da web e criará uma pasta de construção, com todos os scripts relacionados nela.
4	‘pub help’ Isso lhe dará ajuda para todos os comandos pub diferentes.

Se estiver usando um IDE como o WebStorm, você pode clicar com o botão direito do mouse em pubspec.yaml para obter todos os comandos diretamente -

Instalando um pacote

Considere um exemplo em que um aplicativo precisa analisar xml. O Dart XML é uma biblioteca leve, de código aberto e estável para analisar, percorrer, consultar e construir documentos XML.

As etapas para realizar a referida tarefa são as seguintes -

Step 1 - Adicione o seguinte ao arquivo 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:

Clique com o botão direito no pubsec.yamle obter dependências. Isso irá disparar internamente opub get command como mostrado abaixo.

Os pacotes baixados e seus pacotes dependentes podem ser verificados na pasta de pacotes.

Uma vez que a instalação está concluída agora, precisamos consultar o dart xmlno projeto. A sintaxe é a seguinte -

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

Ler string XML

Para ler a string XML e verificar a entrada, o Dart XML usa um parse()método. A sintaxe é a seguinte -

xml.parse(String input):

Exemplo: análise de entrada de string XML

O exemplo a seguir mostra como analisar a entrada de string 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()); 
}

Deve produzir o seguinte 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>

Uma exceção (ou evento excepcional) é um problema que surge durante a execução de um programa. Quando ocorre uma exceção, o fluxo normal do programa é interrompido e o programa / aplicativo é encerrado de forma anormal.

As exceções integradas do Dart incluem -

Sr. Não	Exceções e descrição
1	DeferredLoadException Lançado quando uma biblioteca adiada falha ao carregar.
2	FormatException Exceção lançada quando uma string ou algum outro dado não tem um formato esperado e não pode ser analisado ou processado.
3	IntegerDivisionByZeroException Lançado quando um número é dividido por zero.
4	IOException Classe base para todas as exceções relacionadas a Inupt-Output.
5	IsolateSpawnException Lançado quando um isolado não pode ser criado.
6	Timeout Lançado quando ocorre um tempo limite programado durante a espera por um resultado assíncrono.

Cada exceção no Dart é um subtipo da classe predefinida Exception. As exceções devem ser tratadas para evitar que o aplicativo seja encerrado abruptamente.

Os blocos try / on / catch

o trybloco incorpora código que possivelmente pode resultar em uma exceção. O bloco on é usado quando o tipo de exceção precisa ser especificado. ocatch bloco é usado quando o manipulador precisa do objeto de exceção.

o try bloco deve ser seguido por exatamente um on / catch bloco ou um finallybloco (ou um de ambos). Quando ocorre uma exceção no bloco try, o controle é transferido para ocatch.

o syntax para lidar com uma exceção é como fornecido abaixo -

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

A seguir estão alguns pontos a serem lembrados -

Um trecho de código pode ter mais de um bloco on / catch para lidar com várias exceções.
O bloco on e o bloco catch são mutuamente inclusivos, ou seja, um bloco try pode ser associado a ambos - o bloco on e o bloco catch.

O código a seguir ilustra o tratamento de exceções no Dart -

Exemplo: Usando o Bloco ON

O programa a seguir divide dois números representados pelas variáveis x e yrespectivamente. O código lança uma exceção, pois tenta a divisão por zero. oon block contém o código para lidar com essa exceção.

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

Deve produzir o seguinte output -

Cannot divide by zero

Exemplo: usando o bloco catch

No exemplo a seguir, usamos o mesmo código acima. A única diferença é que ocatch block(em vez do bloco ON) aqui contém o código para tratar a exceção. O parâmetro decatch contém o objeto de exceção lançado no tempo de execução.

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

Deve produzir o seguinte output -

IntegerDivisionByZeroException

Exemplo: on ... catch

O exemplo a seguir mostra como usar o on...catch quadra.

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

Deve produzir o seguinte output -

IntegerDivisionByZeroException

O bloco finalmente

o finallybloco inclui código que deve ser executado independentemente da ocorrência de uma exceção. O opcionalfinally bloco é executado incondicionalmente após try/on/catch.

A sintaxe para usar o finally bloco é o seguinte -

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 
}

O exemplo a seguir ilustra o uso de finally quadra.

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'); 
   } 
}

Deve produzir o seguinte output -

Cannot divide by zero 
Finally block executed

Lançando uma exceção

o throwpalavra-chave é usada para gerar uma exceção explicitamente. Uma exceção gerada deve ser tratada para evitar que o programa seja encerrado abruptamente.

o syntax para levantar uma exceção explicitamente é -

throw new Exception_name()

Exemplo

O exemplo a seguir mostra como usar o throw palavra-chave para lançar uma exceção -

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

Deve produzir o seguinte output -

Age cannot be negative

Exceções personalizadas

Conforme especificado acima, cada tipo de exceção no Dart é um subtipo da classe integrada Exception. O Dart permite a criação de exceções personalizadas, estendendo as existentes. A sintaxe para definir uma exceção personalizada é fornecida a seguir -

Sintaxe: Definindo a exceção

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

Exceções personalizadas devem ser levantadas explicitamente e as mesmas devem ser tratadas no código.

Exemplo

O exemplo a seguir mostra como definir e tratar uma exceção personalizada.

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(); 
   } 
}

No código acima, estamos definindo uma exceção personalizada, AmtException. O código gera a exceção se o valor transmitido não estiver dentro da faixa de exceção. omain função inclui a invocação da função no try...catch quadra.

O código deve produzir o seguinte output -

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

De vez em quando, os desenvolvedores cometem erros durante a codificação. Um erro em um programa é conhecido como bug. O processo de localização e correção de bugs é chamado de depuração e é uma parte normal do processo de desenvolvimento. Esta seção cobre ferramentas e técnicas que podem ajudá-lo nas tarefas de depuração.

O editor WebStorm permite pontos de interrupção e depuração passo a passo. O programa será interrompido no ponto em que o ponto de interrupção for anexado. Essa funcionalidade é semelhante ao que você espera do desenvolvimento de aplicativos Java ou C #. Você pode observar variáveis, navegar na pilha, passar por cima e entrar em chamadas de métodos e funções, tudo a partir do WebStorm Editor.

Adicionando um Ponto de Interrupção

Considere o seguinte trecho de código. (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); 
}

Para add a breakpoint, clique na margem esquerda para. Na figura abaixo, a linha número 7 tem um ponto de interrupção.

Run the program in debug mode. No explorador de projetos, clique com o botão direito do mouse no programa de dardo em nosso caso TestString.dart.

Assim que o programa for executado no modo de depuração, você obterá a janela Depurador conforme mostrado na captura de tela a seguir. A guia de variáveis mostra os valores das variáveis no contexto atual. Você pode adicionar observadores para variáveis específicas e ouvir as alterações de valores usando a janela de relógios.

Step Into(F7) ícone de seta no menu de depuração ajuda a Executa o código uma instrução por vez. Se os métodos principais chamam uma sub-rotina, isso irá para o código da sub-rotina também.

Step over (F8): É semelhante a Step Into. A diferença no uso ocorre quando a instrução atual contém uma chamada para uma sub-rotina. Se o método principal chamar uma sub-rotina, passar por cima não fará uma busca detalhada na sub-rotina. ele irá pular a sub-rotina.

Step Out(Shift + F8): Executa as linhas restantes de uma função na qual se encontra o ponto de execução atual. A próxima instrução exibida é a instrução após a chamada da sub-rotina.

Depois de ser executado no modo de depuração, o programa fornece o seguinte output -

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

UMA typedef, ou um alias de tipo de função, ajuda a definir ponteiros para código executável na memória. Simplificando, umtypedef pode ser usado como um ponteiro que faz referência a uma função.

Abaixo estão as etapas para implementar typedefs em um programa Dart.

Step 1: Defining a typedef

UMA typedefpode ser usado para especificar uma assinatura de função que desejamos que funções específicas correspondam. Uma assinatura de função é definida pelos parâmetros de uma função (incluindo seus tipos). O tipo de retorno não faz parte da assinatura da função. Sua sintaxe é a seguinte.

typedef function_name(parameters)

Step 2: Assigning a Function to a typedef Variable

Uma variável de typedef pode apontar para qualquer função com a mesma assinatura que typedef. Você pode usar a seguinte assinatura para atribuir uma função a umtypedef variável.

type_def  var_name = function_name

Step 3: Invoking a Function

o typedefvariável pode ser usada para invocar funções. Aqui está como você pode invocar uma função -

var_name(parameters)

Exemplo

Vamos agora dar um exemplo para entender mais sobre typedef em Dart.

Em primeiro lugar, vamos definir um typedef. Aqui estamos definindo uma assinatura de função. A função terá dois parâmetros de entrada do tipointeger. O tipo de retorno não faz parte da assinatura da função.

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

A seguir, vamos definir as funções. Defina algumas funções com a mesma assinatura de função daManyOperation 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}"); 
}

Finalmente, vamos invocar a função via typedef. Declare uma variável do tipo ManyOperations. Atribua o nome da função à variável declarada.

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

o opervariável pode apontar para qualquer método que receba dois parâmetros inteiros. oAdda referência da função é atribuída à variável. Typedefs podem alternar referências de função em tempo de execução

Vamos agora juntar todas as peças e ver o programa completo.

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); 
}

O programa deve produzir o seguinte output -

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

Note - O código acima resultará em um erro se o typedef variável tenta apontar para uma função com uma assinatura de função diferente.

Exemplo

Typedefstambém pode ser passado como um parâmetro para uma função. Considere o seguinte exemplo -

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); 
}

Isso produzirá o seguinte output -

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

Uma biblioteca em uma linguagem de programação representa uma coleção de rotinas (conjunto de instruções de programação). O Dart possui um conjunto de bibliotecas embutidas que são úteis para armazenar rotinas usadas com frequência. Uma biblioteca Dart é composta por um conjunto de classes, constantes, funções, typedefs, propriedades e exceções.

Importando uma biblioteca

A importação disponibiliza os componentes de uma biblioteca para o código do chamador. A palavra-chave import é usada para conseguir o mesmo. Um arquivo dart pode ter várias instruções de importação.

URIs de biblioteca DART incorporados usam o esquema dart: para se referir a uma biblioteca. Outras bibliotecas podem usar um caminho do sistema de arquivos ou o esquema package: para especificar seu URI. As bibliotecas fornecidas por um gerenciador de pacotes, como a ferramenta pub, usam o esquema package : .

A sintaxe para importar uma biblioteca no Dart é fornecida abaixo -

import 'URI'

Considere o seguinte snippet de código -

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

Se quiser usar apenas parte de uma biblioteca, você pode importar a biblioteca seletivamente. A sintaxe para o mesmo é fornecida abaixo -

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

Algumas bibliotecas comumente usadas são fornecidas abaixo -

Sr. Não	Biblioteca e descrição
1	dart:io Arquivo, soquete, HTTP e outros suportes de E / S para aplicativos de servidor. Esta biblioteca não funciona em aplicativos baseados em navegador. Esta biblioteca é importada por padrão.
2	dart:core Tipos integrados, coleções e outras funcionalidades básicas para cada programa Dart. Esta biblioteca é importada automaticamente.
3	dart: math Constantes e funções matemáticas, além de um gerador de números aleatórios.
4	dart: convert Codificadores e decodificadores para conversão entre diferentes representações de dados, incluindo JSON e UTF-8.
5	dart: typed_data Listas que lidam com eficiência com dados de tamanho fixo (por exemplo, inteiros de 8 bytes não assinados).

Exemplo: importando e usando uma biblioteca

O exemplo a seguir importa a biblioteca integrada dart: math. O snippet chama osqrt() função do mathbiblioteca. Esta função retorna a raiz quadrada de um número passado a ela.

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

Output

Square root of 36 is: 6.0

Encapsulamento em bibliotecas

Os scripts do DART podem prefixar os identificadores com um sublinhado (_) para marcar seus componentes como particulares. Simplificando, as bibliotecas Dart podem restringir o acesso ao seu conteúdo por scripts externos. Isso é denominado comoencapsulation. A sintaxe para o mesmo é fornecida abaixo -

Sintaxe

_identifier

Exemplo

Em primeiro lugar, defina uma biblioteca com uma função privada.

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

Em seguida, importe a biblioteca

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

O código acima resultará em erro.

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)

Criação de bibliotecas personalizadas

O Dart também permite que você use seu próprio código como biblioteca. A criação de uma biblioteca personalizada envolve as seguintes etapas -

Step 1: Declaring a Library

Para declarar explicitamente uma biblioteca, use o library statement. A sintaxe para declarar uma biblioteca é a seguinte -

library library_name  
// library contents go here

Step 2: Associating a Library

Você pode associar uma biblioteca de duas maneiras -

Dentro do mesmo diretório

import 'library_name'

De um diretório diferente

import 'dir/library_name'

Exemplo: Biblioteca Personalizada

Primeiro, vamos definir uma biblioteca personalizada, 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); 
}

Em seguida, vamos importar a biblioteca -

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"); 
}

O programa deve produzir o seguinte output -

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

Prefixo da biblioteca

Se você importar duas bibliotecas com identificadores conflitantes, poderá especificar um prefixo para uma ou ambas as bibliotecas. Use o'as'palavra-chave para especificar o prefixo. A sintaxe para o mesmo é fornecida abaixo -

Sintaxe

import 'library_uri' as prefix

Exemplo

Primeiro, vamos definir uma biblioteca: loggerlib.dart.

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

A seguir, definiremos outra biblioteca: webloggerlib.dart.

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

Por fim, importaremos a biblioteca com um prefixo.

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

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

Isso produzirá o seguinte output -

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

A asynchronous operation executa em um thread, separado do mainthread do aplicativo. Quando um aplicativo chama um método para realizar uma operação de forma assíncrona, o aplicativo pode continuar executando enquanto o método assíncrono realiza sua tarefa.

Exemplo

Vamos dar um exemplo para entender esse conceito. Aqui, o programa aceita entrada do usuário usando oIO 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"); 
}

o readLineSync()é um método síncrono. Isso significa que a execução de todas as instruções que seguem oreadLineSync() chamada de função será bloqueada até o readLineSync() método termina a execução.

o stdin.readLineSyncaguarda entrada. Ele para em suas trilhas e não executa mais nada até receber a entrada do usuário.

O exemplo acima resultará no seguinte output -

Enter your name :     
Tom                   

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

Na computação, dizemos que algo é synchronousquando espera que um evento aconteça antes de continuar. Uma desvantagem dessa abordagem é que, se uma parte do código demorar muito para ser executada, a execução dos blocos subsequentes, embora não relacionados, será bloqueada. Considere um servidor da web que deve responder a várias solicitações de um recurso.

Um modelo de execução síncrona bloqueará todas as solicitações de outros usuários até concluir o processamento da solicitação atual. Nesse caso, como o de um servidor web, cada solicitação deve ser independente das outras. Isso significa que o servidor da web não deve esperar que a solicitação atual termine de ser executada antes de responder à solicitação de outros usuários.

Simplificando, ele deve aceitar solicitações de novos usuários antes de necessariamente completar as solicitações de usuários anteriores. Isso é denominado como assíncrono. A programação assíncrona significa basicamente nenhum modelo de programação em espera ou sem bloqueio. odart:async pacote facilita a implementação de blocos de programação assíncrona em um script Dart.

Exemplo

O exemplo a seguir ilustra melhor o funcionamento de um bloco assíncrono.

Step 1 - Crie um contact.txt arquivo conforme fornecido abaixo and salve-o na pasta de dados do projeto atual.

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

Step 2 - Escreva um programa que irá ler o arquivo sem bloquear outras partes do aplicativo.

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 
}

o output deste programa será o seguinte -

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

O "fim de main" é executado primeiro enquanto o script continua lendo o arquivo. oFuture classe, parte de dart:async, é usado para obter o resultado de um cálculo após a conclusão de uma tarefa assíncrona. esteFuture valor é então usado para fazer algo após o término do cálculo.

Assim que a operação de leitura for concluída, o controle de execução é transferido dentro "then()". Isso ocorre porque a operação de leitura pode levar mais tempo e, portanto, não deseja bloquear outra parte do programa.

Dart Future

A comunidade Dart define um Futurecomo "um meio para obter um valor em algum momento no futuro." Simplificando,Future objectssão um mecanismo para representar os valores retornados por uma expressão cuja execução será concluída em um momento posterior. Várias das classes integradas do Dart retornam umFuture quando um método assíncrono é chamado.

Dart é uma linguagem de programação de thread único. Se algum código bloquear o thread de execução (por exemplo, esperando por uma operação demorada ou bloqueando a E / S), o programa congela efetivamente.

As operações assíncronas permitem que seu programa seja executado sem ser bloqueado. Dart usaFuture objects para representar operações assíncronas.

Concurrencyé a execução de várias sequências de instruções ao mesmo tempo. Envolve a execução de mais de uma tarefa simultaneamente.

Dart usa Isolatescomo uma ferramenta para fazer trabalhos em paralelo. odart:isolate package é a solução da Dart para pegar o código Dart de thread único e permitir que o aplicativo faça maior uso do hardware disponível.

Isolates, como o nome sugere, são unidades isoladas de código em execução. A única maneira de enviar dados entre eles é passando mensagens, como a maneira como você passa mensagens entre o cliente e o servidor. Aisolate ajuda o programa a tirar proveito de microprocessadores multicore prontos para uso.

Exemplo

Vamos dar um exemplo para entender melhor esse conceito.

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'); 
}

Aqui o spawn método do Isolate classe facilita a execução de uma função, foo, em paralelo com o resto do nosso código. ospawn função leva dois parâmetros -

a função a ser gerada, e
um objeto que será passado para a função gerada.

Caso não haja nenhum objeto a ser passado para a função gerada, pode ser passado um valor NULL.

As duas funções (foo and main)pode não ser executado necessariamente na mesma ordem todas as vezes. Não há garantia de quandofoo estará executando e quando main()estará em execução. A saída será diferente a cada vez que você executar.

Produto 1

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

Produto 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!!

A partir dos resultados, podemos concluir que o código Dart pode gerar um novo isolate da execução de código como o código Java ou C # pode iniciar um novo thread.

Isolates diferem dos tópicos em que um isolatetem sua própria memória. Não há como compartilhar uma variável entreisolates—A única forma de comunicação entre isolates é através da passagem de mensagens.

Note - A saída acima será diferente para diferentes configurações de hardware e sistema operacional.

Isole v / s Futuro

Fazer um trabalho computacional complexo de forma assíncrona é importante para garantir a capacidade de resposta dos aplicativos. Dart Future é um mecanismo para recuperar o valor de uma tarefa assíncrona após sua conclusão, enquanto Dart Isolates são uma ferramenta para abstrair o paralelismo e implementá-lo em uma base prática de alto nível.

O Teste de Unidade envolve o teste de cada unidade individual de um aplicativo. Ajuda o desenvolvedor a testar pequenas funcionalidades sem executar todo o aplicativo complexo.

O dardo external library denominado "teste" fornece uma maneira padrão de escrever e executar testes de unidade.

O teste de unidade Dart envolve as seguintes etapas -

Step 1: Installing the "test" package

Para instalar pacotes de terceiros no projeto atual, você precisará do pubspec.yamlArquivo. Para instalartest packages, primeiro faça a seguinte entrada no pubspec.yaml arquivo -

dependencies: 
test:

Depois de fazer a entrada, clique com o botão direito no pubspec.yamlarquivo e obter dependências. Vai instalar o"test"pacote. Dada abaixo está uma captura de tela para o mesmo noWebStorm Editor.

Os pacotes podem ser instalados a partir do command linetambém. Digite o seguinte no terminal -

pub get

Step 2: Importing the "test" package

import "package:test/test.dart";

Step 3 Writing Tests

Os testes são especificados usando a função de nível superior test(), enquanto test assertions são feitos usando o expect()função. Para usar esses métodos, eles devem ser instalados como umpub dependência.

Sintaxe

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

o group()função pode ser usada para agrupar testes. A descrição de cada grupo é adicionada ao início das descrições de seu teste.

Sintaxe

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

Exemplo 1: Um teste de aprovação

O exemplo a seguir define um método Add(). Este método usa dois valores inteiros e retorna um inteiro que representa osum. Para testar issoadd() método -

Step 1 - Importe o test pacote conforme fornecido abaixo.

Step 2 - Defina o teste usando o test()função. Aqui otest() função usa o expect() função para fazer cumprir uma afirmação.

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); 
   }); 
}

Deve produzir o seguinte output -

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

Exemplo 2: Um teste de falha

o subtract()método definido abaixo tem um erro lógico. Os seguintestest verifica o mesmo.

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 - O caso de teste para a função add() passa, mas o teste para subtract() falha conforme mostrado abaixo.

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)

Agrupando Casos de Teste

Você pode agrupar o test casespara adicionar mais significado ao código de teste. Se você tem muitostest cases isso ajuda a escrever um código muito mais limpo.

No código fornecido, estamos escrevendo um caso de teste para o split() função e o trimfunção. Portanto, agrupamos logicamente esses casos de teste e os chamamosString.

Exemplo

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 - A saída irá anexar o nome do grupo para cada caso de teste, conforme fornecido abaixo -

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

Cada página da web reside dentro de uma janela do navegador que pode ser considerada um objeto.

UMA Document objectrepresenta o documento HTML que é exibido nessa janela. O objeto Document possui várias propriedades que se referem a outros objetos que permitem o acesso e a modificação do conteúdo do documento.

A forma como o conteúdo de um documento é acessado e modificado é chamada de Document Object Model, ou DOM. Os objetos são organizados em uma hierarquia. Essa estrutura hierárquica se aplica à organização de objetos em um documento da web.

Window- Topo da hierarquia. É o elemento mais externo da hierarquia de objetos.
Document- Cada documento HTML que é carregado em uma janela se torna um objeto de documento. O documento contém o conteúdo da página.
Elements- representam o conteúdo de uma página da web. Os exemplos incluem as caixas de texto, título da página, etc.
Nodes - geralmente são elementos, mas também podem ser atributos, texto, comentários e outros tipos de DOM.

Aqui está uma hierarquia simples de alguns objetos DOM importantes -

Dart fornece o dart:htmlbiblioteca para manipular objetos e elementos no DOM. Aplicativos baseados em console não podem usar odart:htmlbiblioteca. Para usar a biblioteca HTML nos aplicativos da web, importedart:html -

import 'dart:html';

Seguindo em frente, discutiremos alguns DOM Operations na próxima seção.

Encontrando Elementos DOM

o dart:html biblioteca fornece o querySelector função para pesquisar elementos no DOM.

Element querySelector(String selectors);

o querySelector() função retorna o primeiro elemento que corresponde ao grupo especificado de seletores. "selectors deve ser uma string usando a sintaxe do seletor CSS conforme fornecido abaixo

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

Exemplo: Manipulando DOM

Siga as etapas fornecidas abaixo, no IDE Webstorm -

Step 1 - Arquivo NewProject → No local, forneça o nome do projeto como DemoWebApp.

Step 1 - Na seção "Gerar conteúdo de amostra", selecione SimpleWebApplication.

Ele criará um projeto de amostra, DemoWebApp. Existe umpubspec.yaml arquivo contendo as dependências que precisam ser baixadas.

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

Se você estiver conectado à Web, eles serão baixados automaticamente, caso contrário, você pode clicar com o botão direito no pubspec.yaml e obter dependências.

Na pasta da web, você encontrará três arquivos: Index.html, main.dart, e 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!!!.'; 
}

Execute o index.htmlArquivo; você verá a seguinte saída em sua tela.

Manipulação de eventos

o dart:html biblioteca fornece o onClickevento para elementos DOM. A sintaxe mostra como um elemento pode lidar com um fluxo de eventos de clique.

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

o querySelector() função retorna o elemento do DOM fornecido e onClick.listen() vai levar um eventHandlermétodo que será chamado quando um evento de clique for gerado. A sintaxe deeventHandler é dado abaixo -

void eventHanlderFunction (MouseEvent event){ }

Vamos agora dar um exemplo para entender o conceito de Manipulação de Eventos no 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; 
}

Resultado