Tabla de Contenido
Introducción
Las colecciones son estructuras de datos con las cuales podemos realizar diferentes operaciones para manipular sus elementos.
En Dart, hay soporte incorporado para tres tipos de colecciones: listas(List), conjuntos(Set) y mapas(Map). En esta primera publicación aprenderemos sobre las Listas en Dart.
Listas(List)
Una lista es una colección ordenada de elementos u objetos, en la mayoría de lenguajes de programación la colección que más se usa es el array. En Dart, los array son objetos de las listas, por eso la mayoría los llaman listas.
Las listas en Dart se pueden crear e inicializar por lo general con sus valores separados por comas entre corchetes ([]).
var list = ['a', 'b', 'c'];
Constructores de una lista
Las listas también cuentan con algunos constructores para generarse.
Constructor List.empty
Sirve para crear una lista vacía.
// cuando growable es true, se genera una lista vacía que si permite
// agregar nuevo elementos.
final growableList = List.empty(growable: true); // []
growableList.add(1); // [1]
// cuando growable es false, es una lista de longitud fija en cero.
// por lo cual no es posible agregar nuevos elementos.
final fixedLengthList = List.empty(growable: false);
fixedLengthList.add(1); // error
Constructor List.filled
Sirve para crear una lista a la cual le podemos dar un tamaño y se llenan todos los elementos. La longitud debe ser un entero no negativo.
// Estructura del contructor.
// tanto length como fill son obligatorios
// length: indica el tamaño que le daremos a la lista
// fill: el valor que tendrán inicialmente todos los elementos
List<E>.filled(
int length,
E fill,
{bool growable = false}
)
// algunos ejemplos
final filledList1 = List.filled(3, 3); // [3, 3, 3]
final filledList2 = List.filled(3, 3); // [[], [], []]
final filledList1 = List.filled(3, 'Mes', growable: true);
filledList1[0] = 'Enero';
filledList1[1] = 'Febrero';
filledList1[1] = 'Marzo';
filledList1.add('Abril'); // ['Enero', 'Febrero', 'Marzo', 'Abril']
Constructor List.from
Sirve para crear una lista que contiene todos los elementos. El Iterator de elementos proporciona el orden de los elementos. Todos los elementos deben ser instancias de E.
// Estructura del contructor
// elements: es la lista de elementos que recibe
List<E>.from(
Iterable elements,
{bool growable = true}
)
// ejemplo
final letters = <String>['a', 'b', 'c'];
final listFrom = List<String>.from(letters);
print(listFrom); // [a, b, c]
Constructor List.generate
Sirve para generar una lista de valores. Crea una lista con posiciones de longitud y la llena con valores creados llamando al generador para cada índice en el rango 0. Podemos modificarlos siempre y cuando indiquemos el growable en true.
// Estructura del contructor
// length: tamaño de la lista
// generator: es una función para generar índices
List<E>.generate(
int length,
E generator(
int index
),
{bool growable = true}
)
// ejemplos
final generateList1 = List<String>.generate(3, (int index) => '$index:A');
print(generateList1); // [0:A, 1:A, 2:A]
final generateList2 =
List<int>.generate(3, (int index) => index + index, growable: true);
print(generateList2); // [0, 2, 4]
Constructor List.of
Sirve para crear una lista a partir de elementos. Este constructor crea una lista que se puede modificar cuando growable es true; sino es una lista de tamaño fijo.
// Estructura del contructor
// elements: es la lista de elementos que recibe
// growable = true, se puede agregar más elementos.
List<E>.of(
Iterable<E> elements,
{bool growable = true}
)
// Ejemplo
final numbers = <int>[1, 2, 3, 4, 5];
final listOfNumbers = List<num>.of(numbers);
print(listOfNumbers); // [1, 2, 3, 4, 5]
final numbers2 = <int>[1, 2, 3, 4, 5];
final listOfNumbers2 = List<num>.of(numbers2, growable: true);
listOfNumbers2.add(6);
print(listOfNumbers2); // [1, 2, 3, 4, 5, 6]
Constructor List.unmodifiable
Sirve para crear una lista no modificable que contiene todos los elementos. Si los elementos son inmutables, la lista que se crea también lo es.
// Estructura del contructor
// elements: es la lista de elementos que recibe
List<E>.unmodifiable(
Iterable elements
)
// ejemplo
final numbers = <int>[1, 2, 3];
final unmodifiableList = List.unmodifiable(numbers); // [1, 2, 3]
unmodifiableList[1] = 87; // Throws.
final objectList = <Object>[true, 1, 'A'];
final unmodifiableList = List.unmodifiable(objectList);
print(unmodifiableList); // [true, 1, A]
unmodifiableList[1] = false; // Uncaught Error: Unsupported operation: indexed set
Propiedades de una lista
Las listas tienen muchas propiedades que podemos utilizarlas para realizar diferentes tipos de acciones sobre ellas.
// Otra forma de crear una lista vacía.
var emptyList = <int>[];
// isEmpty: valida si la lista es vacía.
print(emptyList.isEmpty);
// Crea una lista con literales
var sports = ['Fútbol', 'Natación', 'Tenis'];
// first: obtiene el primer elemento de la lista
print(sports.first);
// isNotEmpty: valida que tenga al menos un elemento.
print(sports.isNotEmpty);
// last: obtiene el último elemento de la lista
print(sports.last);
// length: Obtener el tamaño de la lista
print(sports.length);
// reversed: se usa para ordenar al revés la lista.
var otherList = sports.reversed;
print(otherList);
// runtimeType: el tipo en tiempo de ejecución
print(sports.runtimeType);
// single: valida que la lista tenga un solo elemento
// si es así devuelve el elemento. sino devuelve un error
// Bad state: Too many elements
var oneList = ['one'];
print(oneList.single);
Métodos de una lista
Las listas también tiene métodos que se pueden usar para modificar su estado.
var sports = ['Fútbol', 'Natación', 'Tenis'];
// add: Agrega un elemento a la lista
sports.add('Ciclismo');
print(sports);
// Agregamos varios elementos a la lista
sports.addAll(['Béisbol', 'Baloncesto']);
print(sports);
// any: valida si al menos un elemento cumple con la condición
print(sports.any((element) => element.contains('a')));
// asMap: crea un mapa asignando los keys empezando en 0.
// {0: Fútbol, 1: Natación, 2: Tenis, 3: Ciclismo, 4: Béisbol, 5: Baloncesto}
print(sports.asMap());
// cast: devuelve una vista de la lista
print(sports.cast());
// clear: Eliminar todos los elementos de la lista.
sports.clear();
print('Cantidad de elementos: ${sports.length}');
// contains: Valida si la lista tiene un elemento igual al ingresado.
print(sports.contains('Ciclismo'));
// elementAt: retorna el valor dado el índice.
print(sports.elementAt(2));
// every: valida que todos los elementos cumplan con la condición
print(sports.every((element) => element.length >= 5));
// fillRange: sobreescribe algunos elementos
// [Golf, Golf, Fútbol, Ciclismo, Baloncesto]
sports.fillRange(1, 3, 'Golf');
print(sports);
// firstWhere: devuelve el primer elemento que cumpla la condición.
print(sports.firstWhere((element) => element.endsWith('o')));
// fold: reduce la lista a un solo valor, combinando los elementos
// #FútbolNataciónTenisCiclismoBéisbolBaloncesto
const initialValue = '#';
print(sports.fold<String>(
initialValue, (previousValue, element) => previousValue + element));
// followedBy: crea la concatenación entre 2 iterables.
// (Fútbol, Natación, Tenis, Ciclismo, Béisbol, Baloncesto, Atletismo, Boxeo)
var othersSports = <String>['Atletismo', 'Boxeo'];
var updated = sports.followedBy(othersSports);
print(updated);
// foreach: para iterar los elementos de la lista
othersSports.forEach((element) => print('elemento: $element'));
// getRange: crea un Iterable que itera sobre un rango de elementos.
final firstRange = sports.getRange(0, 3);
print(firstRange.join(', ')); // Fútbol, Natación, Tenis
// indexOf: para obtener el índice dentro de la lista dado el valor
var baseIndex = sports.indexOf('Béisbol');
print(baseIndex);
// indexWhere: el primer índice de la lista que cumpla la condición.
print(sports.indexWhere((item) => item.startsWith('N')));
// insert: inserta un elemento nuevo en el índice que digamos.
// [Fútbol, Rugby, Natación, Tenis, Ciclismo, Béisbol, Baloncesto]
sports.insert(1, 'Rugby');
print(sports);
// // insertAll: inserta varios elementos en la posición indicada.
// [Fútbol, Hockey, Waterpolo, Rugby, Natación, Tenis, Ciclismo, Béisbol, Baloncesto]
sports.insertAll(1, ['Hockey', 'Waterpolo']);
print(sports);
// join: Convierte cada elemento en una cadena y concatena las cadenas.
print(sports.join('-'));
// lastIndexOf: El último índice del elemento en esta lista.
const startIndex = 2;
print(sports.lastIndexOf('Natación', startIndex));
// lastIndexWhere: Obtiene el último índice de la lista
// que cumpla la condición.
print(sports.lastIndexWhere((item) => item.startsWith('C')));
// lastWhere: devuelve el último elemento que cumpla la condición.
print(sports.lastWhere((element) => element.contains('i')));
// map: Los elementos actuales se modifican por los enviados
print(sports.map((product) => product));
// reduce: reduce la colección a un solo valor
// FútbolNataciónTenisCiclismo
var reduceSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(reduceSports.reduce((value, element) => value + element));
// remove: elimina el primer elemento que coincida con el valor
var removeSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo', 'Tenis'];
removeSports.remove('Tenis');
print(removeSports); // [Fútbol, Natación, Ciclismo, Tenis]
// removeAt: elimina el objeto dado un índice
var removeAtSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
removeAtSports.removeAt(1);
print(removeAtSports); // [Fútbol, Tenis, Ciclismo]
// removeLast: elimina el último elemento de la lista
var removeLastSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
removeLastSports.removeLast();
print(removeLastSports); // [Fútbol, Natación, Tenis]
// removeRange: elimina varios elementos dado un rango de índices
var removeRangeSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
removeRangeSports.removeRange(0, 2);
print(removeRangeSports); // [Tenis, Ciclismo]
// removeWhere: elimina todos los elementos que cumplan la condición
var removeWhereSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
removeWhereSports.removeWhere((item) => item.length > 7);
print(removeWhereSports); // [Tenis, Ciclismo]
// replaceRange: reemplaza un rango de elementos por otros que indiquemos
var replaceRangeSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
replaceRangeSports.replaceRange(0, 2, ['Boxeo', 'Golf']);
print(replaceRangeSports); // [Boxeo, Golf, Tenis, Ciclismo]
// retainWhere: Elimina todos los objetos de esta lista que no cumplan la condición.
var retainWhereSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
retainWhereSports.retainWhere((item) => item.length == 6);
print(retainWhereSports); // [Fútbol]
// setAll: sobreescribe elementos con los objetos del iterable
var setAllSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
setAllSports.setAll(1, ['Boxeo', 'Atletismo']);
print(setAllSports); // [Fútbol, Boxeo, Atletismo, Ciclismo]
// shuffle: cambia la posición de los elementos al azar.
var shuffleSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
shuffleSports.shuffle();
print(shuffleSports); // [Natación, Ciclismo, Fútbol, Tenis]
// singleWhere: devuelve un elemento siempre que haya uno solo que cumpla la condición
var singleWhereSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(singleWhereSports.singleWhere((element) => element.startsWith('F'))); // Fútbol
// skip: crea un iterable que devuelve los elementos
// excepto los anteriores al índice ingresado.
var skipSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(skipSports.skip(2)); // (Tenis, Ciclismo)
// skipWhile: Crea un Iterable que omite los elementos principales
// mientras se cumpla la condición.
var skipSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
// (Tenis, Ciclismo)
print(skipSports.skipWhile((element) => element.length > 5));
// sort: sirve para ordenar la lista, utilizando compareTo()
// sino se envía la función para comparar, ordena alfabéticamente.
var sortSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
sortSports.sort();
print(sortSports);
// con compareTo, podemos mostrar al revés la lista
sortSports.sort((a, b) => b.compareTo(a));
print(sortSports);
// sublist: Devuelve una nueva lista que contiene los elementos en un rango.
var sublistSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(sublistSports.sublist(1,3)); // [Natación, Tenis]
// take: Crea un iterable lazy de los elementos antes del índice ingresado.
var takeSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(takeSports.take(1)); // (Fútbol)
// takeWhile: Crea un iterable lazy de los elementos dado una condición.
var takeWhileSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(takeWhileSports.takeWhile((x) => x.contains('o'))); // (Fútbol)
// toList: Crea una lista con los elementos del iterable.
var toListSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(toListSports.toList()); // [Fútbol, Natación, Tenis, Ciclismo]
// toSet: Crea un Set con los elementos del iterable.
var toSetSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(toSetSports.toSet()); // {Fútbol, Natación, Tenis, Ciclismo}
// toString: Crea una representación de cadena de este objeto.
var toSetSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(toSetSports.toString()); // [Fútbol, Natación, Tenis, Ciclismo]
// where: Crea un nuevo Iterable lazy con todos los elementos
// que coincidan con la condición.
var whereSports = ['Fútbol', 'Natación', 'Tenis', 'Ciclismo'];
print(whereSports.where((item) => item.endsWith('s'))); // (Tenis)
Conclusión
Vimos las propiedades y métodos que tienen las listas en Dart, hay muchos que son de gran utilizada para el manejo de listas.
¡Gracias por leer!
