mirror of
https://github.com/adambard/learnxinyminutes-docs.git
synced 2024-11-30 14:58:04 +03:00
530 lines
16 KiB
Dart
530 lines
16 KiB
Dart
---
|
|
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)}'");
|
|
}
|
|
}
|
|
|
|
// 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 aún 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 <a href="etc">'
|
|
"Don't can't I'm Etc"
|
|
'</a>');
|
|
}
|
|
|
|
// 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 <a href="etc">
|
|
Example19 Don't can't I'm Etc
|
|
Example19 </a>''');
|
|
}
|
|
|
|
// 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 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á
|
|
// 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<String> _names;
|
|
Example21() {
|
|
_names = ["a", "b"];
|
|
}
|
|
List<String> get names => _names;
|
|
set names(List<String> 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}'");
|
|
}
|
|
|
|
// 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) {
|
|
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}'");
|
|
}
|
|
|
|
// 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: "algunValor"}) {
|
|
_value = value;
|
|
}
|
|
get value => _value;
|
|
}
|
|
class Example24B extends Example24A {
|
|
Example24B({value: "algunOtroValor"}) : super(value: value);
|
|
}
|
|
example24() {
|
|
var o1 = new Example24B(),
|
|
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}'");
|
|
}
|
|
|
|
// 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 atajo para el constructor '${o.value}' y "
|
|
"'${o.anotherValue}'");
|
|
}
|
|
|
|
// 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}) {
|
|
_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}'");
|
|
}
|
|
|
|
// 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;
|
|
// 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 es '${color}'");
|
|
print("example27 color es '${o.color1}' y '${o.color2}'");
|
|
}
|
|
|
|
// 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() {
|
|
names = ["a", "b"];
|
|
}
|
|
get iterator => names.iterator;
|
|
}
|
|
example28() {
|
|
var o = new Example28();
|
|
o.forEach((name) => print("example28 '${name}'"));
|
|
}
|
|
|
|
// 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 sentencia switch");
|
|
break;
|
|
}
|
|
if (v < 30) {
|
|
} else if (v > 30) {
|
|
} else {
|
|
print("example29 sentencia if-else");
|
|
}
|
|
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;
|
|
}
|
|
// Nunca llega aquí.
|
|
}
|
|
}
|
|
|
|
// 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 porque nextInt top es exclusivo
|
|
print("example30 Adivina un número entre 0 y ${top}");
|
|
guessNumber(i) {
|
|
if (n == gn) {
|
|
print("example30 ¡Adivinaste correctamente! El número es ${gn}");
|
|
} else {
|
|
tooHigh = n > gn;
|
|
print("example30 Número ${n} es demasiado "
|
|
"${tooHigh ? 'high' : 'low'}. Intenta nuevamente");
|
|
}
|
|
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 sección en línea Try Dart.
|
|
[https://www.dartlang.org](https://www.dartlang.org)
|
|
[https://try.dartlang.org](https://try.dartlang.org)
|