[dart/es] Translate to Spanish language

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 declaración de la función de flecha gorda, tiene un retorno implícito 
-// la expresión.
+// 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 int ${i}");
-  print("Example11 double ${d}");
+  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
+// La mezcla de clases también esta disponible y toman la forma de
-// class name extends SomeClass with AnotherClassName {}.
+// NombreDeClase extends AlgunaClase with OtraClase {}.
-// It's necessary to extend some class to be able to mixin another one.
+// Es necesario extender de alguna clase para poder mezclar con otra.
-// The template class of mixin cannot at the moment have a constructor.
+// La clase de plantilla de mixin no puede en este momento tener un constructor.
-// Mixin is mostly used to share methods with distant classes, so the
+// Mixin se utiliza principalmente para compartir métodos con clases distantes,
-// single inheritance doesn't get in the way of reusable code.
+// por lo que la herencia única no interfiere con el código reutilizable.
-// Mixins follow the "with" statement during the class declaration.
+// 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
+// El método constructor de la clase utiliza el mismo nombre de la clase
-// takes the form of SomeClass() : super() {}, where the ": super()"
+// y toma la forma de AlgunaClase() : super() {}, donde la parte ": super()"
-// part is optional and it's used to delegate constant parameters to the
+// es opcional y es utilizado para delegar parametros constantes
-// super-parent's constructor.
+// 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");
+    o2 = new Example24B(value: "aunMas");
-  print("Example24 calling super during constructor '${o1.value}'");
+  print("example24 llama al método super desde el constructor '${o1.value}'");
-  print("Example24 calling super during constructor '${o2.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.
+// Hay un atajo para configurar los parámetros del constructor en el caso de clases más simples.
-// Just use the this.parameterName prefix and it will set the parameter on
+// Simplemente use el prefijo this.nombreParametro y establecerá el parámetro 
-// an instance variable of same name.
+// 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 {}.
+// Los parámetros con nombre están disponibles cuando se declaran entre {}.
-// Parameter order can be optional when declared between {}.
+// El orden de los parámetros puede ser opcional cuando se declara entre {}.
-// Parameters can be made optional when declared between [].
+// 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.
+// Las variables declaradas con final solo se pueden establecer una vez.
-// In case of classes, final instance variables can be set via constant
+// En el caso de las clases, las variables de instancia final se pueden establecer 
-// constructor parameter.
+// 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
+  // Un poco de flexibilidad para establecer variables de instancia finales con la sintaxis
-  // that follows the :
+  // 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 es '${color}'");
-  print("Example27 color is '${o.color1}' and '${o.color2}'");
+  print("example27 color es '${o.color1}' y '${o.color2}'");
 }
 
-// To import a library, use import "libraryPath" or if it's a core library,
+// Para importar una librería utiliza la palabra reservada import "rutaLibrería" o si es una biblioteca central,
-// import "dart:libraryName". There's also the "pub" package management with
+// import "dart:NombreLibrería". También está el "pub" administrador de paquetes con
-// its own convention of import "package:packageName".
+// su propia convensión import "package:NombrePaquete".
-// See import "dart:collection"; at the top. Imports must come before
+// Ve import "dart:collection"; al inicio. Las importaciones deben venir antes
-// other code declarations. IterableBase comes from dart:collection.
+// 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:
+// Para el control de flujo tenemos:
-// * standard switch with must break statements
+// * estandard switch
-// * if-else if-else and ternary ..?..:.. operator
+// * if-else if-else y el operador ternario ..?..:..
-// * closures and anonymous functions
+// * closures y funciones anonimas
-// * break, continue and return statements
+// * 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
+// La sentencia int.parse, convierte de tipo double a int, o simplemente mantener int cuando se dividen los números
-// by using the ~/ operation. Let's play a guess game too.
+// 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
+  gn = new DM.Random().nextInt(top + 1); // +1 porque nextInt top es exclusivo
-  print("Example30 Guess a number between 0 and ${top}");
+  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 "
+      print("example30 Número ${n} es demasiado "
-        "${tooHigh ? 'high' : 'low'}. Try again");
+        "${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)
-
-
-