From b680c4153a7fa479693faa06a2a27b7e085d3a57 Mon Sep 17 00:00:00 2001 From: Jorge Atempa Date: Wed, 1 May 2019 00:06:32 -0700 Subject: [WIP] Translated document to Spanish Language --- es-es/dart-es.html.markdown | 532 ++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 532 insertions(+) create mode 100644 es-es/dart-es.html.markdown diff --git a/es-es/dart-es.html.markdown b/es-es/dart-es.html.markdown new file mode 100644 index 00000000..72c2857e --- /dev/null +++ b/es-es/dart-es.html.markdown @@ -0,0 +1,532 @@ +--- +language: dart +contributors: + - ["Joao Pedrosa", "https://github.com/jpedrosa/"] +translators: + - ["Jorge Antonio Atempa", "http://www.twitter.com/atempa09"] +filename: dart-es.md +lang: es-es +--- + +Dart es un recién llegado al ámbito de los lenguajes de programación. +Toma prestado mucho de otros lenguajes principales, con el objetivo de no desviarse demasiado de +su hermano JavaScript. Tal como JavaScript, Dart tiene como objetivo una gran integración en el navegador. + +La característica más controvertida de Dart debe ser su escritura opcional. + +```dart +import "dart:collection"; +import "dart:math" as DM; + +// Bienvenido a Aprende Dart en 15 minutos. http://www.dartlang.org/ +// Este es un tutorial ejecutable. Puedes ejecutarlo con Dart o en +// el sitio de ¡Try Dart! solo copiando y pegando en http://try.dartlang.org/ + +// La declaración de función y de método tienen el mismo aspecto. +// Las funciones pueden estar anidadas. +// La declaración toma la forma name() {} o name() => expresionEnUnaLinea; +// La declaración de la función de flecha gorda tiene un retorno implícito para el resultado de +// la expresión. +example1() { + nested1() { + nested2() => print("Example1 anidado 1 anidado 2"); + nested2(); + } + nested1(); +} + +// Las funciones anónimas no incluyen un nombre. +example2() { + nested1(fn) { + fn(); + } + nested1(() => print("Example2 anidado 1")); +} + +// Cuando se declara un parámetro de función, la declaración puede incluir el +// número de parámetros que toma la función especificando los nombres de los +// parámetros que lleva. +example3() { + planA(fn(informSomething)) { + fn("Example3 plan A"); + } + planB(fn) { // O no declarar el número de parámetros. + fn("Example3 plan B"); + } + planA((s) => print(s)); + planB((s) => print(s)); +} + +// Las funciones tienen acceso de cierre a variables externas. +var example4Something = "Example4 anidado 1"; +example4() { + nested1(fn(informSomething)) { + fn(example4Something); + } + nested1((s) => print(s)); +} + +// La declaración de la clase con un método sayIt, el cual también tiene acceso de cierre +// a la variable exterior como si fuera una función como se ha visto antes. +var example5method = "Example5 sayIt"; +class Example5Class { + sayIt() { + print(example5method); + } +} +example5() { + // Crear una instancia anónima de Example5Class y la llamada del método sayIt + new Example5Class().sayIt(); +} + +// La declaración de clase toma la forma NombreDeClase { [cuerpoDeClase] }. +// Donde cuerpoDeClase puede incluir métodos de instancia y variables, pero también +// métodos y variables de clase. +class Example6Class { + var instanceVariable = "Example6 variable de instancia"; + sayIt() { + print(instanceVariable); + } +} +example6() { + new Example6Class().sayIt(); +} + +// Los métodos y variables de clase son declarados con términos "static". +class Example7Class { + static var classVariable = "Example7 variable de clase"; + static sayItFromClass() { + print(classVariable); + } + sayItFromInstance() { + print(classVariable); + } +} +example7() { + Example7Class.sayItFromClass(); + new Example7Class().sayItFromInstance(); +} + +// Las literales son geniales, pero hay una restricción para lo que pueden ser las literales +// fuera de los cuerpos de función/método. Literales en el ámbito exterior de clase +// o fuera de clase tienen que ser constantes. Las cadenas de caracteres y los números +// son constantes por defecto. Pero los arreglos y mapas no lo son. +// Ellos pueden hacerse constante anteponiendo en la declaración el término "const". +var example8Array = const ["Example8 arreglo constante"], + example8Map = const {"algunaKey": "Example8 mapa constante"}; +example8() { + print(example8Array[0]); + print(example8Map["algunaKey"]); +} + +// Los bucles en Dart toman la forma estándar para for () {} o ciclos while () {} , +// ligeramente más moderno for (.. in ..) {}, o llamadas funcionales con muchas +// características soportadas, comenzando con forEach. +var example9Array = const ["a", "b"]; +example9() { + for (var i = 0; i < example9Array.length; i++) { + print("Example9 ciclo for '${example9Array[i]}'"); + } + var i = 0; + while (i < example9Array.length) { + print("Example9 ciclo while '${example9Array[i]}'"); + i++; + } + for (var e in example9Array) { + print("Example9 ciclo for-in '${e}'"); + } + example9Array.forEach((e) => print("Example9 ciclo forEach '${e}'")); +} + +// Para recorrer los caracteres de una cadena o para extraer una subcadena. +var example10String = "ab"; +example10() { + for (var i = 0; i < example10String.length; i++) { + print("Example10 Recorrido de caracteres en la cadena '${example10String[i]}'"); + } + for (var i = 0; i < example10String.length; i++) { + print("Example10 ciclo de subcadena '${example10String.substring(i, i + 1)}'"); + } +} + +// Para formato de números Int y double son soportados. +example11() { + var i = 1 + 320, d = 3.2 + 0.01; + print("Example11 int ${i}"); + print("Example11 double ${d}"); +} + +// DateTime ofrece aritmética de fecha/hora. +example12() { + var now = new DateTime.now(); + print("Example12 ahora '${now}'"); + now = now.add(new Duration(days: 1)); + print("Example12 manana '${now}'"); +} + +// Expresiones regulares son soportadas. +example13() { + var s1 = "alguna cadena", s2 = "alguna", re = new RegExp("^s.+?g\$"); + match(s) { + if (re.hasMatch(s)) { + print("Example13 regexp embona '${s}'"); + } else { + print("Example13 regexp no embona '${s}'"); + } + } + match(s1); + match(s2); +} + +// Las expresiones booleanas admiten conversiones implícitas y tipos dinámicos. +example14() { + var a = true; + if (a) { + print("true, a is $a"); + } + a = null; + if (a) { + print("true, a es $a"); + } else { + print("false, a es $a"); // corre aquí + } + + // el tipado dinámico null puede convertirse a bool + var b; // b es de tipo dinámico + b = "abc"; + try { + if (b) { + print("true, b es $b"); + } else { + print("false, b es $b"); + } + } catch (e) { + print("error, b es $b"); // esto podría ser ejecutado pero consiguió error + } + b = null; + if (b) { + print("true, b es $b"); + } else { + print("false, b es $b"); // corre aquí + } + + // tipado estático null no puede ser convertido a bool + var c = "abc"; + c = null; + // compilación fallida + // if (c) { + // print("true, c is $c"); + // } else { + // print("false, c is $c"); + // } +} + +// try/catch/finally y throw son utilizados para el manejo de excepciones. +// throw toma cualquier objeto como parámetro; +example15() { + try { + try { + throw "Algun error inesperado."; + } catch (e) { + print("Example15 una excepcion: '${e}'"); + throw e; // Re-throw + } + } catch (e) { + print("Example15 atrapa la excepcion que ha sido relanzada: '${e}'"); + } finally { + print("Example15 Aun ejecuta finally"); + } +} + +// Para ser eficiente cuando creas una cadena larga dinámicamente, usa +// StringBuffer. O podrías unir un arreglo de cadena de caracteres. +example16() { + var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e; + for (e in a) { sb.write(e); } + print("Example16 cadena de caracteres dinamica creada con " + "StringBuffer '${sb.toString()}'"); + print("Example16 union de arreglo de cadena de caracteres '${a.join()}'"); +} + +// Las cadenas de caracteres pueden ser concatenadas contando solo +// con literales una después de la otra sin algún otro operador necesario. +example17() { + print("Example17 " + "concatenar " + "cadenas " + "asi"); +} + +// Las cadenas de caracteres utilizan comilla simple o comillas dobles como delimitadores +// sin ninguna diferencia entre ambas. Esto proporciona flexibilidad que puede ser efectiva +// para evitar la necesidad de 'escapar' el contenido. Por ejemplo, +// las dobles comillas de los atributos HTML. +example18() { + print('Example18 ' + "Don't can't I'm Etc" + ''); +} + +// Las cadenas de caracteres con triple comilla simple o triple comillas dobles +// dividen múltiples lineas e incluyen como delimitador el salto de línea. +example19() { + print('''Example19 +Example19 Don't can't I'm Etc +Example19 '''); +} + +// Las cadenas de caracteres cuentan con una extraordinaria característica +// para la interpolación de caracteres utilizando el operador $ +// Con $ { [expresion] }, devolvemos la expresion interpolada. +// $ seguido por el nombre de una variable interpola el contenido de dicha variable. +// $ puede ser escapado con \$ para solo agregarlo a la cadena. +example20() { + var s1 = "'\${s}'", s2 = "'\$s'"; + print("Example20 \$ interpolation ${s1} or $s2 works."); +} + +// Hasta ahora no hemos declarado ningún tipo y los programas +// han funcionado bien. De hecho, los tipos no se toman en cuenta durante +// el tiempo de ejecución. +// Los tipos incluso pueden estar equivocados y al programa todavía se le dará +// el beneficio de la duda y se ejecutará como si los tipos no importaran. +// Hay un parámetro de tiempo de ejecución que comprueba los errores de tipo que es +// el modo de verificación, el cuál es útil durante el tiempo de desarrollo, +// pero que también es más lento debido a la comprobación adicional y, por lo tanto +// se evita durante el tiempo de ejecución de la implementación. +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(); + o.add("c"); + print("Example21 nombres '${o.names}' y longitud '${o.length}'"); + o.names = ["d", "e"]; + print("Example21 nombres '${o.names}' y longitud '${o.length}'"); +} + +// La herencia de clases toma la forma NombreDeClase extends OtraClase {}. +class Example22A { + var _name = "¡Algun Nombre!"; + get name => _name; +} +class Example22B extends Example22A {} +example22() { + var o = new Example22B(); + print("Example22 herencia de clase '${o.name}'"); +} + +// Class mixin is also available, and takes the form of +// class name extends SomeClass with AnotherClassName {}. +// It's necessary to extend some class to be able to mixin another one. +// The template class of mixin cannot at the moment have a constructor. +// Mixin is mostly used to share methods with distant classes, so the +// single inheritance doesn't get in the way of reusable code. +// Mixins follow the "with" statement during the class declaration. +class Example23A {} +class Example23Utils { + addTwo(n1, n2) { + return n1 + n2; + } +} +class Example23B extends Example23A with Example23Utils { + addThree(n1, n2, n3) { + return addTwo(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}'"); +} + +// The Class constructor method uses the same name of the class and +// takes the form of SomeClass() : super() {}, where the ": super()" +// part is optional and it's used to delegate constant parameters to the +// super-parent's constructor. +class Example24A { + var _value; + Example24A({value: "someValue"}) { + _value = value; + } + get value => _value; +} +class Example24B extends Example24A { + Example24B({value: "someOtherValue"}) : super(value: value); +} +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}'"); +} + +// There's a shortcut to set constructor parameters in case of simpler classes. +// Just use the this.parameterName prefix and it will set the parameter on +// an instance variable of same name. +class Example25 { + var value, anotherValue; + Example25({this.value, this.anotherValue}); +} +example25() { + var o = new Example25(value: "a", anotherValue: "b"); + print("Example25 shortcut for constructor '${o.value}' and " + "'${o.anotherValue}'"); +} + +// Named parameters are available when declared between {}. +// Parameter order can be optional when declared between {}. +// Parameters can be made optional when declared between []. +example26() { + var _name, _surname, _email; + setConfig1({name, surname}) { + _name = name; + _surname = surname; + } + setConfig2(name, [surname, email]) { + _name = name; + _surname = surname; + _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}'"); +} + +// Variables declared with final can only be set once. +// In case of classes, final instance variables can be set via constant +// constructor parameter. +class Example27 { + final color1, color2; + // A little flexibility to set final instance variables with syntax + // that follows the : + 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}'"); +} + +// To import a library, use import "libraryPath" or if it's a core library, +// import "dart:libraryName". There's also the "pub" package management with +// its own convention of import "package:packageName". +// See import "dart:collection"; at the top. Imports must come before +// other code declarations. IterableBase comes from 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}'")); +} + +// For control flow we have: +// * standard switch with must break statements +// * if-else if-else and ternary ..?..:.. operator +// * closures and anonymous functions +// * break, continue and return statements +example29() { + var v = true ? 30 : 60; + switch (v) { + case 30: + print("Example29 switch statement"); + break; + } + if (v < 30) { + } else if (v > 30) { + } else { + print("Example29 if-else statement"); + } + callItForMe(fn()) { + return fn(); + } + rand() { + v = new DM.Random().nextInt(50); + return v; + } + while (true) { + print("Example29 callItForMe(rand) '${callItForMe(rand)}'"); + if (v != 30) { + break; + } else { + continue; + } + // Never gets here. + } +} + +// Parse int, convert double to int, or just keep int when dividing numbers +// by using the ~/ operation. Let's play a guess game too. +example30() { + 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 because nextInt top is exclusive + print("Example30 Guess a number between 0 and ${top}"); + guessNumber(i) { + if (n == gn) { + print("Example30 Guessed right! The number is ${gn}"); + } else { + tooHigh = n > gn; + print("Example30 Number ${n} is too " + "${tooHigh ? 'high' : 'low'}. Try again"); + } + return n == gn; + } + n = (top - bottom) ~/ 2; + while (!guessNumber(n)) { + if (tooHigh) { + top = n - 1; + } else { + bottom = n + 1; + } + n = bottom + ((top - bottom) ~/ 2); + } +} + +// Los programas tienen un solo punto de entrada en la función principal. +// No se espera que se ejecute nada en el ámbito externo antes de que un programa +// comience a funcionar con su función principal. +// Esto ayuda con una carga más rápida e incluso con una carga lenta +// de lo que necesita el programa para iniciar. +main() { + print("Learn Dart in 15 minutes!"); + [example1, example2, example3, example4, example5, example6, example7, + example8, example9, example10, example11, example12, example13, example14, + example15, example16, example17, example18, example19, example20, + example21, example22, example23, example24, example25, example26, + example27, example28, example29, example30 + ].forEach((ef) => ef()); +} + +``` + +## Lecturas adicionales + +Dart tiene un sitio web muy completo. Cubre referencias de API, tutoriales, artículos y más, incluyendo una +útil Try Dart online. +[https://www.dartlang.org](https://www.dartlang.org) +[https://try.dartlang.org](https://try.dartlang.org) + + + -- cgit v1.2.3 From 4c4da82a91256e1ff120ad1a03f6faef69f0948d Mon Sep 17 00:00:00 2001 From: Jorge Atempa Date: Sat, 18 May 2019 01:19:46 -0700 Subject: [dart/es] Translate to Spanish language --- es-es/dart-es.html.markdown | 173 ++++++++++++++++++++++---------------------- 1 file changed, 85 insertions(+), 88 deletions(-) diff --git a/es-es/dart-es.html.markdown b/es-es/dart-es.html.markdown index 72c2857e..d0f57b95 100644 --- a/es-es/dart-es.html.markdown +++ b/es-es/dart-es.html.markdown @@ -25,11 +25,11 @@ import "dart:math" as DM; // La declaración de función y de método tienen el mismo aspecto. // Las funciones pueden estar anidadas. // La declaración toma la forma name() {} o name() => expresionEnUnaLinea; -// La declaración de la función de flecha gorda tiene un retorno implícito para el resultado de -// la expresión. +// La declaración de la función de flecha gorda, tiene un retorno implícito +// para el resultado de la expresión. example1() { nested1() { - nested2() => print("Example1 anidado 1 anidado 2"); + nested2() => print("example1 anidado 1 anidado 2"); nested2(); } nested1(); @@ -40,7 +40,7 @@ example2() { nested1(fn) { fn(); } - nested1(() => print("Example2 anidado 1")); + nested1(() => print("example2 anidado 1")); } // Cuando se declara un parámetro de función, la declaración puede incluir el @@ -48,10 +48,10 @@ example2() { // parámetros que lleva. example3() { planA(fn(informSomething)) { - fn("Example3 plan A"); + fn("example3 plan A"); } planB(fn) { // O no declarar el número de parámetros. - fn("Example3 plan B"); + fn("example3 plan B"); } planA((s) => print(s)); planB((s) => print(s)); @@ -68,7 +68,7 @@ example4() { // La declaración de la clase con un método sayIt, el cual también tiene acceso de cierre // a la variable exterior como si fuera una función como se ha visto antes. -var example5method = "Example5 sayIt"; +var example5method = "example5 sayIt"; class Example5Class { sayIt() { print(example5method); @@ -125,43 +125,43 @@ example8() { var example9Array = const ["a", "b"]; example9() { for (var i = 0; i < example9Array.length; i++) { - print("Example9 ciclo for '${example9Array[i]}'"); + print("example9 ciclo for '${example9Array[i]}'"); } var i = 0; while (i < example9Array.length) { - print("Example9 ciclo while '${example9Array[i]}'"); + print("example9 ciclo while '${example9Array[i]}'"); i++; } for (var e in example9Array) { - print("Example9 ciclo for-in '${e}'"); + print("example9 ciclo for-in '${e}'"); } - example9Array.forEach((e) => print("Example9 ciclo forEach '${e}'")); + example9Array.forEach((e) => print("example9 ciclo forEach '${e}'")); } // Para recorrer los caracteres de una cadena o para extraer una subcadena. var example10String = "ab"; example10() { for (var i = 0; i < example10String.length; i++) { - print("Example10 Recorrido de caracteres en la cadena '${example10String[i]}'"); + print("example10 Recorrido de caracteres en la cadena '${example10String[i]}'"); } for (var i = 0; i < example10String.length; i++) { - print("Example10 ciclo de subcadena '${example10String.substring(i, i + 1)}'"); + print("example10 ciclo de subcadena '${example10String.substring(i, i + 1)}'"); } } -// Para formato de números Int y double son soportados. +// Formato de números Int y double son soportados. example11() { var i = 1 + 320, d = 3.2 + 0.01; - print("Example11 int ${i}"); - print("Example11 double ${d}"); + print("example11 int ${i}"); + print("example11 double ${d}"); } // DateTime ofrece aritmética de fecha/hora. example12() { var now = new DateTime.now(); - print("Example12 ahora '${now}'"); + print("example12 ahora '${now}'"); now = now.add(new Duration(days: 1)); - print("Example12 manana '${now}'"); + print("example12 manana '${now}'"); } // Expresiones regulares son soportadas. @@ -169,9 +169,9 @@ example13() { var s1 = "alguna cadena", s2 = "alguna", re = new RegExp("^s.+?g\$"); match(s) { if (re.hasMatch(s)) { - print("Example13 regexp embona '${s}'"); + print("example13 regexp embona '${s}'"); } else { - print("Example13 regexp no embona '${s}'"); + print("example13 regexp no embona '${s}'"); } } match(s1); @@ -228,13 +228,13 @@ example15() { try { throw "Algun error inesperado."; } catch (e) { - print("Example15 una excepcion: '${e}'"); + print("example15 una excepcion: '${e}'"); throw e; // Re-throw } } catch (e) { - print("Example15 atrapa la excepcion que ha sido relanzada: '${e}'"); + print("example15 atrapa la excepcion que ha sido relanzada: '${e}'"); } finally { - print("Example15 Aun ejecuta finally"); + print("example15 aún ejecuta finally"); } } @@ -243,15 +243,15 @@ example15() { example16() { var sb = new StringBuffer(), a = ["a", "b", "c", "d"], e; for (e in a) { sb.write(e); } - print("Example16 cadena de caracteres dinamica creada con " + print("example16 cadena de caracteres dinamica creada con " "StringBuffer '${sb.toString()}'"); - print("Example16 union de arreglo de cadena de caracteres '${a.join()}'"); + print("example16 union de arreglo de cadena de caracteres '${a.join()}'"); } // Las cadenas de caracteres pueden ser concatenadas contando solo // con literales una después de la otra sin algún otro operador necesario. example17() { - print("Example17 " + print("example17 " "concatenar " "cadenas " "asi"); @@ -285,7 +285,7 @@ example20() { print("Example20 \$ interpolation ${s1} or $s2 works."); } -// Hasta ahora no hemos declarado ningún tipo y los programas +// Hasta ahora no hemos declarado ningún tipo de dato y los programas // han funcionado bien. De hecho, los tipos no se toman en cuenta durante // el tiempo de ejecución. // Los tipos incluso pueden estar equivocados y al programa todavía se le dará @@ -311,9 +311,9 @@ class Example21 { void example21() { Example21 o = new Example21(); o.add("c"); - print("Example21 nombres '${o.names}' y longitud '${o.length}'"); + print("example21 nombres '${o.names}' y longitud '${o.length}'"); o.names = ["d", "e"]; - print("Example21 nombres '${o.names}' y longitud '${o.length}'"); + print("example21 nombres '${o.names}' y longitud '${o.length}'"); } // La herencia de clases toma la forma NombreDeClase extends OtraClase {}. @@ -324,16 +324,16 @@ class Example22A { class Example22B extends Example22A {} example22() { var o = new Example22B(); - print("Example22 herencia de clase '${o.name}'"); + print("example22 herencia de clase '${o.name}'"); } -// Class mixin is also available, and takes the form of -// class name extends SomeClass with AnotherClassName {}. -// It's necessary to extend some class to be able to mixin another one. -// The template class of mixin cannot at the moment have a constructor. -// Mixin is mostly used to share methods with distant classes, so the -// single inheritance doesn't get in the way of reusable code. -// Mixins follow the "with" statement during the class declaration. +// La mezcla de clases también esta disponible y toman la forma de +// NombreDeClase extends AlgunaClase with OtraClase {}. +// Es necesario extender de alguna clase para poder mezclar con otra. +// La clase de plantilla de mixin no puede en este momento tener un constructor. +// Mixin se utiliza principalmente para compartir métodos con clases distantes, +// por lo que la herencia única no interfiere con el código reutilizable. +// Mixins se colocan despues de la palabra "with" durante la declaración de la clase. class Example23A {} class Example23Utils { addTwo(n1, n2) { @@ -352,43 +352,43 @@ example23() { print("Example23 addTwo(1, 2) results in '${r2}'"); } -// The Class constructor method uses the same name of the class and -// takes the form of SomeClass() : super() {}, where the ": super()" -// part is optional and it's used to delegate constant parameters to the -// super-parent's constructor. +// El método constructor de la clase utiliza el mismo nombre de la clase +// y toma la forma de AlgunaClase() : super() {}, donde la parte ": super()" +// es opcional y es utilizado para delegar parametros constantes +// al método constructor de la clase padre o super clase. class Example24A { var _value; - Example24A({value: "someValue"}) { + Example24A({value: "algunValor"}) { _value = value; } get value => _value; } class Example24B extends Example24A { - Example24B({value: "someOtherValue"}) : super(value: value); + Example24B({value: "algunOtroValor"}) : super(value: value); } 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}'"); + o2 = new Example24B(value: "aunMas"); + print("example24 llama al método super desde el constructor '${o1.value}'"); + print("example24 llama al método super desde el constructor '${o2.value}'"); } -// There's a shortcut to set constructor parameters in case of simpler classes. -// Just use the this.parameterName prefix and it will set the parameter on -// an instance variable of same name. +// Hay un atajo para configurar los parámetros del constructor en el caso de clases más simples. +// Simplemente use el prefijo this.nombreParametro y establecerá el parámetro +// en una variable de instancia del mismo nombre. class Example25 { var value, anotherValue; Example25({this.value, this.anotherValue}); } example25() { var o = new Example25(value: "a", anotherValue: "b"); - print("Example25 shortcut for constructor '${o.value}' and " + print("example25 atajo para el constructor '${o.value}' y " "'${o.anotherValue}'"); } -// Named parameters are available when declared between {}. -// Parameter order can be optional when declared between {}. -// Parameters can be made optional when declared between []. +// Los parámetros con nombre están disponibles cuando se declaran entre {}. +// El orden de los parámetros puede ser opcional cuando se declara entre {}. +// Los parámetros pueden hacerse opcionales cuando se declaran entre []. example26() { var _name, _surname, _email; setConfig1({name, surname}) { @@ -401,33 +401,33 @@ example26() { _email = email; } setConfig1(surname: "Doe", name: "John"); - print("Example26 name '${_name}', surname '${_surname}', " + print("example26 name '${_name}', surname '${_surname}', " "email '${_email}'"); setConfig2("Mary", "Jane"); - print("Example26 name '${_name}', surname '${_surname}', " + print("example26 name '${_name}', surname '${_surname}', " "email '${_email}'"); } -// Variables declared with final can only be set once. -// In case of classes, final instance variables can be set via constant -// constructor parameter. +// Las variables declaradas con final solo se pueden establecer una vez. +// En el caso de las clases, las variables de instancia final se pueden establecer +// a través de la constante del parámetro constructor. class Example27 { final color1, color2; - // A little flexibility to set final instance variables with syntax - // that follows the : + // Un poco de flexibilidad para establecer variables de instancia finales con la sintaxis + // que sigue a : 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}'"); + print("example27 color es '${color}'"); + print("example27 color es '${o.color1}' y '${o.color2}'"); } -// To import a library, use import "libraryPath" or if it's a core library, -// import "dart:libraryName". There's also the "pub" package management with -// its own convention of import "package:packageName". -// See import "dart:collection"; at the top. Imports must come before -// other code declarations. IterableBase comes from dart:collection. +// Para importar una librería utiliza la palabra reservada import "rutaLibrería" o si es una biblioteca central, +// import "dart:NombreLibrería". También está el "pub" administrador de paquetes con +// su propia convensión import "package:NombrePaquete". +// Ve import "dart:collection"; al inicio. Las importaciones deben venir antes +// de la delcaración de algún otro código. IterableBase proviene de dart:collection. class Example28 extends IterableBase { var names; Example28() { @@ -437,25 +437,25 @@ class Example28 extends IterableBase { } example28() { var o = new Example28(); - o.forEach((name) => print("Example28 '${name}'")); + o.forEach((name) => print("example28 '${name}'")); } -// For control flow we have: -// * standard switch with must break statements -// * if-else if-else and ternary ..?..:.. operator -// * closures and anonymous functions -// * break, continue and return statements +// Para el control de flujo tenemos: +// * estandard switch +// * if-else if-else y el operador ternario ..?..:.. +// * closures y funciones anonimas +// * sentencias break, continue y return example29() { var v = true ? 30 : 60; switch (v) { case 30: - print("Example29 switch statement"); + print("example29 sentencia switch"); break; } if (v < 30) { } else if (v > 30) { } else { - print("Example29 if-else statement"); + print("example29 sentencia if-else"); } callItForMe(fn()) { return fn(); @@ -465,31 +465,31 @@ example29() { return v; } while (true) { - print("Example29 callItForMe(rand) '${callItForMe(rand)}'"); + print("example29 callItForMe(rand) '${callItForMe(rand)}'"); if (v != 30) { break; } else { continue; } - // Never gets here. + // Nunca llega aquí. } } -// Parse int, convert double to int, or just keep int when dividing numbers -// by using the ~/ operation. Let's play a guess game too. +// La sentencia int.parse, convierte de tipo double a int, o simplemente mantener int cuando se dividen los números +// utilizando ~/ como operación. Vamos a jugar un juego de adivinanzas también. example30() { 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 because nextInt top is exclusive - print("Example30 Guess a number between 0 and ${top}"); + gn = new DM.Random().nextInt(top + 1); // +1 porque nextInt top es exclusivo + print("example30 Adivina un número entre 0 y ${top}"); guessNumber(i) { if (n == gn) { - print("Example30 Guessed right! The number is ${gn}"); + print("example30 ¡Adivinaste correctamente! El número es ${gn}"); } else { tooHigh = n > gn; - print("Example30 Number ${n} is too " - "${tooHigh ? 'high' : 'low'}. Try again"); + print("example30 Número ${n} es demasiado " + "${tooHigh ? 'high' : 'low'}. Intenta nuevamente"); } return n == gn; } @@ -524,9 +524,6 @@ main() { ## Lecturas adicionales Dart tiene un sitio web muy completo. Cubre referencias de API, tutoriales, artículos y más, incluyendo una -útil Try Dart online. +útil sección en línea Try Dart. [https://www.dartlang.org](https://www.dartlang.org) [https://try.dartlang.org](https://try.dartlang.org) - - - -- cgit v1.2.3