From 987191da39e3d3cb022afe8d16846918cdc9d5bf Mon Sep 17 00:00:00 2001 From: laysleal Date: Mon, 15 Sep 2025 21:58:11 -0300 Subject: [PATCH 1/5] =?UTF-8?q?In=C3=ADcio=20da=20tradu=C3=A7=C3=A3o?= MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit --- pt-br/dart.md | 579 +++++++++++++++++++++++++++++++------------------- 1 file changed, 357 insertions(+), 222 deletions(-) diff --git a/pt-br/dart.md b/pt-br/dart.md index f8b08c05fe..df52d9015d 100644 --- a/pt-br/dart.md +++ b/pt-br/dart.md @@ -4,12 +4,15 @@ contributors: - ["Hélio Oliveira", "https://github.com/insign/"] translators: - ["Junior Damacena", "https://github.com/jdamacena/"] + - ["Lays Leal Correia", "https://github.com/laysleal/"] --- -Dart é uma novata no reino das linguagens de programação. -Ela absorve muitas teorias de outras linguagens mais conhecidas, e tem a meta de não se diferenciar muito de seu irmão, JavaScript. Assim como JavaScript, Dart foi pensada para oferecer grande integração com o navegador. +**Dart** é uma linguagem de programação de propósito geral e com uma única thread. +Ela herda muitos conceitos de outras linguagens populares. +Oferece suporte a Streams, Futures (conhecidas como Promises no JavaScript), Generics, funções de primeira classe (closures) e verificação de tipos estática. +O Dart pode ser executado em qualquer plataforma, como Web, CLI, Desktop, Mobile e dispositivos IoT. -As variáveis em Dart tem tipos, mas não é obrigatório declarar devido à função de [detecção automática](https://dart.dev/guides/language/type-system#type-inference). +As variáveis em Dart tem tipos, mas não é obrigatório declarar devido à função de [detecção automática](https://dart.dev/guides/language/type-system#type-inference), adicionalmente, possui um sistema de verificação para que valores sempre sejam compatíveis com as variáveis [Dart type system](https://dart.dev/language/type-system). ```dart import "dart:collection"; @@ -17,334 +20,466 @@ import "dart:math" as DM; // Bem vindo ao Aprenda Dart em 15 minutos. http://www.dartlang.org/ // Este é um tutorial executável. Você pode rodar esse tutorial com Dart ou no -// site Try Dart!, é só copiar e colar este código lá. http://try.dartlang.org/ - -// Declarações de funções e métodos são iguais. Declarações de funções -// podem ser aninhadas. A declaração é feita das seguintes formas -// nome() {} ou nome() => expressaoDeUmaLinhaSo; -// A declaração feita com a seta tem um return implícito para o resultado da -// expressão. -example1() { - example1nested1() { - example1nested2() => print("Example1 nested 1 nested 2"); - example1nested2(); - } - example1nested1(); -} - -// Funções anônimas são criadas sem um nome. -example2() { - example2nested1(fn) { +// site Try Dart!, é só copiar e colar este código lá. http://dartpad.dev/ +// É possível usar Flutter no DartPad, clique em `Create` > `Flutter snippet`. + +/// Em Dart, tudo é um objeto. +/// Toda declaração de um objeto é uma instância de Null. +/// Null também é um objeto. + +/// 3 Tipos de Comentários em Dart +// Comentário em uma única linha +/** +* Comentário em +* múltiplas +* linhas +*/ +/// Comentário para documentação +/// Usa a sintaxe Markdown para gerar a documentação ao criar uma API. +/// É a opção recomendada para suas APIs, classes e métodos. + +/// 4 Tipos de Declaração de Variáveis +/// Constantes são variáveis imutáveis, portanto não podem ser alteradas. +/// `const` em dart é tradicionalmente declarado utilizando SCREAMING_SNAKE_CASE. +/// Exemplo: +const VALOR_CONSTANTE = "NÃO POSSO SER ALTERADO"; +VALOR_CONSTANTE = "EU MUDEI?"; //Resulta em erro + +/// Final é outra variável que não pode ser alterada depois de declarada. +/// Geralmente é usada para classe e funções. +/// `final` é tradicionalmente declarada em pascalCase. +final valorFinal = "valor não pode ser alterado depois de declarado"; +valorFinal = "Alterado"; //Resulta em erro + +/// `var` é uma variável de valor mutável. +/// Caso seu tipo não seja declarado (String, int, etc.) o Dart conseguirá +/// inferir qual é e não permitirá que esse tipo seja alterado. +var valorAlteravel = "String variável"; +valorAlteravel = "esse comando é válido"; +valorAlteravel = false; //Resulta em erro. + +/// `dynamic` é outra variável de valor mutável, mas seu tipo não será inferido. +/// Tanto o seu valor quanto o seu tipo podem ser alterados. +/// Programadores utilizam dynamic de forma cautelosa já que nem sempre é +/// possível saber qual o seu tipo em determinada situação. +/// Utilize por sua própria conta e risco. +dynamic valorDinamico = "Eu sou uma string"; +valorDinamico = false; // O comando é válido + +/// Funções podem ser declaradas em um espaço global. +/// Declarações de funções e métodos são iguais. +/// Declarações de funções podem ser aninhadas. +/// A declaração é feita das seguintes formas nome() {} ou +/// nome() => expressaoDeUmaLinhaSo; +/// Utilizando a seta o return pode ser implícito ou explícito. +/// O Dart vai executar a função `main()` independente da localização dela. +/// +exemplo1() { + exemplo1aninhado1() { + exemplo1aninhado2() => print("Exemplo1 aninhado 1 aninhado 2"); + exemplo1aninhado2(); + } + exemplo1aninhado1(); +} + +/// Funções anônimas são criadas sem um nome. +exemplo2() { + // Return explícito. + aninhado1(void function() fn) { fn(); } - example2nested1(() => print("Example2 nested 1")); + aninhado1(() => print("Exemplo2 aninhado 1")); } -// Quando uma função é declarada como parâmetro, a declaração pode incluir o número -// de parâmetros que a função recebe, isso é feito especificando o nome de cada um dos -// parâmetros que serão recebidos pela função. -example3() { - example3nested1(fn(informSomething)) { - fn("Example3 nested 1"); +/// Quando a função possui parâmetros, a declaração pode incluir o número +/// de parâmetros que a função recebe, isso é feito especificando o nome de cada um dos +/// parâmetros que serão recebidos pela função. +exemplo3() { + planoA(fn(String informarAlgo)) { + fn("Exemplo3 plano A"); } - example3planB(fn) { // Ou não declare o número de parâmetros. - fn("Example3 plan B"); + planoB(fn) { + // Ou não declare o número de parâmetros. + fn("Exemplo3 plano B"); } - example3nested1((s) => print(s)); - example3planB((s) => print(s)); + planoA((s) => print(s)); + planoB((s) => print(s)); } -// Funções têm acesso à variáveis fora de seu escopo -var example4Something = "Example4 nested 1"; +/// Funções têm acesso à variáveis fora de seu escopo +var exemplo4 = "Example4 aninhado 1"; example4() { - example4nested1(fn(informSomething)) { - fn(example4Something); + aninhado1(fn(informarAlgo)) { + fn(example4); } - example4nested1((s) => print(s)); + aninhado1((s) => print(s)); } -// Declaração de classe com um método chamado sayIt, que também tem acesso -// à variável externa, como se fosse uma função como se viu antes. -var example5method = "Example5 sayIt"; -class Example5Class { +/// Declaração de classe com um método chamado sayIt, que também tem acesso +/// a variáveis externas, assim como visto acima. +var exemplo5 = "Exemplo5 sayIt"; +class Exemplo5Class { sayIt() { - print(example5method); + print(exemplo5); } } -example5() { - // Criar uma instância anônima de Example5Class e chamar o método sayIt - // nela. - new Example5Class().sayIt(); +exemplo5() { + // Criar uma instância anônima de Exemplo5Class e chamar o método sayIt. + new Exemplo5Class().sayIt(); } -// A declaração de uma classe é feita da seguinte maneira: class name { [classBody] }. -// onde classBody pode incluir métodos e variáveis de instância, assim como -// métodos e variáveis de classe. -class Example6Class { - var example6InstanceVariable = "Example6 instance variable"; +/// A declaração de uma classe é feita da seguinte maneira: class name { [classBody] }. +/// onde classBody pode incluir métodos e variáveis de instância, assim como +/// métodos e variáveis de classe. +class Exemplo6Class { + var variavelInstancia = "Exemplo6 variável instância"; sayIt() { - print(example6InstanceVariable); + print(variavelInstancia); } } -example6() { - new Example6Class().sayIt(); +exemplo6() { + Exemplo6Class().sayIt(); } -// Métodos e variáveis de classe são declarados como "static". -class Example7Class { - static var example7ClassVariable = "Example7 class variable"; - static sayItFromClass() { - print(example7ClassVariable); +/// Métodos e variáveis de classe são declarados como "static". +class Exemplo7Class { + static var classVariable = "Exemplo7 class variable"; + static sayItDoClass() { + print(classVariable); } - sayItFromInstance() { - print(example7ClassVariable); + sayItDaInstancia() { + print(classVariable); } } example7() { - Example7Class.sayItFromClass(); + Exemplo7Class.sayItDoClass(); new Example7Class().sayItFromInstance(); } -// Literais são ótimos, mas há uma limitação para o que eles podem ser -// quando estão fora do corpo de uma função/método. Literais fora do escopo da classe -// ou fora da classe têm que ser constantes. Strings e números são constantes -// por padrão. Mas arrays e mapas não. Eles podem ser declarados como constantes -// usando o comando "const". -var example8A = const ["Example8 const array"], - example8M = const {"someKey": "Example8 const map"}; -example8() { - print(example8A[0]); - print(example8M["someKey"]); -} - -// Loops em Dart são criados com for () {} ou while () {}, -// um pouco mais moderno temos for (.. in ..) {}, ou funções de callbacks com muitas -// funcionalidades, começando com o forEach. -var example9A = const ["a", "b"]; -example9() { - for (var i = 0; i < example9A.length; i++) { - print("Example9 for loop '${example9A[i]}'"); +/// O Dart oferece suporte a Genéricos. +/// Genéricos se referem à técnica de escrever o código de uma classe +/// sem especificar o(s) tipo(s) de dados com os quais a classe irá trabalhar. +/// Fonte: [Stack Overflow](https://stackoverflow.com/questions/4560890/what-are-generics-in-c) + +/// O tipo `T` se refere a qualquer tipo que tenha sido instanciado, +/// você pode chamá-lo como quiser. +/// Os programadores usam a seguinte convenção: +/// T - Type (usado para classes e tipos primitivos) +/// E - Element (usado para List, Set ou Iterable) +/// K,V - Key e Value (usados para Map) + +class ExemploGenerico{ + void printType(){ + print("$T"); + } + // Métodos também podem ter genéricos + metodoGenerico(){ + print("classe:$T, metodo: $M"); + } +} + +/// Listas são semelhantes a arrays, mas `List` é filha de `Iterable`. +/// Portanto, Maps, List e LinkedList são todos filhos de `Iterable` +/// para que seja possível iterar usando a palavra-chave `for`. +/// Pontos importantes a lembrar: +/// () - Iterable +/// [] - List +/// {} - Map + +/// Listas são ótimas, mas há uma limitação para o que elas podem ser quando +/// estão fora do corpo de uma função/método. Listas fora do escopo da classe +/// ou fora da classe precisam que ser constantes. Strings e números são +/// constantes por padrão. Mas arrays e mapas não são. Eles podem ser declarados +/// como constantes usando o comando "const". +const exemplo8List = ["Exemplo8 const array"]; +const exemplo8Map = {"chave": "Exemplo8 const map"}; +/// Declare listas ou mapas como objetos. + List listaExplicita = new List.empty(); + Map mapaExplicito = new Map(); + +exemplo8() { + listaExplicita.add("listaQualquer"); + print(exemplo8Map["mapaQualquer"]); + print(listaExplicita[0]); + + /// Atribuir uma lista de uma variável para outra não terá o mesmo resultado. + /// Isso acontece porque o Dart utiliza [pass-reference-by-value](https://stackoverflow.com/questions/25170094/what-is-the-true-meaning-of-pass-by-reference-in-modern-languages-like-dart). + /// Então, quando você atribui uma lista existente a uma nova variável, + /// em vez de continuar sendo uma `List`, ela se torna um `Iterable`. + var iterableExplicitList = explicitList; + print(iterableExplicitList); // ("SomeArray"); "[]" becomes "()" + var newExplicitLists = explicitList.toList(); // Converts Iterable to List +} + +/// Loops em Dart são criados com for () {}, while () {} ou for (.. in ..) {}, ou +/// funções de callbacks com muitas funcionalidades, começando com +/// forEach, map e where. +var exemplo9 = const ["a", "b"]; +exemplo9() { + for (int i = 0; i < exemplo9.length; i++) { + print("Exemplo9 for loop '${exemplo9[i]}'"); } var i = 0; - while (i < example9A.length) { - print("Example9 while loop '${example9A[i]}'"); + while (i < exemplo9.length) { + print("Exemplo9 while loop '${exemplo9[i]}'"); i++; } - for (var e in example9A) { + for (final e in exemplo9) { print("Example9 for-in loop '${e}'"); } - example9A.forEach((e) => print("Example9 forEach loop '${e}'")); + + exemplo9.forEach((e) => print("Exemplo9 forEach loop '${e}'")); } -// Para percorrer os caracteres de uma string ou extrair uma substring. -var example10S = "ab"; -example10() { - for (var i = 0; i < example10S.length; i++) { - print("Example10 String character loop '${example10S[i]}'"); +/// Para percorrer os caracteres de uma string ou extrair uma substring. +var exemplo10 = "ab"; +exemplo10() { + for (var i = 0; i < exemplo10.length; i++) { + print("exemplo10 caracteres de String'${exemplo10[i]}'"); } - for (var i = 0; i < example10S.length; i++) { - print("Example10 substring loop '${example10S.substring(i, i + 1)}'"); + for (var i = 0; i < exemplo10.length; i++) { + print("exemplo10 substring '${exemplo10.substring(i, i + 1)}'"); } } -// Int e double são os dois formatos de número suportados. -example11() { +/// `int`, `double` e `num` são os três formatos de número suportados. +/// `num` pode ser tanto `int` quanto `double`. +/// `int` e `double` são filhos do tipo `num`. +exemplo11() { var i = 1 + 320, d = 3.2 + 0.01; - print("Example11 int ${i}"); - print("Example11 double ${d}"); -} - -// DateTime traz operações com data/hora. + final num meuFinalNumDouble = 2.2; + final num meuFinalNumInt = 2; + final int meuFinalInt = 1; + final double meuFinalDouble = 0.1; + num meuNumDouble = 2.2; + num meuNumInt = 2; + int meuInt = 1; + double meuDouble = 0; // O Dart transformará ele em 0.0; + meuNumDouble = meuFinalInt; // valido + meuNumDouble = meuFinalDouble; // valido + meuNumDouble = meuFinalNumInt; // valido + + meuInt = meuNumDouble; // erro + meuInt = meuFinalDouble; // erro + meuInt = meuFinalNumInt; // erro + meuInt = meuFinalNumInt as int; // valido + + meuDouble = meuFinalInt; // erro + meuDouble = meuFinalNumInt; // erro + meuDouble = meuFinalNumDouble; // erro + meuDouble = meuFinalNumDouble as double; // valido + + print("Exemplo11 int ${i}"); + print("Exemplo11 double ${d}"); + +} + +/// DateTime traz operações com data/hora. example12() { var now = new DateTime.now(); - print("Example12 now '${now}'"); + print("Exemplo12 agora '${now}'"); now = now.add(new Duration(days: 1)); - print("Example12 tomorrow '${now}'"); + print("Exemplo12 amanhã '${now}'"); } -// Expressões regulares são suportadas. -example13() { - var s1 = "some string", s2 = "some", re = new RegExp("^s.+?g\$"); +/// Expressões regulares são suportadas. +exemplo13() { + var s1 = "uma string", s2 = "uma", re = new RegExp("^s.+?g\$"); match(s) { - if (re.hasMatch(s)) { - print("Example13 regexp matches '${s}'"); + if (re.daMatch(s)) { + print("Exemplo13 regexp dá match '${s}'"); } else { - print("Example13 regexp doesn't match '${s}'"); + print("Exemplo13 regexp não dá match '${s}'"); } } match(s1); match(s2); } -// Expressões booleanas precisam retornar ou true ou false, já que -// Dart não faz a conversão implicitamente. -example14() { - var v = true; - if (v) { - print("Example14 value is true"); +/// Expressões booleanas tem suporte a conversões implícitas e tipos dinâmicos +exemplo14() { + var a = true; + if (a) { + print("verdadeiro, a é $a"); + } + a = false; + if (a) { + print("verdadeiro, a é $a"); + } else { + print("falso, a é $a"); } - v = null; + + /// Tipo dinâmico que assume valor nulo não pode ser convertido para booleano + var b; // b é de tipo dinâmico + b = "abc"; try { - if (v) { - // Nunca seria executada + if (b) { + print("verdadeiro, b é $b"); } else { - // Nunca seria executada + print("falso, b é $b"); } } catch (e) { - print("Example14 null value causes an exception: '${e}'"); + print("erro, b é $b"); + } + b = null; + if (b) { // Afirmação errônea: uma expressão boolena não pode ser nula + print("verdadeiro, b é $b"); + } else { + print("falso, b é $b"); } } -// try/catch/finally e throw são usados para tratamento de exceções. -// throw aceita qualquer objeto como parâmetro; -example15() { +/// try/catch/finally e throw são usados para tratamento de exceções. +/// throw aceita qualquer objeto como parâmetro; +exemplo15() { try { try { - throw "Some unexpected error."; + throw "Erro inesperado."; } catch (e) { - print("Example15 an exception: '${e}'"); + print("Exemplo15 tem exceção: '${e}'"); throw e; // Re-throw } } catch (e) { - print("Example15 catch exception being re-thrown: '${e}'"); + print("Exemplo15 encontra exceção passando por re-thrown: '${e}'"); } finally { - print("Example15 Still run finally"); + print("Exemplo15 passa pelo finally"); } } -// Para mais eficiência ao criar strings longas dinamicamente, use o -// StringBuffer. Ou você pode também concatenar um array de strings. -example16() { +/// Para mais eficiência ao criar strings longas dinamicamente, use o +/// StringBuffer. Ou você pode também concatenar um array de strings. +exemplo16() { var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e; for (e in a) { sb.write(e); } - print("Example16 dynamic string created with " + print("Exemplo16 string dinâmica criada com " "StringBuffer '${sb.toString()}'"); - print("Example16 join string array '${a.join()}'"); + print("Exemplo16 juntando array de string '${a.join()}'"); } -// Strings podem ser concatenadas apenas colocando strings literais uma perto -// da outra, sem necessidade de nenhum outro operador. -example17() { - print("Example17 " +/// Strings podem ser concatenadas apenas colocando strings literais uma perto +/// da outra, sem necessidade de nenhum outra operação. +exemplo17() { + print("Exemplo17 " "concatenar " "strings " "é simples assim"); } -// Strings podem ser delimitadas por apóstrofos ou aspas e não há -// diferença entre os dois. Essa flexibilidade pode ser boa para -// evitar a necessidade de escapar conteúdos que contenham o delimitador da string. -// Por exemplo, aspas dos atributos HTMLse a string conter HTML. -example18() { - print('Example18 ' +/// Strings podem ser delimitadas por apóstrofos ou aspas e não há +/// diferença entre os dois. Essa flexibilidade pode ser boa para +/// evitar a necessidade de adaptar conteúdos que contenham um um caractere que +/// é delimitador (Ex.: algumas palavras em inglês). +/// Por exemplo, aspas dos atributos HTMLse a string conter HTML. +exemplo18() { + print('Exemplo18 ' "Don't can't I'm Etc" ''); } -// Strings com três apóstrofos ou aspas podem -// ter muitas linhas e incluem os delimitadores de linha (ou seja, os enter). +/// Strings com três apóstrofos ou aspas podem +/// ter muitas linhas e incluem os delimitadores de linha (ou seja, os enter). example19() { - print('''Example19 -Example19 Don't can't I'm Etc -Example19 '''); + print('''Exemplo19 +Exemplo19 Don't can't I'm Etc +Exemplo19 '''); } -// Strings têm a função de interpolação que é chamada com o caractere $. -// Com $ { [expression] }, o retorno da expressão é interpolado. -// $ seguido pelo nome de uma variável interpola o conteúdo dessa variável. -// $ pode ser escapedo assim \$. -example20() { +/// Strings têm a função de interpolação que é chamada com o caractere $. +/// Utilizando ${[expression]}, o retorno da expressão é interpolado. +/// $ seguido pelo nome de uma variável interpola o conteúdo dessa variável. +/// $ pode ser escapedo assim \$. +exemplo20() { var s1 = "'\${s}'", s2 = "'\$s'"; - print("Example20 \$ interpolation ${s1} or $s2 works."); -} - -// A tipagem opcional permite que APIs usem anotações e também ajuda os -// IDEs na hora das refatorações, auto-complete e checagem de -// erros. Note que até agora não declaramos nenhum tipo e o programa está -// funcionando normalmente. De fato, os tipos são ignorados em tempo de execução. -// Os tipos podem até mesmo estarem errados e o programa ainda vai dar o -// benefício da dúvida e rodar, visto que os tipos não importam. -// Existe um parâmetro que checa erros de tipagem que é o -// checked mode, dizem que é útil enquanto se está desenvolvendo, -// mas também é mais lento devido às checagens extras e por isso -// é evitado em ambiente de produção. -class Example21 { - List _names; - Example21() { - _names = ["a", "b"]; - } - List get names => _names; - set names(List list) { - _names = list; - } - int get length => _names.length; - void add(String name) { - _names.add(name); - } -} -void example21() { - Example21 o = new Example21(); + print("Exemplo20 \$ interpolação: ${s1} e $s2 funcionam da mesma forma."); +} + +/// A tipagem opcional permite que APIs usem anotações e também ajuda as +/// IDEs na hora das refatorações, auto-complete e checagem de +/// erros. Note que até agora não declaramos nenhum tipo e o programa está +/// funcionando normalmente. De fato, os tipos são ignorados em tempo de execução. +/// Os tipos podem até mesmo estar errados e o programa ainda vai dar o +/// benefício da dúvida e compilar, visto que os tipos não importam. +/// Existe um parâmetro que checa erros de tipagem que é o +/// checked mode, é útil enquanto se está desenvolvendo, +/// mas também é mais lento devido às checagens extras e por isso +/// é evitado em ambiente de produção. +class Exemplo21 { + List _nomes; + Exemplo21() { + _nomes = ["a", "b"]; + } + List get nomes => _nomes; + set nomes(List list) { + _nomes = list; + } + int get tamanho => _nomes.length; + void add(String nome) { + _nomes.add(nome); + } +} +void exemplo21() { + Exemplo21 o = new Example21(); o.add("c"); - print("Example21 names '${o.names}' and length '${o.length}'"); + print("Exemplo21 nomes '${o.names}' and tamanho '${o.tamanho}'"); o.names = ["d", "e"]; - print("Example21 names '${o.names}' and length '${o.length}'"); + print("Exemplo21 nomes '${o.names}' and tamanho '${o.tamanho}'"); } -// Herança em classes é feito assim: class name extends AnotherClassName {}. -class Example22A { - var _name = "Some Name!"; - get name => _name; +// Herança em classes é feito assim: class name extends NomeDeOutraClasse {}. +class Exemplo22A { + var _nome = "Um Nome!"; + get nome => _nome; } -class Example22B extends Example22A {} -example22() { - var o = new Example22B(); - print("Example22 class inheritance '${o.name}'"); +class Exemplo22B extends Exemplo22A {} +exemplo22() { + var o = new Exemplo22B(); + print("Exemplo22 herança da classe '${o.nome}'"); } -// Mistura de classes também é possível, e é feito assim: -// class name extends SomeClass with AnotherClassName {} -// É necessário extender uma classe para poder misturar com outra. -// No momento, classes misturadas não podem ter construtor. -// Mistura de classes é mais usado para compartilhar métodos com classes distantes, então -// a herança comum não fica no caminho do reuso de código. -// As misturas aparecem após o comando "with" na declaração da classe. -class Example23A {} -class Example23Utils { +/// Mistura de classes também é possível, e é feito assim: +/// class name extends UmaClasse with NomeDeOutraClasse {} +/// É necessário extender uma classe para poder misturar com outra. +/// No momento, classes misturadas não podem ter construtor. +/// Mistura de classes é mais usado para compartilhar métodos com classes distantes, então +/// a herança comum não fica no caminho do reuso de código. +/// As misturas aparecem após o comando "with" na declaração da classe. +class Exemplo23A {} +class Exemplo23Utils { addTwo(n1, n2) { return n1 + n2; } } -class Example23B extends Example23A with Example23Utils { - addThree(n1, n2, n3) { - return addTwo(n1, n2) + n3; +class Exemplo23B extends Exemplo23A with Exemplo23Utils { + addTres(n1, n2, n3) { + return addDois(n1, n2) + n3; } } -example23() { - var o = new Example23B(), r1 = o.addThree(1, 2, 3), - r2 = o.addTwo(1, 2); - print("Example23 addThree(1, 2, 3) results in '${r1}'"); - print("Example23 addTwo(1, 2) results in '${r2}'"); +exemplo23() { + var o = new Exemplo23B(), r1 = o.addTres(1, 2, 3), + r2 = o.addDois(1, 2); + print("Exemplo23 addTres(1, 2, 3) resultado: '${r1}'"); + print("Exemplo23 addDois(1, 2) resultado: '${r2}'"); } -// O método construtor da classe usa o mesmo nome da classe e -// é feito assim SomeClass() : super() {}, onde a parte ": super()" -// é opcional e é usada para passar parâmetros estáticos para o -// construtor da classe pai. -class Example24A { - var _value; - Example24A({value: "someValue"}) { - _value = value; +/// O método construtor da classe usa o mesmo nome da classe e +/// é feito assim: UmaClasse() : super() {}, onde a parte ": super()" +/// é opcional e é usada para passar parâmetros estáticos para o +/// construtor da classe pai. +class Exemplo24A { + var _valor; + Exemplo24A({valor: "umValor"}) { + _valor = valor; } - get value => _value; + get valor => _valor; } -class Example24B extends Example24A { - Example24B({value: "someOtherValue"}) : super(value: value); +class Exemplo24B extends Exemplo24A { + Exemplo24B({value: "umOutroValor"}) : super(value: valor); } -example24() { - var o1 = new Example24B(), - o2 = new Example24B(value: "evenMore"); - print("Example24 calling super during constructor '${o1.value}'"); - print("Example24 calling super during constructor '${o2.value}'"); +exemplo24() { + var o1 = new Exemplo24B(), + o2 = new Exemplo24B(value: "aindaMais"); + print("Exemplo24 puxando o super do construtor '${o1.value}'"); + print("Exemplo24 puxando o super do construtor '${o2.value}'"); } // Há um atalho para passar parâmetros para o construtor no caso de classes mais simples. From 595921228c694a7f834cf180f62b29e23d04afdb Mon Sep 17 00:00:00 2001 From: laysleal Date: Tue, 16 Sep 2025 13:56:58 -0300 Subject: [PATCH 2/5] [dart/pt-br] Added translation of updates made on the english article --- pt-br/dart.md | 209 ++++++++++++++++++++++++++++++-------------------- 1 file changed, 126 insertions(+), 83 deletions(-) diff --git a/pt-br/dart.md b/pt-br/dart.md index df52d9015d..a3b01da122 100644 --- a/pt-br/dart.md +++ b/pt-br/dart.md @@ -1,4 +1,5 @@ --- +name: Dart contributors: - ["Joao Pedrosa", "https://github.com/jpedrosa/"] - ["Hélio Oliveira", "https://github.com/insign/"] @@ -18,7 +19,7 @@ As variáveis em Dart tem tipos, mas não é obrigatório declarar devido à fun import "dart:collection"; import "dart:math" as DM; -// Bem vindo ao Aprenda Dart em 15 minutos. http://www.dartlang.org/ +// Bem vindo ao Aprenda Dart em 15 minutos. https://dart.dev/ // Este é um tutorial executável. Você pode rodar esse tutorial com Dart ou no // site Try Dart!, é só copiar e colar este código lá. http://dartpad.dev/ // É possível usar Flutter no DartPad, clique em `Create` > `Flutter snippet`. @@ -482,89 +483,89 @@ exemplo24() { print("Exemplo24 puxando o super do construtor '${o2.value}'"); } -// Há um atalho para passar parâmetros para o construtor no caso de classes mais simples. -// Simplesmente use o prefixo this.nomeDoParametro e isso irá passar o parâmetro para uma -// instância de variável de mesmo nome. -class Example25 { - var value, anotherValue; - Example25({this.value, this.anotherValue}); +/// Há um atalho para passar parâmetros para o construtor no caso de classes mais simples. +/// Simplesmente use o prefixo this.nomeDoParametro e isso irá passar o +/// parâmetro para uma instância de variável de mesmo nome. +class Exemplo25 { + var valor, outroValor; + Exemplo25({this.valor, this.outroValor}); } -example25() { - var o = new Example25(value: "a", anotherValue: "b"); - print("Example25 shortcut for constructor '${o.value}' and " +exemplo25() { + var o = new Exemplo25(valor: "a", outroValor: "b"); + print("Exemplo25 atalho para construtor '${o.value}' e " "'${o.anotherValue}'"); } -// Parâmetros com nome estão disponíveis quando declarados entre {}. -// Quando os parâmetros têm nomes, eles podem ser passados em qualquer ordem. -// Parâmetros declarados entre [] são opcionais. -example26() { - var _name, _surname, _email; - setConfig1({name, surname}) { - _name = name; - _surname = surname; +/// Parâmetros com nome estão disponíveis quando declarados entre {}. +/// Quando os parâmetros têm nomes, eles podem ser passados em qualquer ordem. +/// Parâmetros declarados entre [] são opcionais. +exemplo26() { + var _nome, _sobrenome, _email; + setConfig1({nome, sobrenome}) { + _nome = nome; + _sobrenome = sobrenome; } - setConfig2(name, [surname, email]) { - _name = name; - _surname = surname; + setConfig2(nome, [sobrenome, email]) { + _nome = nome; + _sobrenome = sobrenome; _email = email; } - setConfig1(surname: "Doe", name: "John"); - print("Example26 name '${_name}', surname '${_surname}', " - "email '${_email}'"); - setConfig2("Mary", "Jane"); - print("Example26 name '${_name}', surname '${_surname}', " - "email '${_email}'"); -} - -// Variáveis declaradas com um final só podem receber valor uma vez. -// No caso de classes, variáveis final podem ter valor atribuido através -// de um parâmetro no construtor -class Example27 { - final color1, color2; - // Um pouco de flexibilidade ao criar variáveis final com a sintaxe - // que é a seguinte: - Example27({this.color1, color2}) : color2 = color2; -} -example27() { - final color = "orange", o = new Example27(color1: "lilac", color2: "white"); - print("Example27 color is '${color}'"); - print("Example27 color is '${o.color1}' and '${o.color2}'"); -} - -// para importar uma biblioteca, use import "libraryPath" ou se for uma biblioteca da linguagem, -// import "dart:libraryName". Também tem o gerenciador de pacotes "pub"que tem -// sua própria convenção de import "package:packageName". -// Veja o import "dart:collection"; no início do arquivo. Imports devem vir no início -// do arquivo. IterableBase vem de dart:collection. -class Example28 extends IterableBase { - var names; - Example28() { - names = ["a", "b"]; - } - get iterator => names.iterator; -} -example28() { - var o = new Example28(); - o.forEach((name) => print("Example28 '${name}'")); -} - -// Para controle de fluxo nós temos: -// * switch com comandos break obrigatórios -// * if-else if-else e se-ternário ..?..:.. -// * closures e funções anônimas -// * comandos break, continue e return -example29() { + setConfig1(sobrenome: "Silva", name: "João"); + print("Exemplo26 nome: '${_name}', sobrenome: '${_surname}', " + "email: '${_email}'"); + setConfig2("José", "Maria"); + print("Exemplo26 nome: '${_name}', sobrenome: '${_surname}', " + "email: '${_email}'"); +} + +/// Variáveis declaradas com um final só podem receber valor uma vez. +/// No caso de classes, variáveis final podem ter valor atribuido através +/// de um parâmetro no construtor +class Exemplo27 { + final cor1, cor2; + /// Essa sintaxe fornece um pouco de flexibilidade ao criar variáveis: + Exemplo27({this.cor1, cor2}) : cor2 = cor2; +} +exemplo27() { + final cor = "laranja", o = new Exemplo27(cor1: "lilás", cor2: "branco"); + print("No Exemplo27 a cor é '${cor}'"); + print("No Exemplo27 a cor é '${o.cor1}' e '${o.cor2}'"); +} + +/// Para importar uma biblioteca, use import "caminhoDaBiblioteca" ou se for uma +/// biblioteca da linguagem: import "dart:nomeDaBiblioteca". +/// Também tem o gerenciador de pacotes "pub" que tem sua própria convenção: +/// import "package:packageName". +/// Observe o import "dart:collection" no início do arquivo. Imports devem vir +/// sempre no início. A classe IterableBase vem de "dart:collection". +class Exemplo28 extends IterableBase { + var nomes; + Exemplo28() { + nomes = ["a", "b"]; + } + get iterator => nomes.iterator; +} +exemplo28() { + var o = new Exemplo28(); + o.forEach((nome) => print("Exemplo28 '${nome}'")); +} + +/// Para controle de fluxo nós temos: +/// * switch com comandos break obrigatórios +/// * if-else if-else e se-ternário ..?..:.. +/// * closures e funções anônimas +/// * comandos break, continue e return +exemplo29() { var v = true ? 30 : 60; switch (v) { case 30: - print("Example29 switch statement"); + print("Exemplo29 comando switch"); break; } if (v < 30) { } else if (v > 30) { } else { - print("Example29 if-else statement"); + print("Exemplo29 comando if-else"); } callItForMe(fn()) { return fn(); @@ -574,7 +575,7 @@ example29() { return v; } while (true) { - print("Example29 callItForMe(rand) '${callItForMe(rand)}'"); + print("Exemplo29 callItForMe(rand) '${callItForMe(rand)}'"); if (v != 30) { break; } else { @@ -584,20 +585,21 @@ example29() { } } -// Você pode converter string para int, double para int, ou só pegar a parte inteira da divisão -// usando o comando ~/. Vamos jogar um jogo de adivinhação. -example30() { +/// Você pode converter string para int, double para int, ou só pegar a parte +/// inteira da divisão usando o comando ~/. +/// Vamos jogar um jogo de adivinhação. +exemplo30() { var gn, tooHigh = false, n, n2 = (2.0).toInt(), top = int.parse("123") ~/ n2, bottom = 0; top = top ~/ 6; gn = new DM.Random().nextInt(top + 1); // +1 porque o máximo do nextInt conta o número passado - 1 - print("Example30 Diga um número entre 0 e ${top}"); + print("Exemplo30 Diga um número entre 0 e ${top}"); guessNumber(i) { if (n == gn) { - print("Example30 Você acertou! O número é ${gn}"); + print("Exemplo30 Você acertou! O número é ${gn}"); } else { tooHigh = n > gn; - print("Example30 O número ${n} é muito " + print("Exemplo30 O número ${n} é muito " "${tooHigh ? 'alto' : 'baixo'}. Tente de novo"); } return n == gn; @@ -613,11 +615,56 @@ example30() { } } +/// Parâmetro Opcional: +/// Parâmetros declarados entre colchetes são opcionais. +exemplo31() { + encontrarVolume31(int comprimento, int largura, {int? altura}) { + print('comprimento = $comprimento, largura = $largura, altura = $altura'); + } + + encontrarVolume31(10,20,30); //valido + encontrarVolume31(10,20); //valido +} + +/// Parâmetro de Posição Opcional: +/// Parâmetros declarados entre chaves são opcionais. +/// É necessário usar o nome do parâmetro para atribuir um valor, separado por dois pontos `:`. +/// Nos parâmetros entre chaves, a ordem não importa. +/// Esse tipo de parâmetro nos ajuda a evitar confusões ao passar valores +/// para uma função que possui muitos parâmetros. + +exemplo32() { + encontrarVolume31(int comprimento, int largura, {int? altura}) { + print('comprimento = $comprimento, largura = $largura, altura = $altura'); + } + + encontrarVolume32(10,20,height:30);//valido, é possível ver o nome do parâmetro + encontrarVolume32(10,20);//valido +} + +/// Parâmetro Opcional com Valor Padrão: +/// Funciona da mesma forma que um parâmetro de posição opcional, com a +/// diferença de que podemos atribuir um valor padrão a ele. +/// Isso significa que, se nenhum valor for passado, esse valor padrão será utilizado. + +exemplo33() { + encontrarVolume33(int comprimento, int largura, {int? altura}) { + print('comprimento = $comprimento, largura = $largura, altura = $altura'); + } + + encontrarVolume33(10,20,height:30); //valido + encontrarVolume33(10,20); //valido +} + +/// Também existem novos recursos, como os operadores de reconhecimento de nulo. +var isBool = true; +var hasString = isBool ?? "default String"; + // Programas em Dart só têm um ponto de entrada, que é a função main. // Nada será executado antes da funcão main de um programa. // Isso ajuda a carregar o programa mais rapidamente, até mesmo quando o // carregamento é "Lazy". -// O programa deve começar com: +// O programa deve começar com o seguinte formato: main() { print("Aprenda Dart em 15 minutos!"); [example1, example2, example3, example4, example5, example6, example7, @@ -633,9 +680,5 @@ main() { Dart tem um site bastante fácil de entender. Ele tem os docs da API, tutoriais, artigos e muito mais, incluindo uma opção muito útil de testar o Dart online. -* [https://www.dartlang.org](https://www.dartlang.org) -* [https://try.dartlang.org](https://try.dartlang.org) - - - - +* [https://dart.dev/](https://dart.dev/) +* [https://dartpad.dev/](https://dartpad.dev/) \ No newline at end of file From 52656a47d72820257ce4c1e51ca3d3de4786cc87 Mon Sep 17 00:00:00 2001 From: laysleal Date: Tue, 16 Sep 2025 17:01:33 -0300 Subject: [PATCH 3/5] [dart/pt-br] Added translation of updates made on the english article Review 1 --- pt-br/dart.md | 78 ++++++++++++++++++++++++++------------------------- 1 file changed, 40 insertions(+), 38 deletions(-) diff --git a/pt-br/dart.md b/pt-br/dart.md index a3b01da122..896170a59e 100644 --- a/pt-br/dart.md +++ b/pt-br/dart.md @@ -19,10 +19,10 @@ As variáveis em Dart tem tipos, mas não é obrigatório declarar devido à fun import "dart:collection"; import "dart:math" as DM; -// Bem vindo ao Aprenda Dart em 15 minutos. https://dart.dev/ -// Este é um tutorial executável. Você pode rodar esse tutorial com Dart ou no -// site Try Dart!, é só copiar e colar este código lá. http://dartpad.dev/ -// É possível usar Flutter no DartPad, clique em `Create` > `Flutter snippet`. +/// Bem vindo ao Aprenda Dart em 15 minutos. https://dart.dev/ +/// Este é um tutorial executável. Você pode rodar esse tutorial com Dart ou no +/// site Try Dart!, é só copiar e colar este código lá. http://dartpad.dev/ +/// É possível usar Flutter no DartPad, clique em `Create` > `Flutter snippet`. /// Em Dart, tudo é um objeto. /// Toda declaração de um objeto é uma instância de Null. @@ -39,7 +39,7 @@ import "dart:math" as DM; /// Usa a sintaxe Markdown para gerar a documentação ao criar uma API. /// É a opção recomendada para suas APIs, classes e métodos. -/// 4 Tipos de Declaração de Variáveis +/// 5 Tipos de Declaração de Variáveis /// Constantes são variáveis imutáveis, portanto não podem ser alteradas. /// `const` em dart é tradicionalmente declarado utilizando SCREAMING_SNAKE_CASE. /// Exemplo: @@ -67,14 +67,19 @@ valorAlteravel = false; //Resulta em erro. dynamic valorDinamico = "Eu sou uma string"; valorDinamico = false; // O comando é válido -/// Funções podem ser declaradas em um espaço global. +/// `late` permite que você declare variáveis sem inicializá-las imediatamente, +/// mas garantindo que elas serão inicializadas antes de serem usadas. É útil +/// para variáveis globais, parâmetros de classe ou qualquer valor que não seja +/// conhecido no momento da declaração. +late var valorAlteravel; + +/// Funções podem ser declaradas em um espaço global (fora do main). /// Declarações de funções e métodos são iguais. /// Declarações de funções podem ser aninhadas. /// A declaração é feita das seguintes formas nome() {} ou -/// nome() => expressaoDeUmaLinhaSo; -/// Utilizando a seta o return pode ser implícito ou explícito. +/// nome() => expressaoDeUmaLinha; +/// Utilizando a seta (fat arrow) o return pode ser implícito ou explícito. /// O Dart vai executar a função `main()` independente da localização dela. -/// exemplo1() { exemplo1aninhado1() { exemplo1aninhado2() => print("Exemplo1 aninhado 1 aninhado 2"); @@ -85,22 +90,22 @@ exemplo1() { /// Funções anônimas são criadas sem um nome. exemplo2() { - // Return explícito. - aninhado1(void function() fn) { + // Return implícito. + aninhado1(void Function() fn) { fn(); } aninhado1(() => print("Exemplo2 aninhado 1")); } -/// Quando a função possui parâmetros, a declaração pode incluir o número -/// de parâmetros que a função recebe, isso é feito especificando o nome de cada um dos -/// parâmetros que serão recebidos pela função. +/// Quando a função possui parâmetros, a declaração pode incluir os +/// parâmetros que a função recebe, isso é feito especificando o nome de +/// cada um dos parâmetros que serão recebidos pela função. exemplo3() { planoA(fn(String informarAlgo)) { fn("Exemplo3 plano A"); } + // Ou não declare os parâmetros. planoB(fn) { - // Ou não declare o número de parâmetros. fn("Exemplo3 plano B"); } planoA((s) => print(s)); @@ -108,10 +113,10 @@ exemplo3() { } /// Funções têm acesso à variáveis fora de seu escopo -var exemplo4 = "Example4 aninhado 1"; -example4() { +var exemplo4 = "Exemplo4 aninhado 1"; +exemplo4Funcao() { aninhado1(fn(informarAlgo)) { - fn(example4); + fn(exemplo4); } aninhado1((s) => print(s)); } @@ -124,16 +129,16 @@ class Exemplo5Class { print(exemplo5); } } -exemplo5() { +exemplo5Funcao() { // Criar uma instância anônima de Exemplo5Class e chamar o método sayIt. new Exemplo5Class().sayIt(); } -/// A declaração de uma classe é feita da seguinte maneira: class name { [classBody] }. -/// onde classBody pode incluir métodos e variáveis de instância, assim como +/// A declaração de uma classe é feita da seguinte maneira: NomeDaClasse {}. +/// onde as {} podem incluir métodos e variáveis de instância, assim como /// métodos e variáveis de classe. class Exemplo6Class { - var variavelInstancia = "Exemplo6 variável instância"; + var variavelInstancia = "Exemplo6 variável de instância"; sayIt() { print(variavelInstancia); } @@ -152,9 +157,9 @@ class Exemplo7Class { print(classVariable); } } -example7() { +exemplo7() { Exemplo7Class.sayItDoClass(); - new Example7Class().sayItFromInstance(); + new Exemplo7Class().sayItDaInstancia(); } /// O Dart oferece suporte a Genéricos. @@ -189,7 +194,7 @@ class ExemploGenerico{ /// Listas são ótimas, mas há uma limitação para o que elas podem ser quando /// estão fora do corpo de uma função/método. Listas fora do escopo da classe -/// ou fora da classe precisam que ser constantes. Strings e números são +/// ou fora da classe precisam ser constantes. Strings e números são /// constantes por padrão. Mas arrays e mapas não são. Eles podem ser declarados /// como constantes usando o comando "const". const exemplo8List = ["Exemplo8 const array"]; @@ -207,16 +212,14 @@ exemplo8() { /// Isso acontece porque o Dart utiliza [pass-reference-by-value](https://stackoverflow.com/questions/25170094/what-is-the-true-meaning-of-pass-by-reference-in-modern-languages-like-dart). /// Então, quando você atribui uma lista existente a uma nova variável, /// em vez de continuar sendo uma `List`, ela se torna um `Iterable`. - var iterableExplicitList = explicitList; + var iterableExplicitList = listaExplicita; print(iterableExplicitList); // ("SomeArray"); "[]" becomes "()" - var newExplicitLists = explicitList.toList(); // Converts Iterable to List + var newExplicitLists = listaExplicita.toList(); // Converts Iterable to List } -/// Loops em Dart são criados com for () {}, while () {} ou for (.. in ..) {}, ou -/// funções de callbacks com muitas funcionalidades, começando com -/// forEach, map e where. +/// Loops em Dart são criados com for () {}, while () {} ou for (.. in ..) {} var exemplo9 = const ["a", "b"]; -exemplo9() { +exemplo9Metodo() { for (int i = 0; i < exemplo9.length; i++) { print("Exemplo9 for loop '${exemplo9[i]}'"); } @@ -272,22 +275,21 @@ exemplo11() { print("Exemplo11 int ${i}"); print("Exemplo11 double ${d}"); - } /// DateTime traz operações com data/hora. -example12() { - var now = new DateTime.now(); - print("Exemplo12 agora '${now}'"); - now = now.add(new Duration(days: 1)); - print("Exemplo12 amanhã '${now}'"); +exemplo12() { + var agora = new DateTime.now(); + print("Exemplo12 agora '${agora}'"); + agora = agora.add(new Duration(days: 1)); + print("Exemplo12 amanhã '${agora}'"); } /// Expressões regulares são suportadas. exemplo13() { var s1 = "uma string", s2 = "uma", re = new RegExp("^s.+?g\$"); match(s) { - if (re.daMatch(s)) { + if (re.hasMatch(s)) { print("Exemplo13 regexp dá match '${s}'"); } else { print("Exemplo13 regexp não dá match '${s}'"); From 0ede7e9c0164f71870af8a0eb852b1f00472cc44 Mon Sep 17 00:00:00 2001 From: laysleal Date: Wed, 17 Sep 2025 19:23:02 -0300 Subject: [PATCH 4/5] [dart/pt-br] Added translation of updates made on the english article Final review before pull request --- pt-br/dart.md | 65 ++++++++++++++++++++++++++------------------------- 1 file changed, 33 insertions(+), 32 deletions(-) diff --git a/pt-br/dart.md b/pt-br/dart.md index 896170a59e..f0e801c72d 100644 --- a/pt-br/dart.md +++ b/pt-br/dart.md @@ -407,7 +407,7 @@ exemplo20() { /// mas também é mais lento devido às checagens extras e por isso /// é evitado em ambiente de produção. class Exemplo21 { - List _nomes; + List _nomes = []; Exemplo21() { _nomes = ["a", "b"]; } @@ -421,11 +421,11 @@ class Exemplo21 { } } void exemplo21() { - Exemplo21 o = new Example21(); + Exemplo21 o = new Exemplo21(); o.add("c"); - print("Exemplo21 nomes '${o.names}' and tamanho '${o.tamanho}'"); - o.names = ["d", "e"]; - print("Exemplo21 nomes '${o.names}' and tamanho '${o.tamanho}'"); + print("Exemplo21 nomes '${o.nomes}' and tamanho '${o.tamanho}'"); + o.nomes = ["d", "e"]; + print("Exemplo21 nomes '${o.nomes}' and tamanho '${o.tamanho}'"); } // Herança em classes é feito assim: class name extends NomeDeOutraClasse {}. @@ -447,8 +447,9 @@ exemplo22() { /// a herança comum não fica no caminho do reuso de código. /// As misturas aparecem após o comando "with" na declaração da classe. class Exemplo23A {} -class Exemplo23Utils { - addTwo(n1, n2) { +/// Desde o Dart 3, a palavra-chave 'mixin' é obrigatória em vez de 'class'. +mixin Exemplo23Utils { + addDois(n1, n2) { return n1 + n2; } } @@ -470,19 +471,19 @@ exemplo23() { /// construtor da classe pai. class Exemplo24A { var _valor; - Exemplo24A({valor: "umValor"}) { + Exemplo24A({valor = "umValor"}) { _valor = valor; } get valor => _valor; } class Exemplo24B extends Exemplo24A { - Exemplo24B({value: "umOutroValor"}) : super(value: valor); + Exemplo24B({valor = "umOutroValor"}) : super(valor: valor); } exemplo24() { var o1 = new Exemplo24B(), - o2 = new Exemplo24B(value: "aindaMais"); - print("Exemplo24 puxando o super do construtor '${o1.value}'"); - print("Exemplo24 puxando o super do construtor '${o2.value}'"); + o2 = new Exemplo24B(valor: "aindaMais"); + print("Exemplo24 puxando o super do construtor '${o1.valor}'"); + print("Exemplo24 puxando o super do construtor '${o2.valor}'"); } /// Há um atalho para passar parâmetros para o construtor no caso de classes mais simples. @@ -494,8 +495,8 @@ class Exemplo25 { } exemplo25() { var o = new Exemplo25(valor: "a", outroValor: "b"); - print("Exemplo25 atalho para construtor '${o.value}' e " - "'${o.anotherValue}'"); + print("Exemplo25 atalho para construtor '${o.valor}' e " + "'${o.outroValor}'"); } /// Parâmetros com nome estão disponíveis quando declarados entre {}. @@ -512,11 +513,11 @@ exemplo26() { _sobrenome = sobrenome; _email = email; } - setConfig1(sobrenome: "Silva", name: "João"); - print("Exemplo26 nome: '${_name}', sobrenome: '${_surname}', " + setConfig1(sobrenome: "Silva", nome: "João"); + print("Exemplo26 nome: '${_nome}', sobrenome: '${_sobrenome}', " "email: '${_email}'"); setConfig2("José", "Maria"); - print("Exemplo26 nome: '${_name}', sobrenome: '${_surname}', " + print("Exemplo26 nome: '${_nome}', sobrenome: '${_sobrenome}', " "email: '${_email}'"); } @@ -617,10 +618,10 @@ exemplo30() { } } -/// Parâmetro Opcional: -/// Parâmetros declarados entre colchetes são opcionais. +/// Parâmetro Posicional Opcional: +/// o parâmetro declarado entre [] é opcional. exemplo31() { - encontrarVolume31(int comprimento, int largura, {int? altura}) { + encontrarVolume31(int comprimento, int largura, [int? altura]) { print('comprimento = $comprimento, largura = $largura, altura = $altura'); } @@ -628,33 +629,33 @@ exemplo31() { encontrarVolume31(10,20); //valido } -/// Parâmetro de Posição Opcional: -/// Parâmetros declarados entre chaves são opcionais. -/// É necessário usar o nome do parâmetro para atribuir um valor, separado por dois pontos `:`. -/// Nos parâmetros entre chaves, a ordem não importa. -/// Esse tipo de parâmetro nos ajuda a evitar confusões ao passar valores +/// Parâmetro Nomeado Opcional: +/// o parâmetro será declarado entre {}. +/// Os parâmetros entre chaves são opcionais. +/// É necessário usar o nome do parâmetro para atribuir um valor, separado por +/// dois pontos `:`. +/// Nos parâmetros entre chaves, a ordem não importa. +/// Esse tipo de parâmetro ajuda a evitar confusão ao passar valores /// para uma função que possui muitos parâmetros. - exemplo32() { - encontrarVolume31(int comprimento, int largura, {int? altura}) { + encontrarVolume32(int comprimento, int largura, {int? altura}) { print('comprimento = $comprimento, largura = $largura, altura = $altura'); } - encontrarVolume32(10,20,height:30);//valido, é possível ver o nome do parâmetro + encontrarVolume32(10,20,altura:30);//valido, é possível ver o nome do parâmetro encontrarVolume32(10,20);//valido } /// Parâmetro Opcional com Valor Padrão: -/// Funciona da mesma forma que um parâmetro de posição opcional, com a -/// diferença de que podemos atribuir um valor padrão a ele. +/// Funciona da mesma forma que um parâmetro nomeado opcional, com a diferença +/// de que podemos atribuir um valor padrão a ele. /// Isso significa que, se nenhum valor for passado, esse valor padrão será utilizado. - exemplo33() { encontrarVolume33(int comprimento, int largura, {int? altura}) { print('comprimento = $comprimento, largura = $largura, altura = $altura'); } - encontrarVolume33(10,20,height:30); //valido + encontrarVolume33(10,20,altura:30); //valido encontrarVolume33(10,20); //valido } From 4a27ff205316c8e0dd9489446b6e66fbc756691b Mon Sep 17 00:00:00 2001 From: Lays Leal Correia <62303872+laysleal@users.noreply.github.com> Date: Fri, 26 Sep 2025 16:55:27 -0300 Subject: [PATCH 5/5] [dart/pt-br] Added translation of updates made on the english article Fix of MD047 error --- pt-br/dart.md | 3 ++- 1 file changed, 2 insertions(+), 1 deletion(-) diff --git a/pt-br/dart.md b/pt-br/dart.md index f0e801c72d..751ae4b098 100644 --- a/pt-br/dart.md +++ b/pt-br/dart.md @@ -684,4 +684,5 @@ main() { Dart tem um site bastante fácil de entender. Ele tem os docs da API, tutoriais, artigos e muito mais, incluindo uma opção muito útil de testar o Dart online. * [https://dart.dev/](https://dart.dev/) -* [https://dartpad.dev/](https://dartpad.dev/) \ No newline at end of file +* [https://dartpad.dev/](https://dartpad.dev/) +