JavaScript новое ключевое слово и управление памятью

Взятый вне контекста (браузера) javascript полностью способен освободить память с помощью сборки мусора. Возвращение к реальности сборки мусора в сочетании с моделью DOM может вызвать утечку памяти.

Вот одна статья http://www.ibm.com/developerworks/web/library/wa-memleak/ , вы можете найти более подробную информацию о ней

Вся память JavaScript является ссылочной, но не в традиционном смысле. Ссылка на память осуществляется не по адресу памяти, а по строке. В этом коде:

var x = new someObj();

С этого момента на этот объект ссылается строка "x". x не является указателем на какую-то память на куче в этот момент. Если вы присвоили x свойство, то:

x.someProp = 42;

Тогда someProp - это строка в памяти, ссылающаяся на значение 42. Следовательно, это позволяет вам использовать нотацию массива для доступа к нему через его строковое представление:

x["someProp"]++;

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

Память собирается в JavaScript, фактически, когда на нее больше не ссылаются строки (они же переменные или имена свойств). Этот объект будет собран, когда x будет присвоено любое другое значение. Вы можете установить его в null, undefined или любое другое, и эта память будет собрана.

То есть, она будет собрана, когда браузер или любой другой механизм JavaScript доберется до нее.

Delete удаляет только свойства объектов. После этого попытка получить доступ к этому свойству вернет undefined. По большей части, следующие 2 строки кода эквивалентны:

x["someProp"] = undefined;
delete x.someProp;

Edit: Ok, внутренне эти две строки не одинаковы. Оператор delete удалит ссылку на "someProp" из памяти, а установка в undefined - нет. Я думаю. Я не могу найти ничего в спецификациях об установке переменной или свойства в неопределенное значение, но я не думаю, что это делает что-то особенное.

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

Есть удаление . Однако реальная потребность в нем будет редкостью. Однако это не похоже на удаление в C ++.

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

Не используйте удалите в JavaScript, если вы не удаляете обработчики событий. Даже в этом случае мы делаем это только потому, что в старых версиях IE есть утечка памяти, связанная с этой практикой. Дуглас Крокфорд довольно хорошо объясняет это . В его случае он даже не использует delete . Он просто устанавливает для рассматриваемых значений значение null .

В Javascript есть удаление , но поверьте мне: это способ отличается от delete в чем-то вроде C ++. Я рекомендую вам даже не думать об его использовании, пока вы не освоитесь с Javascript.

Сборка мусора работает, но не решает проблему утечки памяти.

new создает объекты из конструктора. delete удаляет свойства объекта. Это две очень разные вещи.

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

удалить o.fu отличается от o.fu = undefined . Попробуйте следующее:

var o = {};
alert(o.hasOwnProperty('fu')); // -> false
o.fu = undefined;
alert(o.hasOwnProperty('fu')); // -> true
delete o.fu;
alert(o.hasOwnProperty('fu')); // -> false

Из MDC :

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

Оператор удаления, на мой взгляд, полезен только тогда, когда вы хотите удалить свойство из объекта. Но поскольку могут быть другие ссылки на свойство, на которое он ссылается, он не будет действительно GCed. Если вы хотите, чтобы что-то было GCed, вам нужно удалить все указатели, указывающие на это, а также освободить замыкания, содержащие ссылки на это ( дополнительная информация по теме ).

Между прочим, ключевое слово «new» на самом деле не обязательно в javascript и не имеет (напрямую) никакого отношения к выделению памяти. Все, что «new» делает, это передает новый пустой объект с именем «this» (this = {}) в качестве скрытого аргумента функции.

var MyClass = function(){
    // fresh empty object "this" gets passed to function
    // when you use the "new" keyword 
    this.method = function(){}
}

var myInstance = new MyClass();

Javascript может стать непростым из-за вложенных замыканий и нескольких переменных «this», плавающих в разных областях. Я предпочитаю делать это так:

var MyNoNewClass = function(){
    // I find this more explicit and less confusing
    var self = {}
    self.method = function(){}
    return self;
}

var myNoNewInstance = MyNoNewClass()