Class Lists

Inserta un elemento en una posición; los elementos desde esa posición en adelante se desplazan una posición.

Ejemplo: [10, 20, 30, 40] con 99 en el índice 2 -> [10, 20, 99, 30, 40]

Inserta el mismo elemento en varias posiciones de la lista original.

Ejemplo: [10, 20, 30] con 99 en los índices [0, 2] -> [99, 10, 20, 99, 30]

Inserta varios elementos, el primero en el primer índice, el segundo en el segundo, y así sucesivamente, todos contados sobre la lista original.

Los índices deben estar en orden ascendente y debe haber uno por elemento, o se lanza un error. Ejemplo: [10, 20, 30] con elementos [88, 99] en los índices [1, 2] -> [10, 88, 20, 99, 30]

Añade un elemento al final de la lista.

Ejemplo: [10, 20, 30] añadiendo 40 -> [10, 20, 30, 40]

Añade un elemento al principio de la lista.

Ejemplo: [10, 20, 30] anteponiendo 5 -> [5, 10, 20, 30]

Añade un elemento al principio o al final de la lista, según se elija.

Ejemplo: [10, 20, 30] añadiendo 5 al principio -> [5, 10, 20, 30]; al final -> [10, 20, 30, 5]

Une varias listas en una, una tras otra.

Ejemplo: [[1, 2], [3, 4], [5, 6]] -> [1, 2, 3, 4, 5, 6]

Hace una lista nueva sin nada dentro.

Ejemplo: -> []

Hace una lista que contiene el mismo elemento un número de veces.

Ejemplo: 5 tres veces -> [5, 5, 5]

Repite un patrón de elementos una y otra vez hasta que la lista alcanza una longitud dada.

Ejemplo: [1, 2, 3] hasta la longitud 7 -> [1, 2, 3, 1, 2, 3, 1]

Invierte el orden de los elementos.

Ejemplo: [1, 2, 3, 4, 5] -> [5, 4, 3, 2, 1]

Pone los elementos en un orden aleatorio, distinto en cada llamada.

Ejemplo: [1, 2, 3, 4, 5] -> quizá [3, 1, 5, 2, 4]

Pone de lado una lista de listas: las filas se convierten en columnas y las columnas en filas.

Todas las listas interiores deben tener la misma longitud. Ejemplo: [[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]

Divide la lista en grupos de n elementos.

Los elementos que sobran al final se descartan salvo que keepRemainder esté activado, lo que los añade como un último grupo más corto. Ejemplo: [0, 1, 2, 3, 4, 5, 6, 7, 8] en grupos de 3 -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

Lee el elemento en una posición de la lista, contando desde 0.

Un índice fuera de la lista lanza un error. Ejemplo: [10, 20, 30, 40] en el índice 2 -> 30

Lee el primer elemento de la lista.

Ejemplo: [10, 20, 30, 40] -> 10

Lee el último elemento de la lista.

Ejemplo: [10, 20, 30, 40] -> 40

Conserva cada elemento de la lista con una probabilidad dada y descarta el resto, de modo que el resultado difiere en cada llamada.

Ejemplo: [1, 2, 3, 4, 5] con umbral 0.5 -> quizá [1, 3, 5]

Recorta los elementos desde un índice inicial hasta un índice final, sin incluirlo.

Ejemplo: [10, 20, 30, 40, 50] de 1 a 4 -> [20, 30, 40]

Conserva cada enésimo elemento, empezando desde un desplazamiento.

Ejemplo: [0, 1, 2, 3, 4, 5, 6, 7, 8] con nth 3 y desplazamiento 0 -> [0, 3, 6]; con nth 2 y desplazamiento 1 -> [1, 3, 5, 7]

Conserva los elementos donde un patrón repetido de true/false dice true y descarta los demás.

El patrón vuelve a empezar cuando se agota. Ejemplo: [0, 1, 2, 3, 4, 5] con patrón [true, true, false] -> [0, 1, 3, 4]

Reagrupa listas anidadas por posición: los primeros elementos de cada lista van juntos, luego los segundos elementos, y así sucesivamente.

level dice cuántos niveles de anidamiento aplanar primero dentro de cada lista; 0 las reagrupa tal como están. Ejemplo: [[0, 1, 2], [3, 4, 5]] en el nivel 0 -> [[0, 3], [1, 4], [2, 5]]

Mide la lista más larga de entre varias.

Ejemplo: [[1, 2], [3, 4, 5, 6], [7]] -> 4

Indica si un elemento está en la lista.

Los elementos se comparan por identidad, así que un objeto se encuentra solo si exactamente el mismo objeto está en la lista. Ejemplo: [10, 20, 30, 40] incluye 30 -> true, incluye 50 -> false

Encuentra la posición de la primera aparición de un elemento, o -1 cuando no está en la lista.

Ejemplo: [10, 20, 30, 20, 40] buscando 20 -> 1, buscando 50 -> -1

Mide cuán profundamente hay listas anidadas dentro de la lista.

Ejemplo: [1, 2, 3] -> 1, [[1, 2], [3, 4]] -> 2, [[[1]]] -> 3

Cuenta los elementos de la lista.

Ejemplo: [10, 20, 30, 40, 50] -> 5, [] -> 0

Elimina el elemento de una posición.

Ejemplo: [10, 20, 30, 40, 50] eliminando el índice 2 -> [10, 20, 40, 50]

Elimina el primer elemento.

Ejemplo: [10, 20, 30, 40] -> [20, 30, 40]

Elimina el último elemento.

Ejemplo: [10, 20, 30, 40] -> [10, 20, 30]

Elimina un elemento contado desde el final: el índice 0 es el último elemento, 1 el anterior.

Ejemplo: [10, 20, 30, 40, 50] eliminando el índice 1 desde el final -> [10, 20, 30, 50]

Elimina los elementos de varias posiciones, todas contadas sobre la lista original.

Ejemplo: [10, 20, 30, 40, 50] eliminando los índices [1, 3] -> [10, 30, 50]

Vacía la lista que se le da, en el sitio: vuelve el mismo array sin ningún elemento.

Ejemplo: [10, 20, 30, 40] -> []

Elimina cada enésimo elemento, empezando desde un desplazamiento.

Ejemplo: [0, 1, 2, 3, 4, 5, 6, 7, 8] con nth 3 y desplazamiento 0 -> [1, 2, 4, 5, 7, 8]

Descarta cada elemento de la lista con una probabilidad dada y conserva el resto, de modo que el resultado difiere en cada llamada.

Ejemplo: [1, 2, 3, 4, 5] con umbral 0.5 -> quizá [2, 4]

Elimina los números repetidos, conservando la primera aparición de cada uno.

Ejemplo: [1, 2, 3, 2, 4, 3, 5] -> [1, 2, 3, 4, 5]

Elimina los números que están dentro de una tolerancia respecto a uno ya conservado, de modo que los valores que difieren solo por ruido de coma flotante cuentan como el mismo.

Ejemplo: [1.0, 1.001, 2.0, 2.002, 3.0] con tolerancia 0.01 -> [1.0, 2.0, 3.0]

Elimina los elementos repetidos de cualquier tipo, conservando la primera aparición de cada uno.

Los elementos se comparan por identidad, así que dos objetos de aspecto igual se quedan ambos. Ejemplo: ['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']

Ordena números de menor a mayor, o de mayor a menor.

Ejemplo: [5, 2, 8, 1, 9] ascendente -> [1, 2, 5, 8, 9]; descendente -> [9, 8, 5, 2, 1]

Ordena textos alfabéticamente, de la A a la Z o de la Z a la A.

Ejemplo: ['dog', 'apple', 'cat'] ascendente -> ['apple', 'cat', 'dog']

Ordena objetos por el número contenido en una de sus propiedades.

Ejemplo: [{age: 30}, {age: 20}, {age: 25}] por 'age' ascendente -> [{age: 20}, {age: 25}, {age: 30}]

Entrelaza varias listas en una tomando el primer elemento de cada una por turno, luego el segundo de cada una, y así sucesivamente.

Una lista más corta simplemente deja de participar cuando se agota. Una lista de listas vacía lanza un error. Ejemplo: [[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]