смысл замыкания в том, чтобы оставить сборщик мусора не у дел :)

бла, это самое лаконичное определение термина "замыкание", которое я видел :victory:

Что там разбирать, всё элементарно.

function doublingDecorator(f) {
  return function() {
    return 2*f.apply(this, arguments); // (*)
  };
}

// Использование:

function sum(a, b) {
  return a + b;
}

sum = doublingDecorator(sum);

alert( sum(1,2) ); // 6
alert( sum(2,3) ); // 10

Вызываем: doublingDecorator(sum)

function doublingDecorator(f) {
	//,,,
}

В данном случае f = sum,
т.е. условно

f = function(a, b) {
	return a + b;
}

Собсно эта f находится в scope(области видимости) текущего вызова данной функции.

//...
return function() {
	return 2*f.apply(this, arguments); // (*)
}

это по сути то же самое что:

function temp() {
	return 2*f.apply(this, arguments); // (*)
}
return temp

просто не создаётся лишних переменных, а идёт возврат на ходу созданной функции.

И поскольку функция, создаваемая внутри другой функции, видит все внутренние переменные, она замыкает их все на себя, тем самым сохраняя их в доступности даже после завершения работы материнской функции.

Последним действием:

sum = doublingDecorator(sum);

затирается первоначальная ссылка на sum, т.е. sum = temp. В простом случае это заставило бы сборщик мусора стереть саму память о функции на которую раньше ссылалась sum, но у нас сохранилась ещё одна ссылка на оную - переменная f, замкнутая внутри новосозданной функции temp и, соответственно, вполне работоспособная.

f.apply(this, arguments);

.apply же просто вызывает нашу функцию f с теми аргументами, что переданы в temp(+подменяет this, но это отдельная тема).
В данном же случае можно было поступить и так:

function temp(a,b) {
	return 2*f(a, b); // (*)
}

но изначальный вариант универсальнее, ибо не привязан к конкретной функции sum и может использоваться с другими.


Ещё небольшой примерчик пользы замыканий:

function act( num ){
	return {
		minus : function( n ){ return num - n },
		plus : function( n ){ return num + n },
	}
}

a = 10;
a = act(a);

alert( a.plus( 3 ) ); //13
alert( a.minus( -1 ) ); //12

Это работает, т.к. обе функции видят одну и ту же переменную num, что при вызове стала равной a,
и, т.к. act уже отработала, эта переменная больше никому недоступна.


Не знаю, помог ли я или ещё сильнее запутал, но пускай будет.)

спасибо, прояснилось
а есть возможность описать как обратиться к f чтоб посмотреть что там (полный путь типа window.-%:";&+%%/!!.#*/&/.f () {return...} (в моем и своем примере)
этот момент меня и смущает - неявное создание каких-то промежуточных объектов или непонятное место нахождение замкнутых переменных.
Надеюсь я понятно выразился?
Хочется понять весь механизм, потому что понять код - я пойму, но сам не "замкну".

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

это ограничение области видимости. Кому я это говорю. Вы и так все знаете лучше меня )
:) еще короче: смысл замыкания сохранить состояние

Хочется материться.
Такое впечатление, как будто теорию относительности или Фрейда пытаешься понять, половину приходится принять на веру - раз работает, значит так оно и есть.
Но, понял как это все в данном мной примере работает.
Самая большая сложность - это учитывать время и ход событий. Типа прошла инициализация (интерпритация / компиляция / (?*%*?-ция) и сложились вот такие объедки, которые находятся в обновленных старых ссылках. Типа в строке 13 происходит перезапись в ссылку sum новой функции которая есть "самостоятельной", а к функции описанной

09	function sum(a, b) {
10	  return a + b;

обращений производиться уже не будет никогда.
:help:
Если не лень, можете над моим примером поизвращаться - функционал оставить, а код еще "перезамкнуть" и сделать лаконичнее, используя самые извращенные способы?

Javascript просто выполняется потоком по порядку, потому не надо ни о каких сложностях париться, как написано так и сработает.)
(исключая некоторые заморочки с var, setTimeout - но это отдельная тема)

sum - это ссылка на функцию(вообще все объекты в js передаются только по ссылке, а функция тоже объект, да), соотвественно при исполнении

doublingDecorator(sum)

- в функцию doublingDecorator передаётся ссылка на функцию

function sum(a, b) {
	  return a + b;
}

и внутренняя переменная f тоже становится ссылкой на оную. После чего действием

sum = doublingDecorator(sum)

, sum становится ссылкой уже на новую функцию (temp) созданную внутри doublingDecorator, при этом ссылка на оригинальную всё ещё остаётся во внутренней переменной f.

Kivi, думаю, тебе стоит почитать про замыкания.

Вообще думаю ему стоит начать не с замыканий, а с описания языка и его особенностей и отличий от иных.))