В чем разница между использованием в delete
оператор на элементе массива в отличие от использования в Array.splice
метод ?
Например:
myArray = ['a', 'b', 'c', 'd'];
delete myArray[1];
// or
myArray.splice (1, 1);
Зачем даже метод сращивания, если я могу удалять элементы массива, как я могу с объектами?
javascript
arrays
array-splice
delete-operator
lYriCAlsSH
источник
источник
.splice
в циклах, взгляните на этот вопрос: Удалить из массива в JavaScript .delete
иArray.prototype.splice
.Ответы:
delete
удалит свойство объекта, но не будет переиндексировать массив или обновит его длину. Это заставляет это казаться, как будто это не определено:Обратите внимание , что это не на самом деле устанавливается на значение
undefined
, а свойство удаляется из массива, что делает его казаться неопределенным. Инструменты разработчика Chrome проясняют это различие, печатаяempty
при регистрации массива.myArray.splice(start, deleteCount)
фактически удаляет элемент, переиндексирует массив и изменяет его длину.источник
delete
действительно удалить элемент, но не индексировать массив или обновить его длину (которая уже подразумеваемой бывший , так как длина всегда самый высокий показатель + 1).delete myArray[0]
синтаксис, говорящий « Ожидается оператор и вместо этого он видит« удалить ». »splice
Рекомендуется использовать.delete myArray[0]
иmyArray[0] = undefined
. В первом случае свойство полностью удаляется из объекта массива. Во втором случае свойство остается со значениемundefined
.empty
вместо того,undefined
чтобы улучшить различие между фактически удаленным (или неинициализированным) элементом массива и элементом, который имеет реальное значениеundefined
. Обратите внимание, что когда я говорю это, я имею в виду, что он отображается только какempty
и не относится к реальному названному значениюempty
(которое не существует).Метод Array.remove ()
Джон Резиг , создатель jQuery, создал очень удобный
Array.remove
метод, который я всегда использую в своих проектах.и вот несколько примеров того, как это можно использовать:
Сайт Джона
источник
[1,2,3].slice('1'); // =[2,3]
), поэтому безопаснее изменить его наvar rest = this.slice(parseInt(to || from) + 1 || this.length);
this.push.apply(this, rest)
, а затем возвращает возвращенное значениеfor(var i in array)
циклом. Я удалил его и использовал вместо него сращивание.Поскольку delete удаляет только объект из элемента в массиве, длина массива не изменится. Splice удаляет объект и сокращает массив.
Следующий код будет отображать «a», «b», «undefined», «d»
Принимая во внимание, что это будет отображать «a», «b», «d»
источник
myArray.splice(2,1)
Я наткнулся на этот вопрос, пытаясь понять, как удалить каждое вхождение элемента из массива. Вот сравнение из
splice
иdelete
для удаления каждого'c'
изitems
массива.источник
Из Базовой Справки по JavaScript 1.5> Операторы> Специальные операторы> Оператор удаления :
источник
splice
будет работать с числовыми индексами.тогда как
delete
могут быть использованы против других видов индексов ..пример:
источник
Вероятно, стоит упомянуть, что сплайс работает только с массивами. (На свойства объекта нельзя полагаться, чтобы следовать последовательному порядку.)
Чтобы удалить пару ключ-значение из объекта, фактически удалите то, что вам нужно:
источник
удалить против сращивания
когда вы удаляете элемент из массива
когда ты склеиваешь
в случае удаления от элемента удаляется , но индекс остается пустым
в то время как в случае сращивания элемент удаляется, а индекс остальных элементов соответственно уменьшается
источник
Как уже много раз говорилось выше, использование
splice()
кажется идеальным. Документация в Mozilla:источник
delete действует как нереальная ситуация, он просто удаляет элемент, но длина массива остается неизменной:
пример из терминала терминала:
Вот функция для удаления элемента массива по индексу, используя slice () , в качестве первого аргумента она принимает arr, а в качестве второго аргумента - индекс члена, который вы хотите удалить. Как видите, он на самом деле удаляет член массива и уменьшает длину массива на 1
Функция, приведенная выше, заключается в получении всех элементов до индекса и всех членов после индекса, объединяет их вместе и возвращает результат.
Вот пример использования функции выше в качестве модуля узла, где будет полезен терминал:
обратите внимание, что это не будет работать с одним массивом, содержащим дубликаты, потому что indexOf ("c") просто получит первое вхождение, и только склеит и удалит первый найденный символ "c".
источник
Если вы хотите выполнить итерацию большого массива и выборочно удалять элементы, было бы дорого вызывать splice () для каждого удаления, так как splice () должен будет каждый раз переиндексировать последующие элементы. Поскольку массивы являются ассоциативными в Javascript, было бы более эффективно удалить отдельные элементы, а затем повторно индексировать массив впоследствии.
Вы можете сделать это, создав новый массив. например
Но я не думаю, что вы можете изменить значения ключей в исходном массиве, что было бы более эффективно - похоже, вам, возможно, придется создать новый массив.
Обратите внимание, что вам не нужно проверять «неопределенные» записи, так как они на самом деле не существуют и цикл for не возвращает их. Это артефакт печати массива, который отображает их как неопределенные. Они, кажется, не существуют в памяти.
Было бы хорошо, если бы вы могли использовать что-то вроде slice (), которое было бы быстрее, но не переиндексирует. Кто-нибудь знает лучший способ?
На самом деле, вы, вероятно, можете сделать это на месте следующим образом, что, вероятно, является более эффективным, с точки зрения производительности:
источник
Вы можете использовать что-то вроде этого
источник
slice
если бы вы пришли из функционального фона (хотя, вероятно, менее эффективно).Почему не просто фильтр? Я думаю, что это самый понятный способ рассмотреть массивы в JS.
источник
delete
илиslice
для меня.Разницу можно увидеть, зарегистрировав длину каждого массива после применения
delete
оператора иsplice()
метода. Например:оператор удаления
delete
Оператор удаляет элемент из массива, но «заполнитель» элемента по- прежнему существует.oak
был удален, но все еще занимает место в массиве. Из-за этого длина массива остается 5.метод splice ()
splice()
Метод полностью удаляет целевое значение и в «заполнитель» , а также.oak
был удален, а также пространство, которое он занимал в массиве. Длина массива теперь 4.источник
пример:
банан удаляется и длина массива = 2
источник
Это разные вещи, которые имеют разные цели.
splice
является специфичным для массива и, когда используется для удаления, удаляет записи из массива и перемещает все предыдущие записи вверх, чтобы заполнить пробел. (Он также может быть использован для вставки записей, или обоих одновременно.)splice
Изменитlength
массив (при условии, что это не вызов no-op:)theArray.splice(x, 0)
.delete
не зависит от массива; он предназначен для использования на объектах: он удаляет свойство (пара ключ / значение) из объекта, на котором вы его используете. Это применимо только к массивам, потому что стандартные (например, нетипизированные) массивы в JavaScript на самом деле вообще не являются массивами *, это объекты со специальной обработкой для определенных свойств, таких как те, чьи имена являются «индексами массива» (которые являются определяется как строковые имена "... чье числовое значениеi
находится в диапазоне+0 ≤ i < 2^32-1
") иlength
. Когда вы используетеdelete
для удаления записи массива, все, что он делает, это удаляет запись; он не перемещает другие записи, следующие за ним, чтобы заполнить пробел, и поэтому массив становится "разреженным" (некоторые записи полностью отсутствуют). Это не влияет наlength
.В паре текущих ответов на этот вопрос неправильно
delete
указано, что при использовании «устанавливает запись вundefined
». Это не правильно. Он полностью удаляет запись (свойство), оставляя пробел.Давайте использовать некоторый код, чтобы проиллюстрировать различия:
* (это пост в моем анемичном небольшом блоге)
источник
В настоящее время есть два способа сделать это
используя splice ()
arrayObject.splice(index, 1);
используя удалить
delete arrayObject[index];
Но я всегда предлагаю использовать соединение для объектов массива и удалять для атрибутов объектов, потому что удаление не обновляет длину массива.
источник
Хорошо, представьте, что у нас есть этот массив ниже:
Давайте сначала удалим:
и вот результат:
пустой! и давайте получим это:
Значит, означает просто удаленное значение, и оно не определено сейчас, поэтому длина такая же, и она вернет true ...
Давайте сбросим наш массив и на этот раз сделаем это со сращиванием:
и вот результат на этот раз:
Как видите, длина массива изменилась и теперь
arr[1]
равна 3 ...Также это вернет удаленный элемент в массиве, который
[3]
в этом случае ...источник
Другие уже правильно по сравнению
delete
сsplice
.Другое интересное сравнение -
delete
сравнениеundefined
: удаленный элемент массива использует меньше памяти, чем тот, который только что установленundefined
;Например, этот код не будет завершен:
Это выдает эту ошибку:
Итак, как видите, на
undefined
самом деле занимает кучу памяти.Однако, если вы также
delete
используете ary-item (вместо того, чтобы просто установить егоundefined
), код будет медленно завершаться:Это крайние примеры, но они указывают на
delete
то, что я нигде не видел упоминаний.источник
Если у вас небольшой массив, вы можете использовать
filter
:источник
Самый простой способ, вероятно,
Надеюсь это поможет. Ссылка: https://lodash.com/docs#compact
источник
compact
... не нужно Лодаш. ПопробуйтеmyArray.filter(function(n){return n;})
Для тех, кто хочет использовать Lodash, можно использовать:
myArray = _.without(myArray, itemToRemove)
Или как я использую в Angular2
источник
Удалить элемент из последнего
Удалить элемент из первого
Удалить из середины
Удалить один элемент из последнего
Удалить используя индексный номер массива
источник
Если нужный элемент находится посередине (скажем, мы хотим удалить 'c', индекс которого равен 1), вы можете использовать:
источник
IndexOf
принимает также ссылочный тип. Предположим следующий сценарий:Иначе:
источник
// результат: myArray = ['b', 'c', 'd'];
источник