Ленивые, отложенные вычисления — такой подоход, когда значения вычисляются только тогда, когда в них возникает потребность, при этом есть возможность не вычислять это значение повторно при последующих вызовах функции. В javascript этот подход можно реализовать с помощью замыканий и переопределения функции изнутри самой себя.

function func_name () {
	var variable_foo,
		variable_bar;

	variable_foo = get_foo();
	variable_bar = get_bar();
	func_name = function () {
		return variable_foo + variable_bar;
	};
	return func_name.apply(this, arguments);
}

Фишка заключается в том, что значения variable_foo и variable_bar будут вычислены только при первом вызове функции. При этом-же вызове функция переопределит себя, захватывая scope с вычисленными переменными и себя-же родимую вызовет (при этом корректно сохраняя this, возвращаемое значение, а так же переданные аргументы).

Этот подход сработает и для методов:

var obj;

obj = {};
obj.method = function () {
	var variable_foo,
		variable_bar;

	variable_foo = get_foo();
	variable_bar = get_bar();
	this.method = function () {
		return variable_foo + variable_bar;
	};
	return this.method.apply(this, arguments);
}

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

Из минусов: зависимость от имени функции или метода. Слишком просто будет допустить ошибку. Во избежание залепил сниппет для sublimetext2, который расскрывается в следующее

// srv
function_name = function () {

};
return function_name.apply(this, arguments);

(этот сниппет можно найти на gihub).