10000000000000000 > Number.MAX_SAFE_INTEGER //true
Number.MAX_SAFE_INTEGER
содержит значение, которое является максимально безопасным в плане "погрешностей". То есть числа, которые по значению больше него, могут грешить на неточность - самостоятельно округляться, к примеру (как это происходит тут). Правильно? constructor.Func
- выдает false.Func.prototype == constructor.Func; //false
Func.prototype.constructor
- выдает true. Func.prototype.constructor == Func; //true
let a = {
};
console.log(String(a)); //преобразование к строке --> [object Object]
По историческим причинам, если toString или valueOf вернёт объект, то ошибки не будет, но такое значение будет проигнорировано (как если бы метода вообще не существовало).
В b у вас число, оно передаётся не по ссылке, а по значению. Соответственно, ссылка на b не создаётся.
function func() {
let a = 10;
let b = 20;
return b;
}
let c = func();
console.log(c);
function func() {
let a = 10;
let b = 20;
}
let c = func;
console.log(c);
func
остаётся, но обращаться к отдельным его свойствам (переменным) нельзя, потому что: во-первых, область видимости, во-вторых, создаваемые ссылки во время выполнения от самой функции func после ее выполнения функции очищаются, если к ним напрямую нет доступа из корня. func
сохраняется, но вывести ее по-прежнему не получается:let outerfunc = function () {
let func = function () {
let a = 5;
let b = 10;
console.log(a + b);
};
}
let c = func;
console.log(c);
outerfunc
от корня хранится ссылка на родительскую функцию. От объекта ф-ции outerfunc
идет ссылка на объект func
. В итоге func
не удаляется сборщиком мусора, правильно я понимаю? function f1() {
let func = function () {
let a = 5;
let b = 10;
console.log(a + b);
};
}
let c = func;
console.log(c);
let func = function () {
let a = 5;
let b = 10;
console.log(a + b);
};
let c = func;
console.log(c);
g
будет идти ссылка в функцию f
к переменной counter
как к свойству объекта. А к x
не будет ссылки, потому что это переменная не "упоминается" во вложенной ф-ции g
. Остаётся только то, на что непосредственно ссылается функция g(), то, что замыкается на ней.
g
- ссылка на лексическое окружение функции f
? Хотя там и так ничего нет в environment record... Пока эта ссылка доступна из глобального контекста (через g), функция сохраняется в памяти.
g
также остается? И из него, как я понимаю, идет ссылка на то окружение, в котором эта внутренняя функция была объявлена - то есть на лексическое окружение ф-ции f
. И лексическое окружение ф-ции f
тоже никуда не удаляется т.к. на него ссылается g
. Правильно? После переприсваивания значения let g ссылки на функцию g больше нет и она будет съедена сборщиком мусора.
g
может хранить ссылку на лексическое окружение родительской ф-ции f
только тогда, когда g
помещена в переменную? Или как? ...а просто не использовать g дальше в коде, оно тоже будет собрано сборщиком.
f()
лексическое окружение этой родительской ф-ции остается в памяти. Именно поэтому вложенная функция g
потом может ссылаться на это "неудаленное" окружение лексической функции. Что вы имеете в виду? Так вот, когда без объявления обращаются к переменной, фактически используется свойство этого верхнего объекта (window).
var foo = 1;
function bar() {
//var foo;
if (!foo) {
var foo = 10;
}
console.log(foo);
}
bar();
Вот только наверное лучше хранить целые хотя бы с одним нулем, потому что первый пример, в отличие от второго, снова образует "хвост":
Почему так происходит я не понимаю...