└── README.md /README.md: -------------------------------------------------------------------------------- 1 | # **Introdução** 2 | 3 | Com este guia você aprenderá **tudo** o que é necessário sobre o Dart, para começar sua jornada com o Flutter. 4 | 5 | > Dart é a [**melhor**](https://www.youtube.com/watch?v=J5DQRPRBiFI) linguagem de programação já feita pelo Google. 6 | 7 | 8 | --- 9 | 10 | ## **Sumário** 11 | - [**Por que o Flutter usa Dart?**](#por-que-o-flutter-usa-dart) 12 | - [**Conceitos fundamentais**](#conceitos-fundamentais) 13 | - [**`main()`**](#main) 14 | - [**Tipos de dados**](#tipos-de-dados) 15 | - [**Variáveis**](#variáveis) 16 | - [**Inferência**](#inferência) 17 | - [**`var / const / final`**](#var--const--final) 18 | - [**Null Safety**](#null-safety) 19 | - [**Operadores**](#operadores) 20 | - [**```if```**](#if) 21 | - [**```switch```**](#switch) 22 | - [**```while```**](#while) 23 | - [**```for```**](#for) 24 | - [**Funções**](#funções) 25 | - [**Classes**](#classes) 26 | - [**Herança**](#herança) 27 | - [**Coleções**](#coleções) 28 | - [**```try / catch / finally```**](#try--catch--finally) 29 | - [**`Future`**](#future) 30 | - [**`async / await`**](#async--await) 31 | - [**E agora?**](#e-agora) 32 | - [**Referências**](#referências) 33 | 34 | --- 35 | 36 | ## **Por que o Flutter usa Dart ?** 37 | 38 | Dart oferece 2 modos de execução distintos: 39 | 40 | 1. **Interpretado (JIT - Just-In-Time):** 41 | - Utilizado durante o desenvolvimento 42 | - Permite hot-reload para atualizações rápidas 43 | - Código interpretado em tempo real pela Dart VM 44 | 45 | 2. **Compilado (AOT - Ahead-Of-Time):** 46 | - Utilizado para a publicação dos aplicativos 47 | - Código pré-compilado para código de máquina nativo 48 | - Oferece inicialização rápida e alto desempenho 49 | 50 | Assim, proporciona equilíbrio entre produtividade (do desenvolvedor) e desempenho (do aplicativo): 51 | 52 | > #### **Interpretado** (JIT = **j**ust-**i**n-**t**ime): O código é interpretado e executado em tempo real pela Dart VM (*virtual machine*), semelhante a linguagens como Python ou Javascript. Essa abordagem é particularmente benéfica durante o desenvolvimento, possibilitando o hot-reload. Isso significa que as alterações no código são injetadas em um aplicativo em execução sem a necessidade de reinicialização. Este modo é utilizado para o desenvolvimento dos aplicativos. 53 | 54 | --- 55 | 56 | > #### **Compilado** (AOT = **a**head **o**f **t**ime): O código é pré-compilado em código de máquina nativo, semelhante a linguagens como Java ou Swift. Esta abordagem aumenta significativamente a velocidade de inicialização e o desempenho geral. Este modo é utilizado para a publicação dos aplicativos. 57 | 58 | ### **E qual a vantagem?** 59 | 60 | Ao oferecer os modos JIT e AOT, o Dart fornece um equilíbrio único entre produtividade do desenvolvedor e desempenho do aplicativo. 61 | 62 | *Para desenvolvedores:* Uma experiência incrível, pois o código é interpretado e as alterações são refletidas em menos de 2 segundos. 63 | 64 | *Para os usuários:* Um aplicativo altamente performático, já que o código foi compilado para a plataforma nativa na qual está sendo executado. 65 | 66 | Esta versatilidade é uma razão chave pela qual o Flutter utiliza o Dart. 67 | 68 | | | Interpretado (JIT) | Compilado (AOT) | 69 | |-----------------|-----------------------------------------------|---------------------------------------------| 70 | | **Código** | Interpretado e executado em tempo real | Pré-compilado em código de nativo | 71 | | **Semelhança** | Python, JavaScript | Java, Swift | 72 | | **Uso** | Desenvolvimento | Produção | 73 | | **Vantagem** | Hot-reload | Performance | 74 | | **Execução** | Lenta | Rápida | 75 | 76 | Caso queira se aprofundar, recomendo os materiais abaixo: 77 | 78 | [Primeiro artigo sobre este assunto](https://hackernoon.com/why-flutter-uses-dart-dd635a054ebf) 79 | 80 | [Documentação oficial do Flutter](https://flutter.dev/docs/resources/faq#why-did-flutter-choose-to-use-dart) 81 | 82 | [Vídeo no canal do Flutter](https://www.youtube.com/watch?v=5F-6n_2XWR8&ab_channel=Flutter) 83 | 84 | --- 85 | 86 | ## **Conceitos fundamentais** 87 | 88 | - É uma linguagem **tipada**, porém a declaração de tipos é opcional. 89 | - Tudo em Dart é um objeto (instância de `Object`), exceto `null`. 90 | - Null safety: variáveis não aceitam `null` por padrão (é necessário declarar **explicitamente** esta possibilidade). 91 | 92 | --- 93 | 94 | ## **`main()`** 95 | Todo programa Dart (e aplicativos em Flutter, são programas Dart), iniciam na função `main()`: 96 | 97 | ```dart 98 | void main() { 99 | print('Flutter Bootcamp'); 100 | } 101 | ``` 102 | ## **Tipos de dados** 103 | 104 | Básicos: 105 | 106 | - Numérico: `int` e `double` 107 | - Literal: `String` 108 | - Booleano: `true` e `false` 109 | - Coleções: `List`,`Sets` e `Maps` 110 | - `null` 111 | 112 | Especiais: 113 | - `Object`: A **super classe** do Dart. Todos os objetos são herdados dela, com exceção do tipo `Null`. 114 | - `Future` e `Stream`: Utilizadas para operações assíncronas. 115 | - `dynamic`: Desabilita a tipagem do Dart e permite que qualquer tipo de dados seja utilizado. 116 | - `void`: Utilizado como retorno (geralmente). Indica que este valor nunca é usado. 117 | 118 | 119 | ## **Variáveis** 120 | 121 | Variáveis armezenam referências. E em Dart, podemos declarar variáveis informando o seu tipo ou não (*a tipagem é opcional*): 122 | 123 | ```dart 124 | String bootcamp = 'Flutter Bootcamp'; 125 | // bootcamp é uma variável do tipo String 126 | ``` 127 | 128 | E esta sintaxe se aplica para todos os outros tipos de dados: 129 | 130 | ```dart 131 | int lancamento = 2024; 132 | double versao = 2.0; 133 | List aplicativos = ['Tempus', 'Menuo', 'Libria', 'Civitas']; 134 | Map informacoes = { 135 | 'tags': ['flutter','dart'], 136 | 'descricao': 'Treinamento completo em Flutter', 137 | 'aplicativos': 6 138 | }; 139 | 140 | ``` 141 | 142 | ## **Inferência** 143 | 144 | A declaração de tipos em Dart é opcional, ou seja, ambas declarações abaixo são válidas: 145 | 146 | ```dart 147 | //tipo String declarado 148 | String bootcampTipado = 'Flutter Bootcamp'; 149 | 150 | // tipo não declarado 151 | var bootcampSemTipo = 'Flutter Bootcamp'; 152 | ``` 153 | 154 | Por **inferência**, o Dart consegue identificar que `bootcampSemTipo` é do tipo `String` devido ao valor atribuido. 155 | 156 | E o mesmo se aplica para todos os outros tipos de dados. 157 | 158 | ```dart 159 | // int 160 | var lancamento = 2024; 161 | 162 | // double 163 | var versao = 1.0; 164 | 165 | // List 166 | var aplicativos = ['Tempus', 'Menuo', 'Libria', 'Civitas']; 167 | 168 | // Map 169 | var informacoes = { 170 | 'tags': ['flutter','dart'], 171 | 'descricao': 'Treinamento completo em Flutter', 172 | 'aplicativos': 6 173 | }; 174 | ``` 175 | 176 | ## **`var / const / final`** 177 | 178 | Estes são os modificadores possíveis ao declarar variáveis: 179 | 180 | - **var:** Permite que o valor seja alterado. 181 | 182 | - **final:** O valor não pode ser alterado e **não** é conhecido em tempo de execução. 183 | 184 | - **const:** O valor não pode ser alterado e ja é conhecido em tempo de execução. 185 | 186 | > Sempre que possível, utilize `const`. 187 | 188 | ## **Null Safety** 189 | 190 | Por padrão, o Dart não aceita variáveis com valor `null`. Sendo mandatório iniciar a variável com um valor. 191 | 192 | Para que uma variável aceite valor `null`, devemos declarar explicitamente, caso contrário, o compilador indicará um erro: 193 | 194 | ```dart 195 | int idade; 196 | print(idade); 197 | 198 | ❌ The non-nullable local variable 'idade' must be assigned before it can be used. 199 | ``` 200 | 201 | Este erro ocorre pois estamos acessando `idade` antes de atribuir um valor à ela. 202 | 203 | Ao utilizar o operador `?`, indicamos ao compilador que a variável pode ter valor `null`. 204 | 205 | ```dart 206 | int? idade; 207 | print(idade); 208 | 209 | ✅ será imprimido o valor null 210 | ``` 211 | 212 | ## **Operadores** 213 | 214 | Dart possui todos os tipos de operadores tradicionais: `==`, `!=`, `&&`, `||`, `>`, `>=`, `+=`, `!`, e muitos outros. 215 | 216 | Porém, precisamos destacar 3 que são amplamente utilizados: 217 | 218 | - `?` - Indica que uma variável pode ter valor `null`. 219 | - `??` - Retorna o valor da 1a expressão **não** seja `null`. Se for `null`, retorna a 2a expressão. 220 | - `:` - Se a condição for `true`, retorna o valor da 1a expressão. Caso **não** seja `null`, retorna a 2a expressão. 221 | 222 | ```dart 223 | // O valor null não pode ser atribuído à variavel mes 224 | int mes = null; 225 | 226 | // Em ambas declarações, o valor de mes é null. 227 | int? mes = null; 228 | int? mes; 229 | 230 | // anoAtual possui valor de 2024, pois ano é null 231 | int? ano; 232 | var anoAtual = ano ?? 2024; 233 | 234 | // maiorIdade possui valor true, pois (idade é maior que 18) 235 | var idade = 34; 236 | var maiorIdade = idade > 18 ? true : false; 237 | ``` 238 | 239 | ## **```if```** 240 | 241 | ```dart 242 | if (condicao) { 243 | 244 | } else if (outraCondicao){ 245 | 246 | } else { 247 | 248 | } 249 | ``` 250 | 251 | ## **```switch```** 252 | ```dart 253 | switch (variavel) { 254 | case valor1: 255 | break; 256 | case valor2: 257 | break; 258 | default; // opcional, acionado caso variavel não seja valor1 ou valor2 259 | } 260 | ``` 261 | 262 | ## **```while```** 263 | 264 | 265 | ```dart 266 | 267 | var mes = 1; 268 | while (mes < 13) { 269 | mes++; 270 | } 271 | 272 | var ano = 2024; 273 | do { 274 | ano++; 275 | } while (ano < 2050); 276 | ``` 277 | 278 | ## **```for```** 279 | 280 | ```dart 281 | for (var i = 0; i < 5; i++) { 282 | 283 | } 284 | 285 | for (var item in minhaLista) { 286 | 287 | } 288 | ``` 289 | 290 | 291 | ## **Funções** 292 | 293 | São instruções de código executadas em sequência. 294 | 295 | No Dart, são objetos do tipo `Function`, ou seja, podem ser atribuídas a variáveis ou passadas como parâmetros. 296 | 297 | ```dart 298 | bool isMaiorDeIdade(int idade) { 299 | return idade >= 18; 300 | } 301 | 302 | // se a função possui apenas 1 instrução, pode ser declarada com => 303 | bool isMaiorIdade(int idade) => idade > 18; 304 | ``` 305 | 306 | ## **Classes** 307 | 308 | Fornecem uma estrutura para a criação de **objetos**. 309 | 310 | ```dart 311 | class FlutterBootcamp { 312 | 313 | // atributos 314 | int? aplicativos; 315 | String? descricao; 316 | List? tags; 317 | 318 | // construtor default(opcional, não é necessário declarar) 319 | FlutterBootcamp(); 320 | 321 | // construtor com parâmetros 322 | FlutterBootcamp(this.aplicativos, this.descricao, this.tags); 323 | 324 | // funções 325 | void exibirConteudo(){ 326 | print('Construa $aplicativos aplicativos com Flutter!'); 327 | } 328 | 329 | } 330 | ``` 331 | 332 | Há também os `named constructors`, que permitem criar a instância do objeto com valores específicos. 333 | 334 | ```dart 335 | class Carro{ 336 | String? marca; 337 | int? ano; 338 | double? motor; 339 | 340 | Carro.popular(){ 341 | motor = 1.0; 342 | } 343 | 344 | Carro.novo(): 345 | ano = 2024; 346 | 347 | Carro.tesla(this.ano, this.motor): 348 | marca = 'Tesla'; 349 | } 350 | 351 | // gol possui motor=1.0 352 | var gol = Carro.popular(); 353 | 354 | // corollaCross possui ano=2024 355 | var corollaCross = Carro.novo(); 356 | 357 | // modelS possui marca='Tesla', ano=2020, motor=2.0 358 | var modelS = Carro.tesla(2020, 2.0); 359 | ``` 360 | ## **Herança** 361 | 362 | É um padrão da orientação à objetos que permite a criação de **subclasses**. 363 | 364 | No Dart, utilizamos a palavra-chave `extends` para indicar que uma classe é *filha* de outra. 365 | 366 | ```dart 367 | class Bootcamp { 368 | String? linguagem; 369 | Bootcamp(this.linguagem); 370 | void basico() { 371 | print('Conceitos Básicos OO'); 372 | conteudo(); 373 | } 374 | 375 | void conteudo() { 376 | print('Objetos, Herança, Encapsulamento'); 377 | } 378 | } 379 | 380 | class FlutterBootcamp extends Bootcamp { 381 | FlutterBootcamp(super.linguagem); 382 | aprenderDart() { 383 | super.basico(); 384 | super.linguagem = 'Dart'; 385 | } 386 | 387 | @override 388 | void conteudo() { 389 | print('Tipos de dados e construtores'); 390 | } 391 | } 392 | ``` 393 | 394 | ## **Coleções** 395 | 396 | ```dart 397 | // list 398 | var aplicativos = ['libria', 'menuo', 'civitas']; 399 | 400 | // set 401 | var aplicativos = {'libria', 'menuo', 'civitas'}; 402 | 403 | // map 404 | var aplicativos = { 405 | 1 : 'libria', 406 | 2 : 'menuo', 407 | 3 : 'civitas' 408 | }; 409 | ``` 410 | ## **```try / catch / finally```** 411 | 412 | ```dart 413 | try { 414 | // código que pode gerar erro 415 | } catch (e) { 416 | // executado caso ocorra erro 417 | } finally { // opcional 418 | // executado independente de ter ocorrido erro ou não 419 | } 420 | ``` 421 | 422 | ## **Future** 423 | 424 | São objetos utilizados para tratar operações assíncronas (sem sincronia), como: 425 | 426 | - Consumir uma API; 427 | - Operações em banco de dados; 428 | - Ler / gravar em um arquivo. 429 | 430 | > Qualquer operação que não seja concluída **imediatamente** é uma operação *assíncrona*. 431 | 432 | Future é um objeto que representa uma operação assíncrona. Assim que a operação for concluída, o valor está pronto para ser usado. 433 | 434 | ```dart 435 | Future buscarApi() async { 436 | // Future.delayed: simula uma operação assíncrona 437 | return Future.delayed(Duration(seconds: 2), () => 2); 438 | } 439 | 440 | void consultarTotalCommits() { 441 | Future totalCommits = buscarApi(); 442 | totalCommits.then((total) => print(total)); 443 | } 444 | 445 | void main() => consultarTotalCommits(); 446 | ``` 447 | 448 | O compilador **não** irá esperar o retorno da API continuar o processamento. 449 | 450 | ## **`async / await`** 451 | 452 | As palavras-chave `async` e `await`, permitem escrever código com operações assíncronas similar à **operações síncronas**. 453 | 454 | O código anterior, com `async` e `await`, poderia ser escrito da seguinte forma: 455 | 456 | ```dart 457 | // deve-se usar async para indicar o uso do await dentro de uma função 458 | void consultarTotalCommits() async { 459 | // usando o await, fará o compilador esperar até que buscarApi() conclua seu processamento 460 | int totalCommits = await buscarApi(); 461 | tratarRetorno(total); 462 | } 463 | ``` 464 | 465 | O compilador **irá** esperar o retorno da API para continuar o processamento. 466 | 467 | ## **E agora ?** 468 | 469 | ### Parabéns! 👏 470 | 471 | Tudo sobre linguagem Dart necessário para começar com Flutter já foi apresentado. 472 | 473 | A documentação oficial do Dart é uma ótima fonte de conhecimento: 474 | 475 | - [Introduction to Dart](https://dart.dev/samples) 476 | - [Effective Dart](https://dart.dev/guides/language/effective-dart) 477 | - [Dart Tutorials](https://dart.dev/tutorials) 478 | 479 | #### Bons estudos 📖 --------------------------------------------------------------------------------