Class Lists

Insere um item numa posição; os itens a partir dessa posição avançam uma posição.

Exemplo: [10, 20, 30, 40] com 99 no índice 2 -> [10, 20, 99, 30, 40]

Insere o mesmo item em várias posições da lista original.

Exemplo: [10, 20, 30] com 99 nos índices [0, 2] -> [99, 10, 20, 99, 30]

Insere vários itens, o primeiro no primeiro índice, o segundo no segundo, e assim por diante, todos contados na lista original.

Os índices têm de estar por ordem crescente e tem de haver um por item, ou é lançado um erro. Exemplo: [10, 20, 30] com itens [88, 99] nos índices [1, 2] -> [10, 88, 20, 99, 30]

Adiciona um item no fim da lista.

Exemplo: [10, 20, 30] a adicionar 40 -> [10, 20, 30, 40]

Adiciona um item no início da lista.

Exemplo: [10, 20, 30] a adicionar 5 no início -> [5, 10, 20, 30]

Adiciona um item no início ou no fim da lista, conforme escolhido.

Exemplo: [10, 20, 30] a adicionar 5 primeiro -> [5, 10, 20, 30]; último -> [10, 20, 30, 5]

Une várias listas numa só, de ponta a ponta.

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

Cria uma nova lista sem nada dentro.

Exemplo: -> []

Cria uma lista que contém o mesmo item um número de vezes.

Exemplo: 5 três vezes -> [5, 5, 5]

Repete um padrão de itens vezes sem conta até a lista atingir um dado comprimento.

Exemplo: [1, 2, 3] até ao comprimento 7 -> [1, 2, 3, 1, 2, 3, 1]

Inverte a ordem dos itens.

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

Põe os itens numa ordem aleatória, diferente a cada chamada.

Exemplo: [1, 2, 3, 4, 5] -> talvez [3, 1, 5, 2, 4]

Vira uma lista de listas de lado: as filas tornam-se colunas e as colunas tornam-se filas.

Todas as listas interiores têm de ter o mesmo comprimento. Exemplo: [[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]

Divide a lista em grupos de n itens.

Os itens que sobram no fim são descartados a menos que keepRemainder esteja ligado, o que os adiciona como um último grupo mais curto. Exemplo: [0, 1, 2, 3, 4, 5, 6, 7, 8] em grupos de 3 -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

Lê o item numa posição da lista, a contar de 0.

Um índice fora da lista lança um erro. Exemplo: [10, 20, 30, 40] no índice 2 -> 30

Lê o primeiro item da lista.

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

Lê o último item da lista.

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

Mantém cada item da lista com uma dada probabilidade e descarta o resto, de modo que o resultado difere a cada chamada.

Exemplo: [1, 2, 3, 4, 5] com limiar 0.5 -> talvez [1, 3, 5]

Recorta os itens de um índice inicial até, mas não incluindo, um índice final.

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

Mantém cada enésimo item, a partir de um desvio.

Exemplo: [0, 1, 2, 3, 4, 5, 6, 7, 8] com nth 3 e desvio 0 -> [0, 3, 6]; com nth 2 e desvio 1 -> [1, 3, 5, 7]

Mantém os itens onde um padrão repetido de verdadeiro/falso diz verdadeiro e descarta os outros.

O padrão recomeça quando se esgota. Exemplo: [0, 1, 2, 3, 4, 5] com padrão [true, true, false] -> [0, 1, 3, 4]

Reagrupa listas aninhadas por posição: os primeiros itens de cada lista ficam juntos, depois os segundos itens, e assim por diante.

level diz quantos níveis de aninhamento achatar primeiro dentro de cada lista; 0 reagrupa-as tal como estão. Exemplo: [[0, 1, 2], [3, 4, 5]] no nível 0 -> [[0, 3], [1, 4], [2, 5]]

Mede a lista mais longa entre várias.

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

Indica se um item está na lista.

Os itens são comparados por identidade, por isso um objeto só é encontrado se exatamente o mesmo objeto estiver na lista. Exemplo: [10, 20, 30, 40] inclui 30 -> true, inclui 50 -> false

Encontra a posição da primeira ocorrência de um item, ou -1 quando não está na lista.

Exemplo: [10, 20, 30, 20, 40] a procurar 20 -> 1, a procurar 50 -> -1

Mede quão profundamente as listas estão aninhadas dentro da lista.

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

Conta os itens da lista.

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

Remove o item numa posição.

Exemplo: [10, 20, 30, 40, 50] a remover o índice 2 -> [10, 20, 40, 50]

Remove o primeiro item.

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

Remove o último item.

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

Remove um item contado a partir do fim: o índice 0 é o último item, 1 o anterior a ele.

Exemplo: [10, 20, 30, 40, 50] a remover o índice 1 a partir do fim -> [10, 20, 30, 50]

Remove os itens em várias posições, todas contadas na lista original.

Exemplo: [10, 20, 30, 40, 50] a remover os índices [1, 3] -> [10, 30, 50]

Esvazia a lista que recebe, no lugar: o mesmo array volta sem itens.

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

Remove cada enésimo item, a partir de um desvio.

Exemplo: [0, 1, 2, 3, 4, 5, 6, 7, 8] com nth 3 e desvio 0 -> [1, 2, 4, 5, 7, 8]

Descarta cada item da lista com uma dada probabilidade e mantém o resto, de modo que o resultado difere a cada chamada.

Exemplo: [1, 2, 3, 4, 5] com limiar 0.5 -> talvez [2, 4]

Remove números repetidos, mantendo a primeira ocorrência de cada um.

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

Remove números que estão dentro de uma tolerância de um já mantido, de modo que valores que diferem só por ruído de vírgula flutuante contam como o mesmo.

Exemplo: [1.0, 1.001, 2.0, 2.002, 3.0] com tolerância 0.01 -> [1.0, 2.0, 3.0]

Remove itens repetidos de qualquer tipo, mantendo a primeira ocorrência de cada um.

Os itens são comparados por identidade, por isso dois objetos de aspeto igual ficam ambos. Exemplo: ['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']

Ordena números do mais baixo para o mais alto, ou do mais alto para o mais baixo.

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

Ordena textos alfabeticamente, de A a Z ou de Z a A.

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

Ordena objetos pelo número guardado numa das suas propriedades.

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

Entrelaça várias listas numa só tomando o primeiro item de cada uma à vez, depois o segundo de cada uma, e assim por diante.

Uma lista mais curta simplesmente sai assim que se esgota. Uma lista de listas vazia lança um erro. Exemplo: [[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]