Codelab de hoja de trucos de Dart
- Interpolación de cadenas
- Nullable variables
- Operadores con reconocimiento de nulos
- Acceso condicional a la propiedad
- Literales de colección
- Sintaxis de flechas
- Cascadas
- Getters y setters
- Parámetros posicionales opcionales
- Parámetros con nombre
- Excepciones
- Usando this en un constructor
- Listas de inicializadores
- Constructores con nombre
- Constructores factory
- Redirigir constructores
- Constructores constantes
- ¿Qué sigue?
El lenguaje Dart está diseñado para que sea fácil de aprender para programadores que usan otros lenguajes, pero tiene algunas características únicas. Este laboratorio de código te guiará a través de las características más importantes de estos lenguajes.
Los editores integrados en este codelab tienen fragmentos de código parcialmente completados. Puedes usar estos editores para probar tus conocimientos completando el código y haciendo clic en el botón Run. Si necesitas ayuda, haz clic en el botón Hint. Para ejecutar el formateador de código (dart format
), haz clic en Format. El botón Reset borra tu trabajo y restaura el editor a su estado original.
Interpolación de cadenas
Para poner el valor de una expresión dentro de una cadena, usa ${expression}
. Si la expresión es un identificador, puedes omitir el {}
.
Aquí hay algunos ejemplos de uso de la interpolación de cadenas:
String | Resultado | |
---|---|---|
'${3 + 2}' |
'5' |
|
'${"word".toUpperCase()}' |
'WORD' |
|
'$myObject' |
El valor de myObject.toString()
|
Ejemplo de código
La siguiente función toma dos números enteros como parámetros. Haz que devuelva una cadena de texto que contenga ambos números enteros separados por un espacio. Por ejemplo, stringify(2, 3)
debería devolver '2 3'
.
{$ begin main.dart $}
String stringify(int x, int y) {
TODO('Return a formatted string here');
}
{$ end main.dart $}
{$ begin solution.dart $}
String stringify(int x, int y) {
return '$x $y';
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
try {
final str = stringify(2, 3);
if (str == '2 3') {
_result(true);
} else if (str == '23') {
_result(false, ['Test failed. It looks like you forgot the space!']);
} else {
_result(false, ['That\'s not quite right. Keep trying!']);
}
} on UnimplementedError {
_result(false, ['Test failed. Did you implement the method?']);
} catch (e) {
_result(false, ['Tried calling stringify(2, 3), but received an exception: ${e.runtimeType}']);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
Both x and y are simple values,
and Dart's string interpolation will handle
converting them to string representations.
All you need to do is use the $ operator to
reference them inside single quotes, with a space in between.
{$ end hint.txt $}
Nullable variables
Dart aplica un sólido null-safety. Esto significa que los valores no pueden ser null (nulos) a menos que tú digas que pueden serlo. En otras palabras, los tipos por defecto no admiten null.
Por ejemplo, considera el siguiente código. Con null-safety, este código devuelve un error. Una variable de tipo int
no puede tener el valor null
:
int a = null; // INVALID.
Al crear una variable, agrega ?
al tipo para indicar que la variable puede ser null
:
int? a = null; // Valid.
Puedes simplificar un poco ese código porque, en todas las versiones de Dart,
null
es el valor predeterminado para variables no inicializadas:
int? a; // The initial value of a is null.
Para obtener más información sobre null-safety en Dart, lee la guía de null-safety ⬀.
Ejemplo de código
Intenta declarar dos variables a continuación:
- Una
String
nullable (que admite null) llamadaname
con el valor'Jane'
. - Una
String
nullable llamadaaddress
con el valornull
.
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
// Declare the two variables here
{$ end main.dart $}
{$ begin solution.dart $}
String? name = 'Jane';
String? address;
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
try {
if (name == 'Jane' && address == null) {
// verify that "name" is nullable
name = null;
_result(true);
} else {
_result(false, ['That\'s not quite right. Keep trying!']);
}
} catch (e) {
_result(false, ['Tried calling stringify(2, 3), but received an exception: ${e.runtimeType}']);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
Declare the two variables as "String" followed by "?".
Then, assign "Jane" to "name"
and leave "address" uninitialized.
{$ end hint.txt $}
Operadores con reconocimiento de nulos
Dart ofrece algunos operadores útiles para tratar con valores que pueden ser nulos. Uno es el operador de asignación
??=
, que asigna un valor a una variable sólo si esa variable es actualmente null:
int? a; // = null
a ??= 3;
print(a); // <-- Prints 3.
a ??= 5;
print(a); // <-- Still prints 3.
Otro operador que reconoce nulos es ??
, que devuelve la expresión de su izquierda a menos que el valor de esa expresión sea null, en cuyo caso evalúa y devuelve la expresión a su derecha:
print(1 ?? 3); // <-- Prints 1.
print(null ?? 12); // <-- Prints 12.
Ejemplo de código
Intenta sustituir en el siguiente fragmento usando los operadores ??=
y ??
para implementar el comportamiento descrito.
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
String? foo = 'a string';
String? bar; // = null
// Substitute an operator that makes 'a string' be assigned to baz.
String? baz = foo /* TODO */ bar;
void updateSomeVars() {
// Substitute an operator that makes 'a string' be assigned to bar.
bar /* TODO */ 'a string';
}
{$ end main.dart $}
{$ begin solution.dart $}
String? foo = 'a string';
String? bar; // = null
// Substitute an operator that makes 'a string' be assigned to baz.
String? baz = foo ?? bar;
void updateSomeVars() {
// Substitute an operator that makes 'a string' be assigned to bar.
bar ??= 'a string';
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
try {
updateSomeVars();
if (foo != 'a string') {
errs.add('Looks like foo somehow ended up with the wrong value.');
} else if (bar != 'a string') {
errs.add('Looks like bar ended up with the wrong value.');
} else if (baz != 'a string') {
errs.add('Looks like baz ended up with the wrong value.');
}
} catch (e) {
errs.add('Tried calling updateSomeVars and received an exception: ${e.runtimeType}.');
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
All you need to do in this exercise is
replace the TODO comments with either ?? or ??=.
Read the codelab text to make sure you understand both,
and then give it a try.
{$ end hint.txt $}
Acceso condicional a la propiedad
Para asegurar el acceso a una propiedad o método de un objeto que podría ser nulo, pon un signo de interrogación (?
) antes del punto (.
):
myObject?.someProperty
El código anterior es equivalente al siguiente:
(myObject != null) ? myObject.someProperty : null
Puedes encadenar múltiples usos de ?.
juntos en una sola expresión:
myObject?.someProperty?.someMethod()
El código anterior devuelve null (y nunca llama a someMethod()
) si
myObject
o myObject.someProperty
es null.
Ejemplo de código
Intenta usar el acceso condicional a la propiedad para finalizar el fragmento de código a continuación.
{$ begin main.dart $}
// This method should return the uppercase version of `str`
// or null if `str` is null.
String? upperCaseIt(String? str) {
// Try conditionally accessing the `toUpperCase` method here.
}
{$ end main.dart $}
{$ begin solution.dart $}
// This method should return the uppercase version of `str`
// or null if `str` is null.
String? upperCaseIt(String? str) {
return str?.toUpperCase();
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
try {
String? one = upperCaseIt(null);
if (one != null) {
errs.add('Looks like you\'re not returning null for null inputs.');
}
} catch (e) {
errs.add('Tried calling upperCaseIt(null) and got an exception: ${e.runtimeType}.');
}
try {
String? two = upperCaseIt('asdf');
if (two == null) {
errs.add('Looks like you\'re returning null even when str has a value.');
} else if (two != 'ASDF') {
errs.add('Tried upperCaseIt(\'asdf\'), but didn\'t get \'ASDF\' in response.');
}
} catch (e) {
errs.add('Tried calling upperCaseIt(\'asdf\') and got an exception: ${e.runtimeType}.');
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
If this exercise wanted you to conditionally lowercase a string,
you could do it like this: str?.toLowerCase()
{$ end hint.txt $}
Literales de colección
Dart tiene soporte integrado para lists, maps y sets. Puedes crearlos usando literales:
final aListOfStrings = ['one', 'two', 'three'];
final aSetOfStrings = {'one', 'two', 'three'};
final aMapOfStringsToInts = {
'one': 1,
'two': 2,
'three': 3,
};
La inferencia de tipos de Dart puede asignar tipos a estas variables por ti. En este caso, los tipos inferidos son List<String>
, Set<String>
y Map<String, int>
.
O puedes especificar el tipo tú mismo:
final aListOfInts = <int>[];
final aSetOfInts = <int>{};
final aMapOfIntToDouble = <int, double>{};
Especificar tipos es útil cuando inicializas una lista con contenidos de un subtipo, pero aún quieres que la lista sea List<BaseType>
:
final aListOfBaseType = <BaseType>[SubType(), SubType()];
Ejemplo de código
Intenta configurar las siguientes variables con los valores indicados. Reemplaza los valores null existentes.
{$ begin main.dart $}
// Assign this a list containing 'a', 'b', and 'c' in that order:
final aListOfStrings = null;
// Assign this a set containing 3, 4, and 5:
final aSetOfInts = null;
// Assign this a map of String to int so that aMapOfStringsToInts['myKey'] returns 12:
final aMapOfStringsToInts = null;
// Assign this an empty List<double>:
final anEmptyListOfDouble = null;
// Assign this an empty Set<String>:
final anEmptySetOfString = null;
// Assign this an empty Map of double to int:
final anEmptyMapOfDoublesToInts = null;
{$ end main.dart $}
{$ begin solution.dart $}
// Assign this a list containing 'a', 'b', and 'c' in that order:
final aListOfStrings = ['a', 'b', 'c'];
// Assign this a set containing 3, 4, and 5:
final aSetOfInts = {3, 4, 5};
// Assign this a map of String to int so that aMapOfStringsToInts['myKey'] returns 12:
final aMapOfStringsToInts = {'myKey': 12};
// Assign this an empty List<double>:
final anEmptyListOfDouble = <double>[];
// Assign this an empty Set<String>:
final anEmptySetOfString = <String>{};
// Assign this an empty Map of double to int:
final anEmptyMapOfDoublesToInts = <double, int>{};
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
if (aListOfStrings is! List<String>) {
errs.add('aListOfStrings should have the type List<String>.');
} else if (aListOfStrings.length != 3) {
errs.add('aListOfStrings has ${aListOfStrings.length} items in it, rather than the expected 3.');
} else if (aListOfStrings[0] != 'a' || aListOfStrings[1] != 'b' || aListOfStrings[2] != 'c') {
errs.add('aListOfStrings doesn\'t contain the correct values (\'a\', \'b\', \'c\').');
}
if (aSetOfInts is! Set<int>) {
errs.add('aSetOfInts should have the type Set<int>.');
} else if (aSetOfInts.length != 3) {
errs.add('aSetOfInts has ${aSetOfInts.length} items in it, rather than the expected 3.');
} else if (!aSetOfInts.contains(3) || !aSetOfInts.contains(4) || !aSetOfInts.contains(5)) {
errs.add('aSetOfInts doesn\'t contain the correct values (3, 4, 5).');
}
if (aMapOfStringsToInts is! Map<String, int>) {
errs.add('aMapOfStringsToInts should have the type Map<String, int>.');
} else if (aMapOfStringsToInts['myKey'] != 12) {
errs.add('aMapOfStringsToInts doesn\'t contain the correct values (\'myKey\': 12).');
}
if (anEmptyListOfDouble is! List<double>) {
errs.add('anEmptyListOfDouble should have the type List<double>.');
} else if (anEmptyListOfDouble.isNotEmpty) {
errs.add('anEmptyListOfDouble should be empty.');
}
if (anEmptySetOfString is! Set<String>) {
errs.add('anEmptySetOfString should have the type Set<String>.');
} else if (anEmptySetOfString.isNotEmpty) {
errs.add('anEmptySetOfString should be empty.');
}
if (anEmptyMapOfDoublesToInts is! Map<double, int>) {
errs.add('anEmptyMapOfDoublesToInts should have the type Map<double, int>.');
} else if (anEmptyMapOfDoublesToInts.isNotEmpty) {
errs.add('anEmptyMapOfDoublesToInts should be empty.');
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
This exercise is fairly straightforward.
Just add a list, set, or map literal after each equals sign.
See the codelab text for the correct syntax to use.
{$ end hint.txt $}
Sintaxis de flechas
Es posible que hayas visto el símbolo =>
en el código Dart. Esta sintaxis de flecha es una forma de definir una función que ejecuta la expresión a su derecha y devuelve su valor.
Por ejemplo, considera esta llamada, de la clase List
, a su método any()
:
bool hasEmpty = aListOfStrings.any((s) {
return s.isEmpty;
});
Aquí tienes una forma más sencilla de escribir ese código:
bool hasEmpty = aListOfStrings.any((s) => s.isEmpty);
Ejemplo de código
Intenta terminar las siguientes declaraciones, que usan sintaxis de flecha.
{$ begin main.dart $}
class MyClass {
int value1 = 2;
int value2 = 3;
int value3 = 5;
// Returns the product of the above values:
int get product => TODO();
// Adds 1 to value1:
void incrementValue1() => TODO();
// Returns a string containing each item in the
// list, separated by commas (e.g. 'a,b,c'):
String joinWithCommas(List<String> strings) => TODO();
}
{$ end main.dart $}
{$ begin solution.dart $}
class MyClass {
int value1 = 2;
int value2 = 3;
int value3 = 5;
// Returns the product of the above values:
int get product => value1 * value2 * value3;
// Adds 1 to value1:
void incrementValue1() => value1++;
// Returns a string containing each item in the
// list, separated by commas (e.g. 'a,b,c'):
String joinWithCommas(List<String> strings) => strings.join(',');
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final obj = MyClass();
final errs = <String>[];
try {
final product = obj.product;
if (product != 30) {
errs.add('The product property returned $product instead of the expected value (30).');
}
} on UnimplementedError {
_result(false, ['Tried to use MyClass.product but failed. Did you implement the method?']);
return;
} catch (e) {
_result(false, ['Tried to use MyClass.product, but encountered an exception: ${e.runtimeType}.']);
return;
}
try {
obj.incrementValue1();
if (obj.value1 != 3) {
errs.add('After calling incrementValue, value1 was ${obj.value1} instead of the expected value (3).');
}
} on UnimplementedError {
_result(false, ['Tried to use MyClass.incrementValue1 but failed. Did you implement the method?']);
return;
} catch (e) {
_result(false, ['Tried to use MyClass.incrementValue1, but encountered an exception: ${e.runtimeType}.']);
return;
}
try {
final joined = obj.joinWithCommas(['one', 'two', 'three']);
if (joined != 'one,two,three') {
errs.add('Tried calling joinWithCommas([\'one\', \'two\', \'three\']) and received $joined instead of the expected value (\'one,two,three\').');
}
} on UnimplementedError {
_result(false, ['Tried to use MyClass.joinWithCommas but failed. Did you implement the method?']);
return;
} catch (e) {
_result(false, ['Tried to use MyClass.joinWithCommas, but encountered an exception: ${e.runtimeType}.']);
return;
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
For the product, you can just multiply the three values together.
For incrementValue1, you can use the increment operator (++).
For joinWithCommas, try using the join method found in the List class.
{$ end hint.txt $}
Cascadas
Para realizar una secuencia de operaciones en el mismo objeto, usa cascadas (..
). Todos hemos visto una expresión como esta:
myObject.someMethod()
Invoca someMethod()
en myObject
, y el resultado de la expresión es el valor de retorno de someMethod()
.
Aquí tienes la misma expresión con una cascada:
myObject..someMethod()
Aunque todavía invoca someMethod()
en myObject
, el resultado de la expresión no es el valor de retorno—¡es una referencia a myObject
!
Usando cascadas, puedes encadenar operaciones que de otro modo requerirían declaraciones separadas. Por ejemplo, considera el siguiente código, que utiliza el operador de acceso a miembros condicional (?.
) para leer las propiedades del button
si no es null
:
var button = querySelector('#confirm');
button?.text = 'Confirm';
button?.classes.add('important');
button?.onClick.listen((e) => window.alert('Confirmed!'));
button?.scrollIntoView();
Usando cascadas, puedes comenzar con la cascada null-shorting (?..
), lo que garantiza que ninguna de las operaciones en cascada se intenten en un objeto null
. El uso de cascadas acorta el código y hace innecesaria a la variable button
:
querySelector('#confirm')
?..text = 'Confirm'
..classes.add('important')
..onClick.listen((e) => window.alert('Confirmed!'))
..scrollIntoView();
Ejemplo de código
Usa cascadas para crear una declaración única que establezca las propiedades anInt
, aString
y aList
de BigObject
a 1
, 'String!'
y [3.0]
(respectivamente) y luego llama a allDone()
.
{$ begin main.dart $}
class BigObject {
int anInt = 0;
String aString = '';
List<double> aList = [];
bool _done = false;
void allDone() {
_done = true;
}
}
BigObject fillBigObject(BigObject obj) {
// Create a single statement that will update and return obj:
return TODO('obj..');
}
{$ end main.dart $}
{$ begin solution.dart $}
class BigObject {
int anInt = 0;
String aString = '';
List<double> aList = [];
bool _done = false;
void allDone() {
_done = true;
}
}
BigObject fillBigObject(BigObject obj) {
return obj
..anInt = 1
..aString = 'String!'
..aList.add(3)
..allDone();
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
BigObject obj;
try {
obj = fillBigObject(BigObject());
} on UnimplementedError {
_result(false, ['Tried to call fillBigObject but failed. Did you implement the method?']);
return;
} catch (e) {
_result(false, [
'Caught an exception of type ${e.runtimeType} while running fillBigObject'
]);
return;
}
final errs = <String>[];
if (obj.anInt != 1) {
errs.add(
'The value of anInt was ${obj.anInt} rather than the expected (1).');
}
if (obj.aString != 'String!') {
errs.add(
'The value of aString was \'${obj.aString}\' rather than the expected (\'String!\').');
}
if (obj.aList.length != 1) {
errs.add(
'The length of aList was ${obj.aList.length} rather than the expected value (1).');
} else {
if (obj.aList[0] != 3.0) {
errs.add(
'The value found in aList was ${obj.aList[0]} rather than the expected (3.0).');
}
}
if (!obj._done) {
errs.add('It looks like allDone() wasn\'t called.');
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
The best solution for this exercise starts with obj.. and
has four assignment operations chained together.
Try starting with `return obj..anInt = 1`,
then add another cascade (..) and start the next assignment.
{$ end hint.txt $}
Getters y setters
Puedes definir getters y setters siempre que necesites más control sobre una propiedad del que permite un simple campo.
Por ejemplo, puedes asegurarte de que el valor de una propiedad sea válido:
class MyClass {
int _aProperty = 0;
int get aProperty => _aProperty;
set aProperty(int value) {
if (value >= 0) {
_aProperty = value;
}
}
}
También puedes usar un getter para definir una propiedad calculada:
class MyClass {
final List<int> _values = [];
void addValue(int value) {
_values.add(value);
}
// A computed property.
int get count {
return _values.length;
}
}
Ejemplo de código
Imagina que tienes una clase de carrito de compras que mantiene una List<double>
privada de precios. Agrega lo siguiente :
- Un getter llamado
total
que devuelve la suma de los precios - Un setter que reemplaza la lista con una nueva, siempre y cuando la nueva lista no contenga ningún precio negativo (en cuyo caso el setter debe lanzar una
InvalidPriceException
).
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
class InvalidPriceException {}
class ShoppingCart {
List<double> _prices = [];
// Add a "total" getter here:
// Add a "prices" setter here:
}
{$ end main.dart $}
{$ begin solution.dart $}
class InvalidPriceException {}
class ShoppingCart {
List<double> _prices = [];
double get total => _prices.fold(0, (e, t) => e + t);
set prices(List<double> value) {
if (value.any((p) => p < 0)) {
throw InvalidPriceException();
}
_prices = value;
}
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
var foundException = false;
try {
final cart = ShoppingCart();
cart.prices = [12.0, 12.0, -23.0];
} on InvalidPriceException {
foundException = true;
} catch (e) {
_result(false, ['Tried setting a negative price and received a ${e.runtimeType} instead of an InvalidPriceException.']);
return;
}
if (!foundException) {
_result(false, ['Tried setting a negative price and didn\'t get an InvalidPriceException.']);
return;
}
final secondCart = ShoppingCart();
try {
secondCart.prices = [1.0, 2.0, 3.0];
} catch(e) {
_result(false, ['Tried setting prices with a valid list, but received an exception: ${e.runtimeType}.']);
return;
}
if (secondCart._prices.length != 3) {
_result(false, ['Tried setting prices with a list of three values, but _prices ended up having length ${secondCart._prices.length}.']);
return;
}
if (secondCart._prices[0] != 1.0 || secondCart._prices[1] != 2.0 || secondCart._prices[2] != 3.0) {
final vals = secondCart._prices.map((p) => p.toString()).join(', ');
_result(false, ['Tried setting prices with a list of three values (1, 2, 3), but incorrect ones ended up in the price list ($vals) .']);
return;
}
var sum = 0.0;
try {
sum = secondCart.total;
} catch (e) {
_result(false, ['Tried to get total, but received an exception: ${e.runtimeType}.']);
return;
}
if (sum != 6.0) {
_result(false, ['After setting prices to (1, 2, 3), total returned $sum instead of 6.']);
return;
}
_result(true);
}
{$ end test.dart $}
{$ begin hint.txt $}
Two functions are handy for this exercise.
One is `fold`, which can reduce a list to a single value
(try it to calculate the total).
The other is `any`, which can check each item in a list
with a function you give it
(try using it to check if there are any negative prices in the prices setter).
{$ end hint.txt $}
Parámetros posicionales opcionales
Dart tiene dos tipos de parámetros de función: posicionales y con nombre. Los parámetros posicionales son del tipo con el que probablemente estés familiarizado:
int sumUp(int a, int b, int c) {
return a + b + c;
}
// ···
int total = sumUp(1, 2, 3);
Con Dart, puedes hacer que estos parámetros posicionales sean opcionales envolviéndolos entre corchetes:
int sumUpToFive(int a, [int? b, int? c, int? d, int? e]) {
int sum = a;
if (b != null) sum += b;
if (c != null) sum += c;
if (d != null) sum += d;
if (e != null) sum += e;
return sum;
}
// ···
int total = sumUpToFive(1, 2);
int otherTotal = sumUpToFive(1, 2, 3, 4, 5);
Los parámetros posicionales opcionales siempre están al final de la lista de parámetros de una función. Su valor predeterminado es null a menos que proporciones otro valor predeterminado:
int sumUpToFive(int a, [int b = 2, int c = 3, int d = 4, int e = 5]) {
// ···
}
// ···
int newTotal = sumUpToFive(1);
print(newTotal); // <-- prints 15
Ejemplo de código
Implementa una función llamada joinWithCommas()
que acepta de uno a cinco enteros y luego devuelve una cadena de esos números separados por comas. Aquí hay algunos ejemplos de llamadas a funciones y valores devueltos:
Llamada a función | Valor devuelto | |
---|---|---|
joinWithCommas(1) |
'1' |
|
joinWithCommas(1, 2, 3) |
'1,2,3' |
|
joinWithCommas(1, 1, 1, 1, 1) |
'1,1,1,1,1' |
{$ begin main.dart $}
String joinWithCommas(int a, [int? b, int? c, int? d, int? e]) {
return TODO();
}
{$ end main.dart $}
{$ begin solution.dart $}
String joinWithCommas(int a, [int? b, int? c, int? d, int? e]) {
var total = '$a';
if (b != null) total = '$total,$b';
if (c != null) total = '$total,$c';
if (d != null) total = '$total,$d';
if (e != null) total = '$total,$e';
return total;
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
try {
final value = joinWithCommas(1);
if (value != '1') {
errs.add('Tried calling joinWithCommas(1) and got $value instead of the expected (\'1\').');
}
} on UnimplementedError {
_result(false, ['Tried to call joinWithCommas but failed. Did you implement the method?']);
return;
} catch (e) {
_result(false, ['Tried calling joinWithCommas(1), but encountered an exception: ${e.runtimeType}.']);
return;
}
try {
final value = joinWithCommas(1, 2, 3);
if (value != '1,2,3') {
errs.add('Tried calling joinWithCommas(1, 2, 3) and got $value instead of the expected (\'1,2,3\').');
}
} on UnimplementedError {
_result(false, ['Tried to call joinWithCommas but failed. Did you implement the method?']);
return;
} catch (e) {
_result(false, ['Tried calling joinWithCommas(1, 2 ,3), but encountered an exception: ${e.runtimeType}.']);
return;
}
try {
final value = joinWithCommas(1, 2, 3, 4, 5);
if (value != '1,2,3,4,5') {
errs.add('Tried calling joinWithCommas(1, 2, 3, 4, 5) and got $value instead of the expected (\'1,2,3,4,5\').');
}
} on UnimplementedError {
_result(false, ['Tried to call joinWithCommas but failed. Did you implement the method?']);
return;
} catch (e) {
_result(false, ['Tried calling stringify(1, 2, 3, 4 ,5), but encountered an exception: ${e.runtimeType}.']);
return;
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
The b, c, d, and e parameters are null if they aren't provided by caller.
The important thing, then, is to check whether those arguments are null
before you add them to the final string.
{$ end hint.txt $}
Parámetros con nombre
Usando una sintaxis de llave al final de la lista de parámetros, puedes definir parámetros que tengan nombres.
Los parámetros con nombre son opcionales a menos que estén marcados explícitamente como required
.
void printName(String firstName, String lastName, {String? middleName}) {
print('$firstName ${middleName ?? ''} $lastName');
}
// ···
printName('Dash', 'Dartisan');
printName('John', 'Smith', middleName: 'Who');
// Named arguments can be placed anywhere in the argument list
printName('John', middleName: 'Who', 'Smith');
Como es de esperar, el valor predeterminado de un parámetro con nombre que acepta valores null es null
, pero puedes proporcionar un valor predeterminado personalizado.
Si el tipo de un parámetro no admite valores null, entonces debes proporcionar un valor predeterminado (como se muestra en el siguiente código) o marcar el parámetro como required
(como se muestra en la sección del constructor).
void printName(String firstName, String lastName, {String middleName = ''}) {
print('$firstName $middleName $lastName');
}
Una función no puede tener ambos, parámetros posicionales opcionales y con nombre.
Ejemplo de código
Agrega un método de instancia copyWith()
a la clase MyDataObject
. Debería tomar tres parámetros con nombre que acepten valores null:
int? newInt
String? newString
double? newDouble
Tu método copyWith()
debería devolver un nuevo MyDataObject
basado en la instancia actual, con datos de los parámetros anteriores (si los hay) copiados en las propiedades del objeto. Por ejemplo, si newInt
no es null, entonces copia su valor en anInt
.
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
class MyDataObject {
final int anInt;
final String aString;
final double aDouble;
MyDataObject({
this.anInt = 1,
this.aString = 'Old!',
this.aDouble = 2.0,
});
// Add your copyWith method here:
}
{$ end main.dart $}
{$ begin solution.dart $}
class MyDataObject {
final int anInt;
final String aString;
final double aDouble;
MyDataObject({
this.anInt = 1,
this.aString = 'Old!',
this.aDouble = 2.0,
});
MyDataObject copyWith({int? newInt, String? newString, double? newDouble}) {
return MyDataObject(
anInt: newInt ?? this.anInt,
aString: newString ?? this.aString,
aDouble: newDouble ?? this.aDouble,
);
}
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final source = MyDataObject();
final errs = <String>[];
try {
final copy = source.copyWith(newInt: 12, newString: 'New!', newDouble: 3.0);
if (copy.anInt != 12) {
errs.add('Called copyWith(newInt: 12, newString: \'New!\', newDouble: 3.0), and the new object\'s anInt was ${copy.anInt} rather than the expected value (12).');
}
if (copy.aString != 'New!') {
errs.add('Called copyWith(newInt: 12, newString: \'New!\', newDouble: 3.0), and the new object\'s aString was ${copy.aString} rather than the expected value (\'New!\').');
}
if (copy.aDouble != 3) {
errs.add('Called copyWith(newInt: 12, newString: \'New!\', newDouble: 3.0), and the new object\'s aDouble was ${copy.aDouble} rather than the expected value (3).');
}
} catch (e) {
_result(false, ['Called copyWith(newInt: 12, newString: \'New!\', newDouble: 3.0) and got an exception: ${e.runtimeType}']);
}
try {
final copy = source.copyWith();
if (copy.anInt != 1) {
errs.add('Called copyWith(), and the new object\'s anInt was ${copy.anInt} rather than the expected value (1).');
}
if (copy.aString != 'Old!') {
errs.add('Called copyWith(), and the new object\'s aString was ${copy.aString} rather than the expected value (\'Old!\').');
}
if (copy.aDouble != 2) {
errs.add('Called copyWith(), and the new object\'s aDouble was ${copy.aDouble} rather than the expected value (2).');
}
} catch (e) {
_result(false, ['Called copyWith() and got an exception: ${e.runtimeType}']);
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
The copyWith method shows up in a lot of classes and libraries.
Yours should do a few things:
use optional named parameters,
create a new instance of MyDataObject,
and use the data from the parameters to fill it
(or the data from the current instance if the parameters are null).
This is a chance to get more practice with the ?? operator!
{$ end hint.txt $}
Excepciones
El código Dart puede generar y detectar excepciones. A diferencia de Java, todas las excepciones de Dart son excepciones no controladas. Los métodos no declaran qué excepciones podrían generar y no es necesario detectar ninguna excepción.
Dart proporciona los tipos Exception
y Error
, pero puedes lanzar cualquier objeto que no sea null:
throw Exception('Something bad happened.');
throw 'Waaaaaaah!';
Usa las palabras clave try
, on
y catch
para manejar excepciones:
try {
breedMoreLlamas();
} on OutOfLlamasException {
// A specific exception
buyMoreLlamas();
} on Exception catch (e) {
// Anything else that is an exception
print('Unknown exception: $e');
} catch (e) {
// No specified type, handles all
print('Something really unknown: $e');
}
La palabra clave try
funciona como en la mayoría de los demás lenguajes. Usa la palabra clave on
para filtrar excepciones específicas por tipo, y la palabra clave catch
para obtener una referencia al objeto de la excepción.
Si no puedes manejar completamente la excepción, usa la palabra clave rethrow
para propagar la excepción:
try {
breedMoreLlamas();
} catch (e) {
print('I was just trying to breed llamas!');
rethrow;
}
Para ejecutar código independientemente de que se produzca una excepción o no, usa finally
:
try {
breedMoreLlamas();
} catch (e) {
// ... handle exception ...
} finally {
// Always clean up, even if an exception is thrown.
cleanLlamaStalls();
}
Ejemplo de código
Implementa tryFunction()
a continuación. Debería ejecutar un método untrustworthy() y luego hacer lo siguiente:
- Si
untrustworthy()
arroja unaExceptionWithMessage
, llama alogger.logException
con el tipo de excepción y el mensaje (intenta usaron
ycatch
). - Si
untrustworthy()
arroja unaException
, llama alogger.logException
con el tipo de excepción (intenta usaron
para éste). - Si
untrustworthy()
arroja cualquier otro objeto, no detecta la excepción. - Después de que todo esté capturado y manejado, llama a
logger.doneLogging
(intenta usarfinally
).
{$ begin main.dart $}
typedef VoidFunction = void Function();
class ExceptionWithMessage {
final String message;
const ExceptionWithMessage(this.message);
}
// Call logException to log an exception, and doneLogging when finished.
abstract class Logger {
void logException(Type t, [String? msg]);
void doneLogging();
}
void tryFunction(VoidFunction untrustworthy, Logger logger) {
// Invoking this method might cause an exception. Catch and handle
// them using try-on-catch-finally.
untrustworthy();
}
{$ end main.dart $}
{$ begin solution.dart $}
typedef VoidFunction = void Function();
class ExceptionWithMessage {
final String message;
const ExceptionWithMessage(this.message);
}
abstract class Logger {
void logException(Type t, [String? msg]);
void doneLogging();
}
void tryFunction(VoidFunction untrustworthy, Logger logger) {
try {
untrustworthy();
} on ExceptionWithMessage catch (e) {
logger.logException(e.runtimeType, e.message);
} on Exception {
logger.logException(Exception);
} finally {
logger.doneLogging();
}
}
{$ end solution.dart $}
{$ begin test.dart $}
class MyLogger extends Logger {
Type? lastType;
String lastMessage = '';
bool done = false;
void logException(Type t, [String? message]) {
lastType = t;
lastMessage = message ?? lastMessage;
}
void doneLogging() => done = true;
}
void main() {
final errs = <String>[];
var logger = MyLogger();
try {
tryFunction(() => throw Exception(), logger);
if ('${logger.lastType}' != 'Exception' && '${logger.lastType}' != '_Exception') {
errs.add('Untrustworthy threw an Exception, but a different type was logged: ${logger.lastType}.');
}
if (logger.lastMessage != '') {
errs.add('Untrustworthy threw an Exception with no message, but a message was logged anyway: \'${logger.lastMessage}\'.');
}
if (!logger.done) {
errs.add('Untrustworthy threw an Exception, and doneLogging() wasn\'t called afterward.');
}
} catch (e) {
_result(false, ['Untrustworthy threw an exception, and an exception of type ${e.runtimeType} was unhandled by tryFunction.']);
}
logger = MyLogger();
try {
tryFunction(() => throw ExceptionWithMessage('Hey!'), logger);
if (logger.lastType != ExceptionWithMessage) {
errs.add('Untrustworthy threw an ExceptionWithMessage(\'Hey!\'), but a different type was logged: ${logger.lastType}.');
}
if (logger.lastMessage != 'Hey!') {
errs.add('Untrustworthy threw an ExceptionWithMessage(\'Hey!\'), but a different message was logged: \'${logger.lastMessage}\'.');
}
if (!logger.done) {
errs.add('Untrustworthy threw an ExceptionWithMessage(\'Hey!\'), and doneLogging() wasn\'t called afterward.');
}
} catch (e) {
_result(false, ['Untrustworthy threw an ExceptionWithMessage(\'Hey!\'), and an exception of type ${e.runtimeType} was unhandled by tryFunction.']);
}
logger = MyLogger();
bool caughtStringException = false;
try {
tryFunction(() => throw 'A String', logger);
} on String {
caughtStringException = true;
}
if (!caughtStringException) {
errs.add('Untrustworthy threw a string, and it was incorrectly handled inside tryFunction().');
}
logger = MyLogger();
try {
tryFunction(() {}, logger);
if (logger.lastType != null) {
errs.add('Untrustworthy didn\'t throw an Exception, but one was logged anyway: ${logger.lastType}.');
}
if (logger.lastMessage != '') {
errs.add('Untrustworthy didn\'t throw an Exception with no message, but a message was logged anyway: \'${logger.lastMessage}\'.');
}
if (!logger.done) {
errs.add('Untrustworthy didn\'t throw an Exception, but doneLogging() wasn\'t called afterward.');
}
} catch (e) {
_result(false, ['Untrustworthy didn\'t throw an exception, but an exception of type ${e.runtimeType} was unhandled by tryFunction anyway.']);
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
This exercise looks tricky, but it's really one big `try` statement.
Just call `untrustworthy` inside the `try`, and
then use `on`, `catch`, and `finally` to catch exceptions and
call methods on the logger.
{$ end hint.txt $}
this
en un constructor
Usando Dart proporciona un atajo útil para asignar valores a propiedades en un constructor: usa this.propertyName
al declarar el constructor:
class MyColor {
int red;
int green;
int blue;
MyColor(this.red, this.green, this.blue);
}
final color = MyColor(80, 80, 128);
Esta técnica también funciona para parámetros con nombre. Los nombres de propiedad se convierten en los nombres de los parámetros:
class MyColor {
...
MyColor({required this.red, required this.green, required this.blue});
}
final color = MyColor(red: 80, green: 80, blue: 80);
En el código anterior, red
, green
y blue
están marcados como required
porque estos int
no pueden ser null. Si agregas valores predeterminados, puedes omitir required
:
MyColor([this.red = 0, this.green = 0, this.blue = 0]);
// or
MyColor({this.red = 0, this.green = 0, this.blue = 0});
Ejemplo de código
Agrega un constructor de una línea a MyClass
que use la sintaxis
this.
para recibir y asignar valores para las tres propiedades de la clase.
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
class MyClass {
final int anInt;
final String aString;
final double aDouble;
// Create a constructor here.
}
{$ end main.dart $}
{$ begin solution.dart $}
class MyClass {
final int anInt;
final String aString;
final double aDouble;
MyClass(this.anInt, this.aString, this.aDouble);
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
try {
final obj = MyClass(1, 'two', 3);
if (obj.anInt != 1) {
errs.add('Called MyClass(1, \'two\', 3) and got an object with anInt of ${obj.anInt} instead of the expected value (1).');
}
if (obj.anInt != 1) {
errs.add('Called MyClass(1, \'two\', 3) and got an object with aString of \'${obj.aString}\' instead of the expected value (\'two\').');
}
if (obj.anInt != 1) {
errs.add('Called MyClass(1, \'two\', 3) and got an object with aDouble of ${obj.aDouble} instead of the expected value (3).');
}
} catch (e) {
_result(false, ['Called MyClass(1, \'two\', 3) and got an exception of type ${e.runtimeType}.']);
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
This exercise has a one-line solution.
Just declare the constructor with
`this.anInt`, `this.aString`, and `this.aDouble`
as its parameters in that order.
{$ end hint.txt $}
Listas de inicializadores
A veces, cuando implementas un constructor, necesitas realizar algunas configuraciones antes de que se ejecute el cuerpo del constructor. Por ejemplo, los campos final deben tener valores antes de que se ejecute el cuerpo del constructor. Haz este trabajo en una lista de inicializadores, que va entre la firma (signature) del constructor y su cuerpo:
Point.fromJson(Map<String, double> json)
: x = json['x']!,
y = json['y']! {
print('In Point.fromJson(): ($x, $y)');
}
La lista de inicializadores también es un lugar útil para colocar asserts, que se ejecutan solo durante el desarrollo:
NonNegativePoint(this.x, this.y)
: assert(x >= 0),
assert(y >= 0) {
print('I just made a NonNegativePoint: ($x, $y)');
}
Ejemplo de código
Completa el constructor FirstTwoLetters
a continuación. Usa una lista de inicializadores para asignar los dos primeros caracteres en word
a las propiedades letterOne
y LetterTwo
. Para obtener crédito adicional, agrega un assert
para capturar palabras de menos de dos caracteres.
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
class FirstTwoLetters {
final String letterOne;
final String letterTwo;
// Create a constructor with an initializer list here:
FirstTwoLetters(String word)
...
}
{$ end main.dart $}
{$ begin solution.dart $}
class FirstTwoLetters {
final String letterOne;
final String letterTwo;
FirstTwoLetters(String word)
: assert(word.length >= 2),
letterOne = word[0],
letterTwo = word[1];
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
try {
final result = FirstTwoLetters('My String');
if (result.letterOne != 'M') {
errs.add('Called FirstTwoLetters(\'My String\') and got an object with letterOne equal to \'${result.letterOne}\' instead of the expected value (\'M\').');
}
if (result.letterTwo != 'y') {
errs.add('Called FirstTwoLetters(\'My String\') and got an object with letterTwo equal to \'${result.letterTwo}\' instead of the expected value (\'y\').');
}
} catch (e) {
errs.add('Called FirstTwoLetters(\'My String\') and got an exception of type ${e.runtimeType}.');
}
bool caughtException = false;
try {
FirstTwoLetters('');
} catch (e) {
caughtException = true;
}
if (!caughtException) {
errs.add('Called FirstTwoLetters(\'\') and didn\'t get an exception from the failed assertion.');
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
Two assignments need to happen:
letterOne should be word[0], and letterTwo should be word[1].
{$ end hint.txt $}
Constructores con nombre
Para permitir que las clases tengan múltiples constructores, Dart admite constructores con nombre:
class Point {
double x, y;
Point(this.x, this.y);
Point.origin()
: x = 0,
y = 0;
}
Para usar un constructor con nombre, invocalo usando su nombre completo:
final myPoint = Point.origin();
Ejemplo de código
Dale a la clase Color
un constructor llamado Color.black
que establece las tres propiedades en cero.
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
class Color {
int red;
int green;
int blue;
Color(this.red, this.green, this.blue);
// Create a named constructor called "Color.black" here:
}
{$ end main.dart $}
{$ begin solution.dart $}
class Color {
int red;
int green;
int blue;
Color(this.red, this.green, this.blue);
Color.black()
: red = 0,
green = 0,
blue = 0;
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
try {
final result = Color.black();
if (result.red != 0) {
errs.add('Called Color.black() and got a Color with red equal to ${result.red} instead of the expected value (0).');
}
if (result.green != 0) {
errs.add('Called Color.black() and got a Color with green equal to ${result.green} instead of the expected value (0).');
}
if (result.blue != 0) {
errs.add('Called Color.black() and got a Color with blue equal to ${result.blue} instead of the expected value (0).');
}
} catch (e) {
_result(false, ['Called Color.black() and got an exception of type ${e.runtimeType}.']);
return;
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
The declaration for your constructor should be `Color.black() {}`.
Inside the braces, set red, green, and blue to zero.
{$ end hint.txt $}
Constructores factory
Dart admite constructores factory, que pueden devolver subtipos o incluso null. Para crear un constructor factory, usa la palabra clave factory
:
class Square extends Shape {}
class Circle extends Shape {}
class Shape {
Shape();
factory Shape.fromTypeName(String typeName) {
if (typeName == 'square') return Square();
if (typeName == 'circle') return Circle();
throw ArgumentError('Unrecognized $typeName');
}
}
Ejemplo de código
Completa el constructor factory llamado IntegerHolder.fromList
, haciendo que haga lo siguiente:
- Si la lista tiene un valor, crea un
IntegerSingle
con ese valor. - Si la lista tiene dos valores, crea un
IntegerDouble
con los valores en orden. - Si la lista tiene tres valores, crea un
IntegerTriple
con los valores en orden. - De lo contrario, arroja un
Error
.
{$ begin main.dart $}
class IntegerHolder {
IntegerHolder();
// Implement this factory constructor.
factory IntegerHolder.fromList(List<int> list) {
TODO();
}
}
class IntegerSingle extends IntegerHolder {
final int a;
IntegerSingle(this.a);
}
class IntegerDouble extends IntegerHolder {
final int a;
final int b;
IntegerDouble(this.a, this.b);
}
class IntegerTriple extends IntegerHolder {
final int a;
final int b;
final int c;
IntegerTriple(this.a, this.b, this.c);
}
{$ end main.dart $}
{$ begin solution.dart $}
class IntegerHolder {
IntegerHolder();
factory IntegerHolder.fromList(List<int> list) {
if (list.length == 1) {
return IntegerSingle(list[0]);
} else if (list.length == 2) {
return IntegerDouble(list[0], list[1]);
} else if (list.length == 3) {
return IntegerTriple(list[0], list[1], list[2]);
} else {
throw Error();
}
}
}
class IntegerSingle extends IntegerHolder {
final int a;
IntegerSingle(this.a);
}
class IntegerDouble extends IntegerHolder {
final int a;
final int b;
IntegerDouble(this.a, this.b);
}
class IntegerTriple extends IntegerHolder {
final int a;
final int b;
final int c;
IntegerTriple(this.a, this.b, this.c);
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
bool _throwed = false;
try {
IntegerHolder.fromList([]);
} on UnimplementedError {
_result(false, ['Test failed. Did you implement the method?']);
return;
} on Error {
_throwed = true;
} catch (e) {
_result(false, ['Called IntegerSingle.fromList([]) and got an exception of type ${e.runtimeType}.']);
return;
}
if (!_throwed) {
errs.add('Called IntegerSingle.fromList([]) and didn\'t throw Error.');
}
try {
final obj = IntegerHolder.fromList([1]);
if (obj is! IntegerSingle) {
errs.add('Called IntegerHolder.fromList([1]) and got an object of type ${obj.runtimeType} instead of IntegerSingle.');
} else {
if (obj.a != 1) {
errs.add('Called IntegerHolder.fromList([1]) and got an IntegerSingle with an \'a\' value of ${obj.a} instead of the expected (1).');
}
}
} catch (e) {
_result(false, ['Called IntegerHolder.fromList([]) and got an exception of type ${e.runtimeType}.']);
return;
}
try {
final obj = IntegerHolder.fromList([1, 2]);
if (obj is! IntegerDouble) {
errs.add('Called IntegerHolder.fromList([1, 2]) and got an object of type ${obj.runtimeType} instead of IntegerDouble.');
} else {
if (obj.a != 1) {
errs.add('Called IntegerHolder.fromList([1, 2]) and got an IntegerDouble with an \'a\' value of ${obj.a} instead of the expected (1).');
}
if (obj.b != 2) {
errs.add('Called IntegerHolder.fromList([1, 2]) and got an IntegerDouble with an \'b\' value of ${obj.b} instead of the expected (2).');
}
}
} catch (e) {
_result(false, ['Called IntegerHolder.fromList([1, 2]) and got an exception of type ${e.runtimeType}.']);
return;
}
try {
final obj = IntegerHolder.fromList([1, 2, 3]);
if (obj is! IntegerTriple) {
errs.add('Called IntegerHolder.fromList([1, 2, 3]) and got an object of type ${obj.runtimeType} instead of IntegerTriple.');
} else {
if (obj.a != 1) {
errs.add('Called IntegerHolder.fromList([1, 2, 3]) and got an IntegerTriple with an \'a\' value of ${obj.a} instead of the expected (1).');
}
if (obj.b != 2) {
errs.add('Called IntegerHolder.fromList([1, 2, 3]) and got an IntegerTriple with an \'a\' value of ${obj.b} instead of the expected (2).');
}
if (obj.c != 3) {
errs.add('Called IntegerHolder.fromList([1, 2, 3]) and got an IntegerTriple with an \'a\' value of ${obj.b} instead of the expected (2).');
}
}
} catch (e) {
_result(false, ['Called IntegerHolder.fromList([1, 2, 3]) and got an exception of type ${e.runtimeType}.']);
return;
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
Inside the factory constructor,
check the length of the list and create an
IntegerSingle, IntegerDouble, or IntegerTriple as appropriate.
{$ end hint.txt $}
Redirigir constructores
A veces el único propósito de un constructor es redirigir a otro constructor en la misma clase. El cuerpo de un constructor redirigido está vacío, y la llamada al constructor aparece después de dos puntos (:
).
class Automobile {
String make;
String model;
int mpg;
// The main constructor for this class.
Automobile(this.make, this.model, this.mpg);
// Delegates to the main constructor.
Automobile.hybrid(String make, String model) : this(make, model, 60);
// Delegates to a named constructor
Automobile.fancyHybrid() : this.hybrid('Futurecar', 'Mark 2');
}
Ejemplo de código
¿Recuerdas la clase Color
de arriba? Crea un constructor con nombre llamado
black
, pero en lugar de asignar manualmente las propiedades, rediríjelo al constructor predeterminado con ceros como argumentos.
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
class Color {
int red;
int green;
int blue;
Color(this.red, this.green, this.blue);
// Create a named constructor called "black" here and redirect it
// to call the existing constructor
}
{$ end main.dart $}
{$ begin solution.dart $}
class Color {
int red;
int green;
int blue;
Color(this.red, this.green, this.blue);
Color.black() : this(0, 0, 0);
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
try {
final result = Color.black();
if (result.red != 0) {
errs.add('Called Color.black() and got a Color with red equal to ${result.red} instead of the expected value (0).');
}
if (result.green != 0) {
errs.add('Called Color.black() and got a Color with green equal to ${result.green} instead of the expected value (0).');
}
if (result.blue != 0) {
errs.add('Called Color.black() and got a Color with blue equal to ${result.blue} instead of the expected value (0).');
}
} catch (e) {
_result(false, ['Called Color.black() and got an exception of type ${e.runtimeType}.']);
return;
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
Your constructor should redirect to `this(0, 0, 0)`.
{$ end hint.txt $}
Constructores constantes
Si tu clase produce objetos que nunca cambian, puedes hacer que estos objetos sean constantes en tiempo de compilación. Para hacer esto, define un constructor const
y asegúrate de que todas las variables de instancia sean final.
class ImmutablePoint {
static const ImmutablePoint origin = ImmutablePoint(0, 0);
final int x;
final int y;
const ImmutablePoint(this.x, this.y);
}
Ejemplo de código
Modifica la clase Recipe
para que sus instancias puedan ser constantes y crea un constructor constante que haga lo siguiente:
- Tiene tres parámetros:
ingredients
,calories
ymilligramsOfSodium
(en ese orden). - Utiliza la sintaxis
this.
para asignar automáticamente los valores de los parámetros a las propiedades del objeto del mismo nombre. - Es constante, con la palabra clave
const
justo antes deRecipe
en la declaración del constructor.
Ignora todos los errores iniciales en DartPad.
{$ begin main.dart $}
class Recipe {
List<String> ingredients;
int calories;
double milligramsOfSodium;
}
{$ end main.dart $}
{$ begin solution.dart $}
class Recipe {
final List<String> ingredients;
final int calories;
final double milligramsOfSodium;
const Recipe(this.ingredients, this.calories, this.milligramsOfSodium);
}
{$ end solution.dart $}
{$ begin test.dart $}
void main() {
final errs = <String>[];
try {
const obj = Recipe(['1 egg', 'Pat of butter', 'Pinch salt'], 120, 200);
if (obj.ingredients.length != 3) {
errs.add('Called Recipe([\'1 egg\', \'Pat of butter\', \'Pinch salt\'], 120, 200) and got an object with ingredient list of length ${obj.ingredients.length} rather than the expected length (3).');
}
if (obj.calories != 120) {
errs.add('Called Recipe([\'1 egg\', \'Pat of butter\', \'Pinch salt\'], 120, 200) and got an object with a calorie value of ${obj.calories} rather than the expected value (120).');
}
if (obj.milligramsOfSodium != 200) {
errs.add('Called Recipe([\'1 egg\', \'Pat of butter\', \'Pinch salt\'], 120, 200) and got an object with a milligramsOfSodium value of ${obj.milligramsOfSodium} rather than the expected value (200).');
}
} catch (e) {
_result(false, ['Tried calling Recipe([\'1 egg\', \'Pat of butter\', \'Pinch salt\'], 120, 200) and received a null.']);
}
if (errs.isEmpty) {
_result(true);
} else {
_result(false, errs);
}
}
{$ end test.dart $}
{$ begin hint.txt $}
To make the constructor const, you'll need to make all the properties final.
{$ end hint.txt $}
¿Qué sigue?
Esperamos que hayas disfrutado usando este codelab para aprender o probar tu conocimiento de algunas de las características más interesantes del lenguaje Dart. Aquí hay algunas sugerencias sobre qué hacer ahora:
- Prueba otros codelabs de Dart.
- Lee el tour del lenguaje Dart ⬀.
- Juega con DartPad.
- Obtén el SDK de Dart.