Удаление элемента из массива: Как удалить элемент из массива в JavaScript

удаление первого, последнего и нескольких элементов / Skillbox Media

#статьи

• 18 ноя 2022
• 0

Рассказываем, как работают методы remove(), pop(), clear() и ключевое слово del.

Иван Стуков

Журналист, изучает Python. Любит разбираться в мелочах, общаться с людьми и понимать их.

В Python есть много удобных механизмов для работы со списками. И удалять элементы из них можно по-разному.

remove() можно использовать, когда мы точно знаем значение, от которого хотим избавиться. В качестве аргумента remove() получает объект, находит совпадение и удаляет его, ничего не возвращая:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
new_list.remove(1)
print(new_list )
>>> ['ноль', [2.1, 'два и два'], 3, 'IV']

Можно удалять и более сложные объекты: например, внутренние списки. Главное — в точности передать этот объект методу:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
new_list. remove([2.1, 'два и два'])
print(new_list)
>>> ['ноль', 1, 3, 'IV']

remove() удаляет только первое совпадение с искомым элементом. Например, так он себя поведёт, если в списке будет несколько строк ‘ноль’:

change_list = ['ноль', 1, [2.1, 'два и два'], 'ноль', 3, 'IV']
change_list.remove('ноль')
print(change_list)
>>> [1, [2.1, 'два и два'], 'ноль', 3, 'IV']

При попытке удалить значение, которого нет в списке, Python выдаст ошибку

pop() подойдёт, когда известно точное местоположение удаляемого элемента. В качестве аргумента pop() получает индекс, а возвращает удалённое значение:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
new_list.pop(2)
>>> [2.1, 'два и два']
print(new_list)
>>> ['ноль', 1, 3, 'IV']

Если передать отрицательное значение, то pop() будет считать индексы не с нуля, а с -1:

new_list = ['ноль', 1, [2.  1, 'два и два'], 3, 'IV']
new_list.pop(-2)
print(new_list)
#Удалили предпоследний элемент.
>>> ['ноль', 1, [2.1, 'два и два'], 'IV']

А вот если оставить pop() без аргумента, то удалится последний элемент — потому что -1 является аргументом по умолчанию:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
new_list.pop()
print(new_list)
>>> ['ноль', 1, [2.1, 'два и два'], 3]

При попытке обратиться в методе pop() к несуществующему индексу, интерпретатор выбросит исключение IndexError.

clear() удаляет из списка всё, то есть буквально очищает его. Он не принимает аргументов и не возвращает никаких значений:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
new_list.clear()
print(new_list)
>>> []

del, как и метод pop(), удаляет элементы списка по индексу. При этом с его помощью можно избавиться как от единичного объекта, так и от целого среза:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
del new_list[2]
print(new_list)
>>> ['ноль', 1, 3, 'IV']

Если передать срез, то элемент с правым индексом не удалится. В примере ниже это строка

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
del new_list[1:4]
print(new_list)
>>> ['ноль', 'IV']

Чтобы очистить список, достаточно передать полный срез [:]:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
del new_list[:]
print(new_list)
>>> []

Также del можно использовать с отрицательными индексами:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
del new_list[-4]
print(new_list)
>>> ['ноль', [2.1, 'два и два'], 3, 'IV']

Со срезами это тоже работает:

new_list = ['ноль', 1, [2. 1, 'два и два'], 3, 'IV']
del new_list[-3:-1]
print(new_list)
>>> ['ноль', 1, 'IV']

Если при удалении единичного элемента указать несуществующий индекс, то Python выдаст ошибку IndexError.

Довольно часто, например, при реализации стека, нужно удалить первый элемент списка. Возьмём наш new_list и посмотрим, какими способами это можно сделать.

Передаём в качестве аргумента pop() индекс 0:

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
new_list.pop(0)
print(new_list)
>>> [1, [2.1, 'два и два'], 3, 'IV']

Используем del с элементом с индексом 0.

new_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
del new_list[0]
print(new_list)
>>> [1, [2.1, 'два и два'], 3, 'IV']

Если элементы, от которых нужно избавиться, находятся по соседству друг с другом, то удобнее всего использовать del.

Допустим, в последовательности чисел от 0 до 9 нужно удалить 4, 5, 6 и 7. Тогда решение будет выглядеть так:

#Сначала создадим лист с числами от 0 до 9.
num_list = list(i for i in range(10))
print(num_list)
>>> [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]
#После чего укажем срез чисел от 4 до 7.
#Обратите внимание: элемент с индексом 8 не удаляется.
del num_list[4:8]
print(num_list)
>>> [0, 1, 2, 3, 8, 9]

Если мы хотим избавиться от последнего элемента, то, как и в случае с первым, удобнее всего это сделать с помощью pop() или del.

Так как по умолчанию метод принимает аргумент -1, то можно вообще ничего не передавать:

num_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
num_list.pop()
print (num_list)
>>> ['ноль', 1, [2.1, 'два и два'], 3]

Но если вы истинный приверженец дзена Python («Явное лучше неявного»), то можно указать -1 — ничего не изменится.

А вот если хотите удалить последний элемент с помощью del, то передать -1 нужно обязательно:

num_list = ['ноль', 1, [2.1, 'два и два'], 3, 'IV']
del num_list[-1]
print(num_list)
>>> ['ноль', 1, [2.1, 'два и два'], 3]

Язык Python даёт четыре основных инструмента для удаления элементов из списка:

• remove() — удаляет по названию;
• pop() — удаляет по индексу, положительному или отрицательному;
• clear() — удаляет всё содержимое списка;
• del — позволяет удалить как отдельный элемент, так и целый срез по индексу.

Читайте также:

Microsoft сделала бесплатным сервис Loop — это аналог Notion c фишками на основе ИИ 24 мар 2023

Новая библиотека от NVIDIA ускоряет литографию процессоров в 40 раз 22 мар 2023

Выпустили нейросеть, которая генерирует видео по текстовому запросу 21 мар 2023

Понравилась статья?

Да

Как удалить элемент из списка в Python

Python является один из самых востребованных языков программирования на рынке. Этой популярностью язык не в последнюю очередь обязан своему богатому функционалу.

Мы расскажем вам о маленькой частичке этого обширного функционала, а именно — о том, как удалить элемент из списка. Списки – это коллекции, существенно упрощающие жизнь программистам, так что знать приемы работы с ними совершенно необходимо.

Итак, в этой статье мы рассмотрим следующие темы:

• Зачем нужны списки?
• Что такое списки?
• Как удалить элементы из списка, используя:
  • remove()
  • pop()
  • del

Приступим 🙂

Зачем нужны списки?

Бывают ситуации, когда нужно обрабатывать разные типы данных одновременно.

Скажем, вам нужно, чтобы у вас был элемент строкового типа, целое число и число с плавающей точкой в одной коллекции. Дефолтные типы данных в других языках, таких как C и C++, такого не допускают. То есть, если вы определяете массив целочисленного типа, вы можете хранить в нем только целые числа. Если ваш массив имеет строковый тип, то и хранить в нем можно только строки.

Вот здесь у Python есть преимущество. Список позволяет хранить элементы разных типов данных как единую упорядоченную коллекцию!

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

От редакции Pythonist. По теме типов данных в Python советуем почитать:

• Изменяемые vs. неизменяемые типы данных в Python
• Проверка типов данных и «утиная» типизация в Python
• Преобразование типов данных в Python 3

Что такое списки?

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

Списки также допускают дублирование членов.

Списки в Python можно сравнить с массивами на других языках программирования. Но есть одно важное отличие. Массивы содержат данные какого-нибудь одного типа, тогда как списки Python могут содержать элементы разных типов. В одном списке могут храниться строки, целые числа, числа с плавающей точкой и т.д.

Списки поддерживают индексацию и срезы, так же, как и строки. Кроме того, списки изменяемы (mutable). Это значит, что они могут быть изменены после создания. В дополнение к этому списки также могут быть вложенными, то есть вы можете включить список в список.

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

Пример:

myList = ["Bran",11,3.14,33,"Stark",22,33,11]
print(myList)
# OUTPUT: [‘Bran’, 11, 3.14, 33, ‘Stark’, 22, 33, 11]

В этом примере мы определили список под названием myList. Как видите, все элементы заключены в квадратные скобки ([]) и разделены запятыми. Этот список представляет собой упорядоченную последовательность, содержащую элементы разных типов данных.

Под индексом 0 у нас есть строковый элемент ‘Bran’. Под индексом 1 – целое число 11. Число с плавающей точкой 3.14 имеет индекс 2.

Таким образом, в одном списке мы можем хранить элементы разных типов.

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

Удаление элемента из списка

Удалить элементы из списка можно тремя способами:

• используя метод remove()
• при помощи метода pop() для объекта списка
• при помощи оператора del

Давайте рассмотрим все три варианта подробнее.

Метод remove() в Python

Метод remove() – один из наиболее часто используемых методов списка для удаления элемента из него.

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

Обратите внимание: если указанный элемент встречается несколько раз, то из списка будет удалено только его первое вхождение. Мы можем рассматривать этот метод как «удаление по bvtyb элемента». Если конкретный удаляемый элемент не найден, возникает ошибка ValueError.

Рассмотрим следующие примеры:

Пример 1:

myList = ["Bran",11,22,33,"Stark",22,33,11]
myList.remove(22)
myList
# OUTPUT: [‘Bran’, 11, 33, ‘Stark’, 22, 33, 11]

В этом примере мы определяем список под названием myList. Обратите внимание, что, как обсуждалось ранее, мы заключаем наши элементы списка в квадратные скобки. Далее мы используем метод remove() для удаления элемента 22 из myList.

При выводе в консоль списка с помощью print() мы видим, что из myList было удалено первое вхождение элемента 22.

Пример 2:

myList.remove(44)
# OUTPUT:
# Traceback (most recent call last):
#   File “<stdin>”, line 1, in 
# ValueError: list.remove(x): x not in list2

В примере 2 мы используем remove() для удаления элемента 44. Но мы знаем, что список myList не имеет целого числа 44. В результате интерпретатор Python выдает ошибку ValueError.

Однако стоит отметить, что remove() — медленный метод, поскольку он предполагает поиск элемента в списке.

Метод pop() в Python

Метод pop() – еще один широко используемый метод списка. Он удаляет элемент из списка и возвращает его.

Метод remove() и метод pop() работают по-разному. Применяя remove(), в качестве аргумента мы указываем сам элемент, который нужно удалить. А при использовании pop() мы указываем индекс нужного элемента. При этом элемент не только удаляется, но и возвращается. Если конкретный удаляемый элемент не найден, возникает IndexError.

Рассмотрим следующие примеры:

Пример 1:

myList = ["Bran", 11, 22, 33, "Stark", 22, 33, 11]
myList.pop(1)
# Output: 11
print(myList)
# OUTPUT: ['Bran', 22, 33, 'Stark', 22, 33, 11]

В этом примере мы опять определяем список под названием myList. Далее мы используем метод pop(), передавая 1 в качестве аргумента. Эта единичка представляет собой не что иное, как индекс удаляемого элемента (помним, что в Python нумерация начинается с 0).

Как видно из вывода, pop() удаляет элемент и выводит его в консоль. В данном случае элемент с индексом 1 является целым числом 11.

Когда мы выводим список myList после вызова pop(),мы видим, что в списке больше нет целого числа 11, которое ранее было на позиции 1.

Пример 2:

myList.pop(8)
# OUTPUT:
# Traceback (most recent call last):
#    File “<stdin>”, line 1, in 
# IndexError: pop index out of range

В примере 2 мы используем pop() для удаления элемента с индексом 8. Но поскольку на этой позиции нет элемента, интерпретатор Python выдает ошибку IndexError, как показано в выходных данных.

Здесь стоит сказать, что pop() — быстрый метод, поскольку он удаляет элемент по индексу и не производит поиск.

Оператор Python del

Этот оператор похож на метод pop() с одним важным отличием. Оператор del удаляет элемент из списка по индексу, но удаленный элемент не возвращается, как это происходит в методе pop(). По сути, этот оператор принимает индекс удаляемого элемента в качестве аргумента и удаляет элемент по этому индексу. Всё просто?.

Оператор del также поддерживает удаление ряда элементов из списка.

Обратите внимание: этот оператор, как и метод pop(), вызывает ошибку IndexError, когда указанный индекс выходит за пределы допустимого диапазона.

Рассмотрим примеры.

Пример 1:

myList = ["Bran", 11, 22, 33, "Stark", 22, 33, 11]
del myList[2]
myList
# OUTPUT: [‘Bran’, 11, 33, ‘Stark’, 22, 33, 11]

В этом примере мы в который раз определяем список под названием myList. И используем оператор del для удаления элемента с индексом 2. При удалении элемента он не возвращается (не выводится в консоль).

Распечатав myList, мы видим, что целое число 22, которое стояло под индексом 2, удалено.

Пример 2:

del myList[1:4]
myList
# OUTPUT:  [‘Bran’, 22, 33, 11]

В примере 2 мы используем оператор del для удаления диапазона элементов: от индекса 1 до индекса 4 (но не включая 4). Впоследствии, выведя в консоль myList, можно увидеть, что элементы, которые были на позициях 1, 2 и 3, удалены.

Пример 3:

del myList[7]
# OUTPUT:
# Traceback (most recent call last):
# File “”, line 1, in 
# IndexError: list assignment index out of range

В примере 3, когда мы используем оператор del для удаления элемента с индексом 7 (которого не существует), интерпретатор Python выдает ошибку ValueError.

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

Подведем итоги:

• метод remove() удаляет первое совпадающее с аргументом значение
• метод pop() удаляет элемент по указанному индексу и возвращает его
• оператор del просто удаляет элемент по указанному индексу (или диапазону индексов).

Самые популярные вопросы, связанные с удалением элементов из списка

Как удалить определенный элемент из списка в Python?

Метод remove() удаляет первое вхождение элемента, переданного в метод в качестве аргумента. Метод pop() удаляет элемент по заданному индексу, а также возвращает удаленный элемент. Для удаления элемента или диапазона элементов из списка также можно использовать ключевое слово del.

Как удалить первый элемент из списка в Python?

Мы можем сделать это с помощью следующих четырех вариантов:

• Самый простой подход – использовать метод списка pop([i]), который удаляет и возвращает элемент, присутствующий в указанной позиции в списке.
• Это еще один подход, при котором метод remove(x) удаляет первый элемент из списка, который соответствует указанному значению.
• Чтобы удалить первый элемент, мы можем использовать срезы, получив подсписок, содержащий все элементы списка, кроме первого.
• Используя оператор del, мы можем удалить элемент из списка, используя его индекс. Отличие от метода pop() в том, что он не возвращает удаленный элемент.

Как удалить последний элемент списка в Python?

Метод pop() может использоваться для удаления и возврата последнего значения из списка или заданного значения индекса. Если индекс не указан, последний элемент выскакивает и удаляется автоматически.

Как удалить несколько элементов из списка в Python?

Для этой цели можно использовать ключевое слово del. С его помощью можно удалить несколько элементов из списка (указав диапазон индексов).

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

Больше 50 задач по Python c решением и дискуссией между подписчиками можно посмотреть тут

Перевод статьи «Python Remove List: How to remove element from Lists».

Удаление объектов из массивов в PowerShell

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

Когда я впервые ответил на этот вопрос в about_Arrays, я мало что знал о предмете и использовал (очень хороший) ответ, который мне дала команда. Но этот ответ был неполным, и хотя на эту тему есть много хороших сообщений, ни одно из них не охватывает весь спектр подводных камней.

[Обязательно начните с about_Arrays. Я предполагаю, что вы его прочитали и не будете повторять основы работы с массивами, которые там описаны.]

Почему удаление сложно?

Удаление объектов из массивов должно быть простым, но тип коллекции по умолчанию в Windows PowerShell, массив объектов (System. Object[]), имеет фиксированный размер. Вы можете изменять объекты в массиве, но не можете добавлять или удалять их, потому что это изменит размер массива.

Давайте посмотрим на проблему. Я создам массив с именем $letters и сохраните несколько букв в массиве.

 $letters = "a", "b", "c", "d" 

Теперь я попытаюсь удалить букву «c» из массива.

 $letters = $letters - "c" 

Не удалось вызвать метод, так как [System.Object[]] не содержит метод с именем op_Subtraction.
В строке:1 символ:2
+  $letters = $letters – “c”
+  ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
+ Информация о категории          : InvalidOperation: (op_Subtraction:String) [], RuntimeException
+ FullyQualifiedErrorId : MethodNotFound

Это не сработало, потому что массивы объектов [System.Object[]) не имеют метода вычитания (op_Subtraction). Давайте найдем методы, которые System. Object[] поддерживает.

Как правило, чтобы получить тип, методы и свойства объекта, вы передаете их командлету Get-Member . Но когда вы передаете коллекцию объектов Get-Member, Get-Member получает элементы объектов в коллекции. Чтобы получить элементы коллекции (а не содержащиеся в ней объекты), используйте ее Параметр InputObject .

Эта команда показывает, что массивы объектов, подобные массивам в переменной $letters, имеют метод Remove . Давайте попробуем метод Удалить .

Удалить не удалось, так как массивы объектов имеют фиксированный размер.

Здесь новички застревают, и даже опытные пользователи обращаются за помощью в Google, Facebook или на форум PowerShell.

Создать новый массив

Одним из способов удаления объекта из массива фиксированного размера является создание нового массива, включающего только выбранные объекты из исходного массива. В этой команде мы используем цикл ForEach, просматривающий каждую букву в массиве $letters. Мы добавляем все объекты в $letters в массив $newLetters, кроме «c». Чтобы добавить объекты в новый массив, используйте операторы + или +=; утверждения эквивалентны.

 $newLetters = @()
    foreach ($буква в $буквах)
    {
        если ($буква -ne "с")
        {
            #$newLetters = $newLetters + $letter
            $newLetters = $newLetters += $letter
        }
    } 

PS C:\> $newLetters
a
b
d

Интересно, что когда мы используем операторы + или +=, Windows PowerShell фактически каждый раз создает новый массив в фоновом режиме, потому что вы можете т изменить размер массива. К сожалению, оператора —= нет. Кроме того, в этом очень простом примере проще использовать командлет Where-Object для фильтрации «с», но мы можем предположить, что вы используете массив для более сложной задачи.

 $newLetters = $letters | Где-Объект { $_ –ne "c" } 

Вы также можете использовать нотацию индекса массива, чтобы исключить элементы из нового массива. В этой команде мы добавляем элементы с индексами 0, 1 и 3 из $letters в массив $newLetters, но исключаем элемент с индексом 2.

 $newLetters = $letters[0, 1, 3] 

Вы можете повторно использовать имя переменной $letters, но вы все равно создаете новый массив $letters, независимый от исходного.

 $буквы = $буквы[0, 1, 3] 

Использовать ArrayList

Мое любимое решение проблемы «коллекция была фиксированного размера» — создать ArrayList (вместо объекта System.Collections.ArrayList по умолчанию) Система.Объект[]). ArrayList ведут себя как массивы, но в отличие от массивов объекты ArrayList не имеют фиксированного размера.

Чтобы создать список массивов, приведите переменную:

 [System.Collections.ArrayList]$caps = "A", "B", "C", "D" 

Или приведите объекты. (Не забудьте круглые скобки.)

 $caps = [System.Collections.ArrayList]("A", "B", "C", "D") 

Используйте параметр InputObject командлета Get-Member чтобы получить свойства и методы списка массивов. Существует метод Remove для объектов ArrayList, и он работает.

Удаление объектов из списка массивов

Как показано в справке, Удалить Метод ArrayList удаляет первый экземпляр элемента из списка массивов. Он возвращает Void , что ничего не значит. Метод Remove изменяет исходный список массивов. Он не возвращает новый список массивов.

PS C:\ps-test> $caps
A
B
D

Чтобы удалить несколько экземпляров объекта, используйте цикл 8 While 90.

 [System.Collections.ArrayList]$caps = "A", "B", "C", "D", "C", "E"
    в то время как ($caps-содержит "C") {
        $caps.Удалить("С")
    } 

Вы также можете использовать цикл ForEach для списка массивов, но вы не можете удалять объекты из списка массивов, которые вы просматриваете с помощью ForEach. В фоновом режиме ForEach использует позиционные индексы, и положение каждого объекта в списке массивов (или любой коллекции) изменяется при удалении объекта.

В следующем примере код использует цикл ForEach для удаления процессов svchost из массива списка процессов.

 [System.Collections.ArrayList]$p = Get-Process
    foreach ($процесс в $p)
    {
        если ($process.Name -eq "svchost")
        {
            $p.Удалить($процесс)
        }
    } 

Коллекция изменена; операция перечисления может не выполняться.
At line:1 char:10
+ foreach ($process in $p)
+ ~~~~
+ CategoryInfo          : OperationStopped: (:) [], InvalidOperationException
+ FullyQualifiedErrorId : System.InvalidOperationException

Вместо

 , создайте массив из процессов svchost ($s) и используйте цикл ForEach для удаления каждого процесса svchost из $p. Поскольку ForEach просматривает массив $s, вы можете использовать его для удаления объектов из $p.

   [System.Collections.ArrayList]$p = Get-Process
    $s = Get-Process | где ProcessName -eq "svchost"
    foreach ($svchost в $s)
    {
        $p.Удалить($svchost)
    }
 

RemoveAt: удаление объектов по индексу

Для удаления объектов можно также использовать метод RemoveAt в ArrayLists. RemoveAt принимает индекс объекта, который вы хотите удалить. В этом примере мы будем использовать значение 2, которое является индексом «C».

PS C:\ps-test> $caps
A
B
D
E

В таком маленьком списке массивов найти индекс «C» было легко, но имеют больший список массивов, вы можете использовать метод IndexOf , чтобы найти индекс, а затем использовать метод RemoveAt , чтобы удалить объект по этому индексу. Вы можете вызывать методы в двух отдельных командах или в одной команде.

 $index = $caps. IndexOf("C")
    $caps.RemoveAt($index)
 

-или-

 $caps.RemoveAt($caps.IndexOf("C"))
 

Чтобы использовать метод RemoveAt для удаления нескольких объектов, используйте цикл For . Цикл For хорошо подходит для этой задачи, поскольку он использует индексы.

Но будьте осторожны! Когда вы удаляете объект из коллекции, вы изменяете индексы каждого последующего объекта в коллекции. Например, в следующем списке массивов мы хотим удалить объекты «C» с индексами 2, 3 и 4. Но после того, как мы удалим объект «C» с индексом 2, индекс второго объекта «C» изменится. с 3 на 2. Если мы переместим индекс с 2 на 3, мы пропустим букву «С», которая сейчас находится в индексе 2.

Для компенсации всякий раз, когда вы удаляете объект, уменьшайте индекс на 1. Вы можете использовать любое обозначение, чтобы уменьшить его значение на единицу:  $i = $i – 1, $i –= 1 или $i– .

 [System.Collections. ArrayList]$caps = "A", "B", "C", "D", "C", "E"
    для ($i = 0; $i -lt $caps.count; $i++)
    {
        если ($caps[$i] -eq "C")
        {
            $caps.RemoveAt($i)
            $i--
        }
    } 

Здесь используется тот же метод, что и для удаления процессов svchost из списка массивов $p.

 [System.Collections.ArrayList]$p = Get-Process
    for ($i = 0; $i -lt $p.Count; $i++)
    {
        если ($p[$i].Name -eq "svchost")
        {
            $p.RemoveAt($i)
            $i--
        }
    } 

Сводка

В большинстве скриптов вы не работаете с массивами напрямую. Вместо этого вы используете Where-Object для создания новой коллекции, включающей только те элементы, которые вам нужны. Но если вам нужно управлять массивом напрямую, вы можете добавлять и удалять объекты.

Джун Блендер — евангелист технологий в SAPIEN Technologies, Inc. Вы можете связаться с ней по адресу [email protected] или подписаться на нее в Твиттере по адресу @juneb_get_help.

Удаление элементов из массива в документе — Elasticsearch

Jayant_Kerai (Джайант Керай) 21 декабря 2012 г., 15:54

1

Привет, я новичок в ES и оцениваю его для своих поисковых нужд

http://www.elasticsearch.org/guide/reference/api/update.html

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

curl -XPOST ‘localhost:9200/test/type1/1/_update’ -d ‘{

 "сценарий" : "ctx._source.tags += тег",
"параметры": {
    "тег": "синий"
}
 

}’
Приведенное выше должно добавить новый элемент в список.

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

curl -XPOST ‘localhost:9200/test/type1/1/_update’ -d ‘{

 "сценарий" : "ctx. _source.tags -= тег",
"параметры": {
    "тег": "синий"
}
 

}’

Помимо чтения всех записей элементов и удаления той, которую я хочу
удалить, и обновления всего элемента с помощью конечной точки _update.

—

Игорь Мотов (Игорь Мотов) 22 декабря 2012 г., 1:48

2

Теги в вашем примере — это ArrayListhttp://docs.oracle.com/javase/6/docs/api/java/util/ArrayList.html#remove(java.lang.Object).
Итак, вы можете сделать что-то вроде этого:

curl -XPOST ‘localhost:9200/test/type1/1/_update’ -d ‘{
«script» : «ctx._source.tags.remove(tag)»,
«params» : {
«tag» : «blue»
}
}’

В пятницу, 21 декабря 2012 г., 10:54:09 UTC-5, jkerai написал:

Привет, я очень новичок в ES и оцениваю его для своих поисковых нужд

http://www. elasticsearch.org/guide/reference/api/update.html

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

curl -XPOST ‘localhost:9200/test/type1/1/_update’ -d ‘{

 "скрипт": "ctx._source.tags += тег",
"параметры": {
    "тег": "синий"
}
 

}’
Приведенное выше должно добавить новый элемент в список.

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

curl -XPOST ‘localhost:9200/test/type1/1/_update’ -d ‘{

 "скрипт" : "ctx._source.tags -= тег",
"параметры": {
    "тег": "синий"
}
 

}’

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

—

Джаянт_Керай (Джайант Керай) 22 декабря 2012 г. , 12:25

3

Отлично. Это работает как сон.
И я благодарен вам за исправление моей терминологии. Спасибо Игорь!

Просто чтобы уточнить, мой фактический пример немного отличается от того, что я опубликовал
, но ваше решение работает.

Мой пример:

curl -XPUT ‘http://localhost:9200/myindex/mytype/12’ -d ‘{
«Name»: «Entity 1»,
«Description»: «Jay Desc 1»,
«Объекты»: [
{
«CategoryID»: «1»,
«CategoryName»: «Офис»,
«EntityID»: «1»,
«EntityName»: «UK»
},
{
«CategoryID»: «1»,
«CategoryName»: «Office»,
«EntityID»: «2»,
«EntityName»: «Южная Африка»
},
{
«CategoryID»: «2»,
«CategoryName»: «Team»,
«EntityID»: «3»,
«EntityName»: «Accounts»
} ,
{
«CategoryID»: «2»,
«CategoryName»: «Team»,
«EntityID»: «4»,
«EntityName»: «Разработка»
}
]
}’

curl -XPOST ‘http://локальный:9200/myindex/mytype/12/_update’ -d
‘{
«сценарий» : «ctx.