Class Lists

Вставляет элемент на позицию; элементы с этой позиции сдвигаются на одну вверх.

Пример: [10, 20, 30, 40] с 99 на индексе 2 -> [10, 20, 99, 30, 40]

Вставляет один и тот же элемент на несколько позиций исходного списка.

Пример: [10, 20, 30] с 99 на индексах [0, 2] -> [99, 10, 20, 99, 30]

Вставляет несколько элементов, первый на первый индекс, второй на второй и так далее, все считаются по исходному списку.

Индексы должны быть по возрастанию, и их должно быть по одному на элемент, иначе выбрасывается ошибка. Пример: [10, 20, 30] с элементами [88, 99] на индексах [1, 2] -> [10, 88, 20, 99, 30]

Добавляет элемент в конец списка.

Пример: [10, 20, 30] добавляем 40 -> [10, 20, 30, 40]

Добавляет элемент в начало списка.

Пример: [10, 20, 30] добавляем в начало 5 -> [5, 10, 20, 30]

Добавляет элемент в начало или в конец списка, по выбору.

Пример: [10, 20, 30] добавляем 5 в начало -> [5, 10, 20, 30]; в конец -> [10, 20, 30, 5]

Соединяет несколько списков в один, один за другим.

Пример: [[1, 2], [3, 4], [5, 6]] -> [1, 2, 3, 4, 5, 6]

Делает новый список без ничего внутри.

Пример: -> []

Делает список, содержащий один и тот же элемент несколько раз.

Пример: 5 три раза -> [5, 5, 5]

Повторяет шаблон элементов снова и снова, пока список не достигнет заданной длины.

Пример: [1, 2, 3] до длины 7 -> [1, 2, 3, 1, 2, 3, 1]

Обращает порядок элементов.

Пример: [1, 2, 3, 4, 5] -> [5, 4, 3, 2, 1]

Расставляет элементы в случайном порядке, разном при каждом вызове.

Пример: [1, 2, 3, 4, 5] -> возможно [3, 1, 5, 2, 4]

Переворачивает список списков на бок: строки становятся столбцами, а столбцы - строками.

Все внутренние списки должны быть одной длины. Пример: [[0, 1, 2], [3, 4, 5]] -> [[0, 3], [1, 4], [2, 5]]

Разбивает список на группы по n элементов.

Элементы, оставшиеся в конце, отбрасываются, если не включен keepRemainder, который добавляет их как более короткую последнюю группу. Пример: [0, 1, 2, 3, 4, 5, 6, 7, 8] группами по 3 -> [[0, 1, 2], [3, 4, 5], [6, 7, 8]]

Читает элемент на позиции в списке, считая с 0.

Индекс за пределами списка выбрасывает ошибку. Пример: [10, 20, 30, 40] с индексом 2 -> 30

Читает первый элемент списка.

Пример: [10, 20, 30, 40] -> 10

Читает последний элемент списка.

Пример: [10, 20, 30, 40] -> 40

Сохраняет каждый элемент списка с заданной вероятностью и отбрасывает остальные, так что результат отличается при каждом вызове.

Пример: [1, 2, 3, 4, 5] с порогом 0.5 -> возможно [1, 3, 5]

Вырезает элементы от начального индекса до конечного, не включая его.

Пример: [10, 20, 30, 40, 50] от 1 до 4 -> [20, 30, 40]

Сохраняет каждый n-й элемент, начиная со смещения.

Пример: [0, 1, 2, 3, 4, 5, 6, 7, 8] с nth 3 и смещением 0 -> [0, 3, 6]; с nth 2 и смещением 1 -> [1, 3, 5, 7]

Сохраняет элементы там, где повторяющийся шаблон true/false говорит true, и отбрасывает остальные.

Шаблон начинается заново, когда заканчивается. Пример: [0, 1, 2, 3, 4, 5] с шаблоном [true, true, false] -> [0, 1, 3, 4]

Перегруппировывает вложенные списки по позиции: первые элементы каждого списка идут вместе, затем вторые элементы и так далее.

level говорит, сколько уровней вложенности сначала развернуть внутри каждого списка; 0 перегруппировывает их как есть. Пример: [[0, 1, 2], [3, 4, 5]] на уровне 0 -> [[0, 3], [1, 4], [2, 5]]

Измеряет самый длинный список среди нескольких.

Пример: [[1, 2], [3, 4, 5, 6], [7]] -> 4

Сообщает, есть ли элемент в списке.

Элементы сравниваются по идентичности, так что объект находится, только если в списке тот же самый объект. Пример: [10, 20, 30, 40] содержит 30 -> true, содержит 50 -> false

Находит позицию первого вхождения элемента, или -1, когда его нет в списке.

Пример: [10, 20, 30, 20, 40] ищем 20 -> 1, ищем 50 -> -1

Измеряет, насколько глубоко списки вложены внутри списка.

Пример: [1, 2, 3] -> 1, [[1, 2], [3, 4]] -> 2, [[[1]]] -> 3

Считает элементы в списке.

Пример: [10, 20, 30, 40, 50] -> 5, [] -> 0

Удаляет элемент на позиции.

Пример: [10, 20, 30, 40, 50] удаляем индекс 2 -> [10, 20, 40, 50]

Удаляет первый элемент.

Пример: [10, 20, 30, 40] -> [20, 30, 40]

Удаляет последний элемент.

Пример: [10, 20, 30, 40] -> [10, 20, 30]

Удаляет элемент, считая с конца: индекс 0 - последний элемент, 1 - предпоследний.

Пример: [10, 20, 30, 40, 50] удаляем индекс 1 с конца -> [10, 20, 30, 50]

Удаляет элементы на нескольких позициях, все считаются по исходному списку.

Пример: [10, 20, 30, 40, 50] удаляем индексы [1, 3] -> [10, 30, 50]

Опустошает заданный список на месте: тот же массив возвращается без элементов.

Пример: [10, 20, 30, 40] -> []

Удаляет каждый n-й элемент, начиная со смещения.

Пример: [0, 1, 2, 3, 4, 5, 6, 7, 8] с nth 3 и смещением 0 -> [1, 2, 4, 5, 7, 8]

Отбрасывает каждый элемент списка с заданной вероятностью и сохраняет остальные, так что результат отличается при каждом вызове.

Пример: [1, 2, 3, 4, 5] с порогом 0.5 -> возможно [2, 4]

Удаляет повторяющиеся числа, сохраняя первое вхождение каждого.

Пример: [1, 2, 3, 2, 4, 3, 5] -> [1, 2, 3, 4, 5]

Удаляет числа, находящиеся в пределах допуска от уже сохраненного, так что значения, отличающиеся только шумом плавающей точки, считаются одинаковыми.

Пример: [1.0, 1.001, 2.0, 2.002, 3.0] с допуском 0.01 -> [1.0, 2.0, 3.0]

Удаляет повторяющиеся элементы любого вида, сохраняя первое вхождение каждого.

Элементы сравниваются по идентичности, так что два одинаково выглядящих объекта оба остаются. Пример: ['a', 'b', 'c', 'a', 'd', 'b'] -> ['a', 'b', 'c', 'd']

Сортирует числа от наименьшего к наибольшему или от наибольшего к наименьшему.

Пример: [5, 2, 8, 1, 9] по возрастанию -> [1, 2, 5, 8, 9]; по убыванию -> [9, 8, 5, 2, 1]

Сортирует тексты по алфавиту, от A до Z или от Z до A.

Пример: ['dog', 'apple', 'cat'] по возрастанию -> ['apple', 'cat', 'dog']

Сортирует объекты по числу, хранящемуся в одном из их свойств.

Пример: [{age: 30}, {age: 20}, {age: 25}] по 'age' по возрастанию -> [{age: 20}, {age: 25}, {age: 30}]

Сплетает несколько списков в один, беря по очереди первый элемент каждого, затем второй каждого и так далее.

Более короткий список просто выбывает, когда исчерпывается. Пустой список списков выбрасывает ошибку. Пример: [[0, 1, 2], [3, 4, 5]] -> [0, 3, 1, 4, 2, 5]