Js удалить переменную из памяти
Обновлено: 07.07.2024
Каков наилучший способ удалить свойство, regex чтобы закончить с новым myObject следующим образом?
@EscapeNetscape Это вопрос о поведении, поэтому тест отображает неправильную картину. Конечно, delete это будет самый медленный вариант, поскольку это фактическая операция, а не две другие, которые являются просто назначениями. Но суть дела в том , что назначение свойства null или на undefined самом деле не удалить свойство из объекта, но вместо этого устанавливает , что собственность на равную определенную величину постоянной. (Ниже приведены причины, по которым это существенно отличается.) Результатом одного из наблюдений по ссылке «понимание удаления» выше является то, что, поскольку вы не можете обязательно удалить переменную, а только свойства объекта, вы, следовательно, не можете удалить свойство объекта «по ссылке» - var value = obj [ 'проп']; удалить значение // не работает Так что на самом деле это не удалить? Это просто становится неопределенным, но ключ все еще существует? Я что-то пропустил? @ChristopherPfohl работает на меня. Как я уже сказал, на самом деле это довольно глубоко, поэтому подвести итог немного сложно. Основной ответ в ответе выше достаточен почти для всех случаев, в блоге рассматриваются еще некоторые крайние случаи и причины, по которым эти случаи существуют.Объекты в JavaScript могут рассматриваться как карты между ключами и значениями. delete Оператор используется , чтобы удалить эти ключи, более широко известные как свойства объекта, по одному за раз.
delete Оператор непосредственно не свободной памяти, и оно отличается от простого присвоения значения null или undefined к свойству, в том , что свойство само по себе удаляется из объекта. Обратите внимание, что если значением удаленного свойства был ссылочный тип (объект), а другая часть вашей программы по-прежнему содержит ссылку на этот объект, то этот объект, разумеется, не будет собирать мусор, пока все ссылки на него не будут иметь исчез.
delete будет работать только со свойствами, дескриптор которых помечает их как настраиваемые.
свойство, назначенное неопределенному, все еще является свойством объекта, поэтому оно не будет удалено GC, если вы не прочитали последний абзац. Я был неправ, касаясь темы GC здесь. Оба метода имеют одинаковый результат для GC: они удаляют значение, связанное с ключом. Если это значение было последней ссылкой на какой-либо другой объект, этот объект был бы очищен. свойство, назначенное неопределенному, все еще является свойством объекта, поэтому оно не будет удалено GC . GC ничего не управляет свойствами. Он собирает и удаляет значения. Пока ничто больше не ссылается на значение (объект, строку и т. Д.), GC действительно удаляет его из памяти. Кстати, это двойная проблема, чтобы проверить, существует ли свойство в объекте Javascript. Использование в операторе надежно, но медленно. Проверьте, не является ли свойство неопределенным, «это не правильный ответ», но это намного быстрее. чек Этот ответ по-прежнему актуален? jsperf в настоящее время не работает, но этот тест, похоже, указывает на то, что разница в скорости составляет всего 25%, что нигде не близко к «100 раз медленнее» в этом ответе.
Это работает в Firefox и Internet Explorer, и я думаю, что это работает во всех остальных.
delete Оператор используется для удаления свойств из объектов.
delete в JavaScript функция отличается от функции ключевого слова в C и C ++: он не освобождает память напрямую. Вместо этого его единственной целью является удаление свойств из объектов.
Для массивов удаление свойства, соответствующего индексу, создает разреженный массив (т. Е. Массив с «дырой» в нем). Большинство браузеров представляют эти отсутствующие индексы как «пустые».
Обратите внимание, что delete не перемещается array[3] в array[2] .
Различные встроенные функции в JavaScript по-разному обрабатывают разреженные массивы.
for. in пропустит пустой индекс полностью.
Традиционный for цикл возвращает undefined значение в индексе.
Любой использующий метод Symbol.iterator вернёт undefined значение в индексе.
forEach , map И reduce просто пропустить отсутствующий индекс.
Этот подход не изменяет исходный объект, на который можно ссылаться в другом месте. Это может или не может быть проблемой, в зависимости от того, как она используется, но об этом следует помнить. @wulftone nope, который разбивает массив и ничего не делает для удаления значения. Я действительно думаю, что лучший способ удаления из массива, в котором необходимо удалить определенные значения, - это использовать delete и создать функцию «Сборка мусора» для ее очистки. Я не вижу splice в вашем редакторе, но remove должно быть Array.prototype.remove = function(index) < this.splice(index, 1); >; Эта статья полна быка 1. Это не касается вопроса! 2. Это примерное злоупотребление языком и жалоба на то, что «это не работает!» 3. Не обвиняйте оператор удаления JavaScript в характерной ошибке Крокфорда, заключающейся в установке значения NULL для индекса пустого массива. Он не понимает значения нуля - он думает, что это ошибка. Ошибка является его собственной и единственной - в удаленном значении данного индекса массива нет нуля. В массиве нет «дыры» - это пустой индекс. Абсолютно законно и ожидаемо.Старый вопрос, современный ответ. Используя деструктуризацию объектов, функцию ECMAScript 6 , это так просто, как:
Или с образцом вопросов:
Редактировать:
Чтобы переназначить одну и ту же переменную, используйте let :
Возможно, потому что цель состоит в том, чтобы удалить свойство из объекта, а не создать новое без свойства . хотя, ваше решение - мое любимое, так как я предпочитаю неизменный способ. В вопросе говорилось «закончить с новым myObject». Добавление подчеркивания для удаления свойства засорять ваш проект :) Вместо того , чтобы он доступен , как regex вы могли бы также назначить его на какой - либо другой переменной, например _ , то , что используется в таких языках , как Go отбрасывать результат: const < regex: _, . newObject >= myObject; . @PranayKumar Я надеялся, что этот синтаксис сработает; const < Js удалить переменную из памяти, . newObject >= myObject; но это не так, поэтому я не думаю, что это возможно с разрушением. С объектами freeze() 'd и seal() ' d вы не можете просто delete создать свойство. Так что это отличная альтернатива. Хотя в большинстве случаев, вероятно, в любом случае не имеет смысла удалять свойство из замороженного / запечатанного объекта, учитывая, что весь смысл в том, чтобы дать определенные гарантии относительно ваших структур данных, которые этот шаблон будет подрывать. Для тех случаев, когда вам необходимо неразрушающим образом дублировать объект, но без некоторых его свойств, это идеальноДля тех, кто нуждается в этом .
Чтобы завершить ответ @Koen в этой теме, на случай, если вы захотите удалить динамическую переменную с использованием синтаксиса распространения, вы можете сделать это так:
* foo будет новой переменной со значением a ( равным 1).
РАСШИРЕННЫЙ ОТВЕТ 😇
Существует несколько распространенных способов удаления свойства из объекта.
У каждого есть свои плюсы и минусы ( посмотрите сравнение производительности ):
Delete Operator
Readable и short, однако, это может быть не лучшим выбором, если вы работаете с большим количеством объектов, так как его производительность не оптимизирована.
Переназначение
Более чем в 2 раза быстрее, чем delete , однако свойствонеудаляется и может быть повторено.
Spread Operator
Этот ES6 оператор позволяет нам возвращать совершенно новый объект, исключая любые свойства, не изменяя существующий объект. Недостатком является то, что он имеет худшую производительность из вышеперечисленных и не рекомендуется использовать, когда вам нужно удалить много свойств одновременно.
Другой альтернативой является использование библиотеки Underscore.js .
Обратите внимание , что _.pick() и _.omit() как вернуть копию объекта и не непосредственно изменять исходный объект. Присвоение результата исходному объекту должно помочь (не показано).
Ссылка: ссылка _.pick (объект, * ключи)
Возвращает копию объекта, отфильтрованного, чтобы иметь только значения для ключей из белого списка (или массива допустимых ключей).
Ссылка: ссылка _.omit (объект, * ключи)
Возвращает копию объекта, отфильтрованного для исключения ключей из черного списка (или массива ключей).
Для массивов _.filter() и _.reject() может быть использован аналогичным образом.
Имейте в виду, что если ключи вашего объекта являются числами, вам может понадобиться _.omit(collection, key.toString())100 раз медленнее, чем delete obj[prop] в
100 раз медленнее, чем obj[prop] = undefined .
Термин, который вы использовали в заголовке вашего вопроса Remove a property from a JavaScript object , может интерпретироваться по-разному. Один из них - удалить всю память и список ключей объекта, а другой - просто удалить его из вашего объекта. Как уже упоминалось в некоторых других ответах, delete ключевое слово является основной частью. Допустим, у вас есть ваш объект, как:
Если вы делаете:
Вы можете удалить этот конкретный ключ из ваших ключей объекта, например:
Тогда ключ вашего объекта Object.keys(myJSONObject) будет:
Но дело в том, что если вы заботитесь о памяти и хотите, чтобы весь объект был удален из памяти, рекомендуется установить его в null перед удалением ключа:
Другим важным моментом здесь является осторожность в отношении других ссылок на тот же объект. Например, если вы создаете переменную вроде:
Или добавьте его как новый указатель на другой объект, например:
Тогда, даже если вы удалите его из своего объекта myJSONObject , этот конкретный объект не будет удален из памяти, поскольку regex переменная myOtherObject["regex"] все еще имеет свои значения. Тогда как мы можем точно удалить объект из памяти?
Ответ будет состоять в том, чтобы удалить все ссылки, которые вы имеете в своем коде, указывающие на этот самый объект, а также не использовать var операторы для создания новых ссылок на этот объект . Этот последний пункт, касающийся var операторов, является одной из наиболее важных проблем, с которыми мы обычно сталкиваемся, поскольку использование var операторов будет препятствовать удалению созданного объекта.
Это означает, что в этом случае вы не сможете удалить этот объект, потому что вы создали regex переменную с помощью var оператора, и если вы это сделаете:
Результат будет false , что означает, что ваш оператор удаления не был выполнен, как вы ожидали. Но если вы ранее не создавали эту переменную и использовали только myOtherObject["regex"] свою последнюю существующую ссылку, вы могли бы сделать это, просто удалив ее следующим образом:
Другими словами, объект JavaScript уничтожается, как только в вашем коде не остается ссылки на этот объект.
Here is my javascript code, I want to delete the variable code so that it has value undefined.
Here I'm doing the check:
Why does this program not remove the code variable so it has the value undefined?
10 Answers 10
Delete does not delete a variable.
21.2k 6 6 gold badges 41 41 silver badges 71 71 bronze badgesThe delete operator removes a property from an object.
Delete a variable in JavaScript:
Summary:
The reason you are having trouble deleting your variable in JavaScript is because JavaScript won't let you. You can't delete anything created by the var command unless we pull a rabbit out our bag of tricks.
The delete command is only for object's properties which were not created with var.
JavaScript will let you delete a variable created with var under the following conditions:
You are using a javascript interpreter or commandline.
You are using eval and you create and delete your var inside there.
Demo on terminal, Use the delete boo or delete(boo) command. A demo with js command line terminal let you delete a variable.
If you MUST set your variable to undefined in JavaScript, you have one option:
Demo in javascript page: put this in myjs.html :
Open myjs.html with a browser, it prints this:
Warning When you set your variable to undefined you are assigning a variable to another variable. If someone poisons the well by running undefined = 'gotcha!' , then whenever you set your variable to undefined, it becomes: "gotcha!".
How should we check if a variable has no value?
Use null instead of undefined like this:
If you are not using strict, you can delete variables created like this:
Удаляет объект, свойство объекта или элемент массива по указанному индексу.
Значением expression должна являтся ссылка на удаляемое свойство, например:
Если expression не приводится к свойству, оператор delete не делает ничего.
При успешном выполнении оператор delete удаляет свойство из объекта.
При этом delete не меняет прототип объекта, даже если там есть свойство, совпадающее по названию с удаляемым.
Некоторые свойства объектов не могут быть удалены. В спецификации такие свойства обозначены флагом DontDelete .
Можно удалить переменные, объявленные глобально без var , но нельзя - объявленные через var .
Оператор delete возвращает false только если свойство существует, но не может быть удалено, и true - в любых других случаях.
Вы не можете удалить свойство из объекта, которое он унаследовал от прототипа (хотя вы можете удалить его напрямую из прототипа).
При удалении элементов массива, его длина не меняется. Даже если вы удалите последний элемент: delete a[a.length-1] - его длина останется той же.
При этом элемент исчезнет из массива:
Если вы хотите, чтобы элемент остался в массиве, но стал undefined - просто приравняйте его к undefined :
См. также
А можно ли как-то удалить класс, например
function Foo()<>
delete Foo;
Почему-то использование window.Foo = null; не очищает память.
в javascripte нет классов! Это не класс а объект, а конкретнее - функция-конструктор. Память очищает сборщик мусора, который решает удалять ли данные по каким-то своим магическим алгоритмам.
Как написано в коменте выше, это не класс, а функция. Функцию можно удалить так же, как и любой другой объект, если создавать ее динамически и присваивать в глобальную переменную. Вот так, например, можно:
Foo = function()<>;
delete Foo;
Написаный вами вариант эквивалентен следующему:
var Foo = function()<>;
delete Foo;
А как написано в статье, переменные, объявленные через var, удалять нельзя.
Оператор delete удаляет не сам объект, а ссылку(указатель) на объект.
Пример
Тоесть из объекта а мы удалили ссылку на объект [1,2,3], но сам объект из памяти не удалился, т.к. на него указывает другой указатель. Объект удалится только по прихоти и решению GC.
к сожалению даже узнать, удалил ли мусоросборщик этот объект, не получиться:
В браузерах Chrome Версия 19.0.1084.56 и Firefox 13.0 удаляется:
локальные элементы в текущем closure удалять нельзя, видимо, GC итак их удалит при выходе из closure
А вот Google Closure при проверке кода на валидность ругается на удаление результата функции, т.е.
delete foo()
хотя по стандарту операция валидна
У меня есть глобальная переменная в JavaScript (на самом деле это window свойство, но я не думаю, что это имеет значение), которое уже было заполнено предыдущим скриптом, но я не хочу, чтобы другой скрипт запускался позже, чтобы увидеть его значение или что он был даже определены.
Я поставил, some_var = undefined и это работает с целью тестирования, typeof some_var == "undefined" но я действительно не думаю, что это правильный путь.
delete Оператор удаляет свойство из объекта. Он не может удалить переменную. Таким образом, ответ на вопрос зависит от того, как определяется глобальная переменная или свойство.
(1) Если он создан с помощью var , он не может быть удален.
(2) Если он создан без var , его можно удалить.
Техническое объяснение
1. Использование var
В этом случае ссылка g_a создается в том, что спецификация ECMAScript называет « VariableEnvironment », которая присоединена к текущей области - это может быть контекст выполнения функции в случае использования var внутри функции (хотя это может быть немного сложнее если учитывать let ) или в случае «глобального» кода VariableEnvironment присоединяется к глобальному объекту (часто window ).
Ссылки в VariableEnvironment обычно не удаляются - процесс, подробно описанный в ECMAScript 10.5, объясняет это подробно, но достаточно сказать, что если ваш код не выполняется в eval контексте (который используется большинством браузерных консолей разработки), то переменные, объявленные с var помощью, не могут быть удаленным.
2. Без использования var
При попытке присвоить значение имени без использования var ключевого слова Javascript пытается найти именованную ссылку в том, что спецификация ECMAScript называет « LexicalEnvironment », и основное отличие заключается в том, что элементы LexicalEvironment являются вложенными - то есть LexicalEnvironment имеет родителя ( то, что спецификация ECMAScript называет «ссылкой на внешнюю среду»), и когда Javscript не удается найти ссылку в LexicalEenvironment , он ищет в родительской среде LexicalEnvironment (как подробно описано в 10.3.1 и 10.2.2.1 ). Верхний уровень LexicalEnvironment - это « глобальная среда»", и это связано с глобальным объектом в том смысле, что его ссылки являются свойствами глобального объекта. Поэтому, если вы попытаетесь получить доступ к имени, которое не было объявлено с использованием var ключевого слова в текущей области или каких-либо внешних областях, Javascript в конечном итоге получит свойство от window объекта , чтобы служить этой ссылке. Как мы узнали ранее, свойства на объекты могут быть удалены.
Важно помнить, что var объявления «подняты», т. Е. Всегда считается, что они произошли в начале области действия, в которой они находятся, - но не при инициализации значения, которое может быть выполнено в var операторе, - который остается там, где он находится. , Таким образом, в следующем коде a это ссылка из VariableEnvironment, а не window свойство, и его значение будет 10 в конце кода:
В чем разница между использованием в delete оператор на элементе массива в отличие от использования в Array.splice метод ?
Зачем даже метод сращивания, если я могу удалять элементы массива, как я могу с объектами?
@andynormancx Да, но этот ответ был опубликован буквально на следующий день и получил гораздо больше голосов - я бы сказал, что лучше написать, так и должно быть. @andynormancx - похоже, он не является точной копией. Вопрос, который вы связали, в основном спрашивает, почему удаление элемента из массива (что делает его разреженным) не приведет к уменьшению его длины. Этот вопрос задает различия между delete и Array.prototype.splice . @chharvey согласился, что более важно, хотя как этот вопрос был опубликован 9 лет назад! Я чувствую себя старым, чтобы вернуться сюда и комментировать этоdelete удалит свойство объекта, но не будет переиндексировать массив или обновит его длину. Это заставляет это казаться, как будто это не определено:
Обратите внимание , что это не на самом деле устанавливается на значение undefined , а свойство удаляется из массива, что делает его казаться неопределенным. Инструменты разработчика Chrome проясняют это различие, печатая empty при регистрации массива.
myArray.splice(start, deleteCount) фактически удаляет элемент, переиндексирует массив и изменяет его длину.
На самом деле, delete действительно удалить элемент, но не индексировать массив или обновить его длину (которая уже подразумеваемой бывший , так как длина всегда самый высокий показатель + 1). JSlint не любит delete myArray[0] синтаксис, говорящий « Ожидается оператор и вместо этого он видит« удалить ». » splice Рекомендуется использовать. @Eye: На самом деле JSLint просто жалуется на отсутствие точки с запятой в предыдущей строке. И вы не можете действительно рекомендовать одно над другим, так как они делают совершенно разные вещи… «Удалить в этом случае будет только установить элемент как неопределенный:« Нет, это категорически неверно. Есть принципиальная разница между delete myArray[0] и myArray[0] = undefined . В первом случае свойство полностью удаляется из объекта массива. Во втором случае свойство остается со значением undefined . К сведению, инструменты Chrome dev показывают ключевое слово empty вместо того, undefined чтобы улучшить различие между фактически удаленным (или неинициализированным) элементом массива и элементом, который имеет реальное значение undefined . Обратите внимание, что когда я говорю это, я имею в виду, что он отображается только как empty и не относится к реальному названному значению empty (которое не существует).Джон Резиг , создатель jQuery, создал очень удобный Array.remove метод, который я всегда использую в своих проектах.
и вот несколько примеров того, как это можно использовать:
+1 Для Array.remove (). Однако не очень приятно, когда передаются строковые аргументы (в отличие от большинства методов Array, например [1,2,3].slice('1'); // =[2,3] ), поэтому безопаснее изменить его на var rest = this.slice(parseInt(to || from) + 1 || this.length); @tomwrong, в javascript нет потоков, и функция выполняется this.push.apply(this, rest) , а затем возвращает возвращенное значение Почему бы просто не использовать splice ()? Имя этой функции, имена параметров и результаты не очевидны. Я рекомендую просто использовать сплайс (индекс, длина) - (см. Ответ Энди Хьюма) Функция, представленная выше, работает как объяснено, но создает нежелательные побочные эффекты при переборе массива с for(var i in array) циклом. Я удалил его и использовал вместо него сращивание.Поскольку delete удаляет только объект из элемента в массиве, длина массива не изменится. Splice удаляет объект и сокращает массив.
Следующий код будет отображать «a», «b», «undefined», «d»
Принимая во внимание, что это будет отображать «a», «b», «d»
Отличный пример, за исключением неоднозначности во втором примере с использованием 1,1 - первый 1 относится к индексу в массиве, чтобы начать соединение, второй 1 - это количество элементов, которые нужно удалить. Таким образом, чтобы удалить 'c' из исходного массива, используйте myArray.splice(2,1)Я наткнулся на этот вопрос, пытаясь понять, как удалить каждое вхождение элемента из массива. Вот сравнение из splice и delete для удаления каждого 'c' из items массива.
Когда вы удаляете элемент массива, длина массива не изменяется. Например, если вы удалите [3], a [4] будет по-прежнему [4], а [3] не определено. Это сохраняется, даже если вы удалите последний элемент массива (delete a [a.length-1]).
splice будет работать с числовыми индексами.
тогда как delete могут быть использованы против других видов индексов ..
Когда вы говорите «любые другие виды индексов», вы больше не говорите о массивах, а скорее об объектах, о которых спрашивает OP. @YiJiang: массивы являются объектами. Indizes являются свойствами. Нет никакой разницы.Вероятно, стоит упомянуть, что сплайс работает только с массивами. (На свойства объекта нельзя полагаться, чтобы следовать последовательному порядку.)
Чтобы удалить пару ключ-значение из объекта, фактически удалите то, что вам нужно:
delete не переупорядочивает ключи массива, поэтому: var arr = [1,2,3,4,5]; удалить обр [3]; for (var i = 0; i <= arr.length; i ++) console.log (arr [i]); будет демонстрировать неожиданные результаты. Это правда. Поэтому, если вы не хотите оставить неопределенный элемент в этом месте, НЕ используйте delete для ключей массива! Первоначально я добавил этот комментарий, чтобы включить ссылку на правильное использование удаления.удалить против сращивания
когда вы удаляете элемент из массива
когда ты склеиваешь
в случае удаления от элемента удаляется , но индекс остается пустым
в то время как в случае сращивания элемент удаляется, а индекс остальных элементов соответственно уменьшается
Как уже много раз говорилось выше, использование splice() кажется идеальным. Документация в Mozilla:
splice() Метод изменяет содержимое массива путем удаления существующих элементов и / или добавления новых элементов.
параметры
Начните
Индекс, с которого начинается изменение массива. Если он больше длины массива, фактический начальный индекс будет установлен равным длине массива. Если отрицательный, начнется так много элементов с конца.
deleteCount
Целое число, указывающее количество удаляемых старых элементов массива. Если deleteCount равен 0, элементы не удаляются. В этом случае вы должны указать хотя бы один новый элемент. Если deleteCount больше, чем количество элементов, оставшихся в массиве, начиная с начала, то все элементы до конца массива будут удалены.
Если deleteCount не указан, deleteCount будет равен (arr.length - start).
item1, item2, .
Элементы для добавления в массив, начиная с начального индекса. Если вы не укажете какие-либо элементы, splice() будут удалены только элементы из массива.
Возвращаемое значение
Массив, содержащий удаленные элементы. Если удаляется только один элемент, возвращается массив из одного элемента. Если никакие элементы не удалены, возвращается пустой массив.
@ downvoter: почему downvote? хочешь объяснить или нет?delete действует как нереальная ситуация, он просто удаляет элемент, но длина массива остается неизменной:
пример из терминала терминала:
Вот функция для удаления элемента массива по индексу, используя slice () , в качестве первого аргумента она принимает arr, а в качестве второго аргумента - индекс члена, который вы хотите удалить. Как видите, он на самом деле удаляет член массива и уменьшает длину массива на 1
Функция, приведенная выше, заключается в получении всех элементов до индекса и всех членов после индекса, объединяет их вместе и возвращает результат.
Вот пример использования функции выше в качестве модуля узла, где будет полезен терминал:
обратите внимание, что это не будет работать с одним массивом, содержащим дубликаты, потому что indexOf ("c") просто получит первое вхождение, и только склеит и удалит первый найденный символ "c".
Если вы хотите выполнить итерацию большого массива и выборочно удалять элементы, было бы дорого вызывать splice () для каждого удаления, так как splice () должен будет каждый раз переиндексировать последующие элементы. Поскольку массивы являются ассоциативными в Javascript, было бы более эффективно удалить отдельные элементы, а затем повторно индексировать массив впоследствии.
Вы можете сделать это, создав новый массив. например
Но я не думаю, что вы можете изменить значения ключей в исходном массиве, что было бы более эффективно - похоже, вам, возможно, придется создать новый массив.
Обратите внимание, что вам не нужно проверять «неопределенные» записи, так как они на самом деле не существуют и цикл for не возвращает их. Это артефакт печати массива, который отображает их как неопределенные. Они, кажется, не существуют в памяти.
Было бы хорошо, если бы вы могли использовать что-то вроде slice (), которое было бы быстрее, но не переиндексирует. Кто-нибудь знает лучший способ?
На самом деле, вы, вероятно, можете сделать это на месте следующим образом, что, вероятно, является более эффективным, с точки зрения производительности:
Я считаю индекс ++; должно произойти за пределами «если». Делая правкуВы можете использовать что-то вроде этого
это более интуитивно понятно, чем slice если бы вы пришли из функционального фона (хотя, вероятно, менее эффективно).Почему не просто фильтр? Я думаю, что это самый понятный способ рассмотреть массивы в JS.
Как насчет массива с сотнями (если не тысячами) записей, из которых нужно удалить только 3 из них? хорошая точка зрения. Я использую этот метод для разреженных массивов, длина которых не превышает 200 или 300 и работает очень хорошо. Тем не менее, я думаю, что библиотеки, такие как подчеркивание, должны быть предпочтительнее, если вам нужно управлять такими большими массивами. Тем не менее, это кажется намного лучше, чем 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 .
Читайте также: