Событие вызова функции
 

Чисто из интереса, решил узнать, можно ли повесить событие на вызов функции. Как ни странно (для меня), это удалось.

(function(){
	window.callEvent = function(func, callback){
		var callNumber = 0;
		return function(){
			var args = [].slice.call(arguments);
			var result;
			try {
				result = func.apply(this, arguments);
				callNumber++;
			} catch (e) {
				callback(e, args, this, callNumber);
				throw e;
			}
			callback(result, args, this, callNumber);
			return result;				 
		}
	}
	
	var logSomething = function(something){
		console.log(something);
	}
	
	logSomething = callEvent(logSomething, function(result, args, self, callNumber){
		console.log('alertSomething has been called. \n\
			Result is ' + result + '. \n\
			Arguments are ' + args + '. \n\
			Self is ' + self + '. \n\
			Number of calls ' + callNumber + '. \n'
		);
	});
	
	Array.prototype.push = callEvent(Array.prototype.push, function(result, args, self, callNumber){
		console.log('Array.prototype.push has been called. \n\
			Result is ' + result + '. \n\
			Arguments are ' + args + '. \n\
			Self is ' + self);
	});
	
	logSomething('Fuck yeah!');
	logSomething('Fuck yeah!');
	logSomething('Fuck yeah!');
	logSomething('Fuck yeah!');
	logSomething('Fuck yeah!');
	
	var array = [1,2,3,4,5];
	array.push(6);
})();

Ненужная строка. И простого func хватит.

B@rmaley.e><e, точно, спасибо.

Только вот не могу придумать, как это сделать через Function.prototype.

а ну-ка, выкинь исключение в наблюдаемой функции))))

Не совсем понимаю о чем ты. Кинул исключение, всё остановилось. И что?

Переопределить?

Э, как?

Function.prototype.callEvent = function(callback){
	this = function(){...

Выкидывает исключение.

Естественно. Изменить this из метода нельзя. В данном случае можно будет только вернуть новую функцию, для которой будет назначен соответствующий обработчик.

Я говорю о том, чтобы при создании ф-ции добавлять к ней коллбек и способ добавления новых коллбеков. Путем сохранения Function в переменную и переопределения его. Вряд ли это реально, но это просто идея.

Если тебя этот вариант устраивает, то все в порядке.
Я бы, в данном случае поймал бы исключение, предал бы в обработчик события, и затем передал бы его дальше, наверх

Так?

window.callEvent = function(func, callback){
		return function(){
			var args = Array.prototype.slice.call(arguments);
			var result;
			try {
				result = func.apply(this, arguments); 
			} catch (e) {
				result = e;
			}
			callback(result, args, this);
			return result;				 
		}
	}

UPD Хотя нет, бред.

Я о том же.

не совсем

window.callEvent = function(func, callback){
		return function(){
			var args = Array.prototype.slice.call(arguments);
			var result;
			try {
				result = func.apply(this, arguments); 
			} catch (e) {
				callback(e, args, this);
				throw e;
			}
			callback(result, args, this);
			return result;				 
		}
	}

Gvozd,
ок, спасибо.

(не обновил страницу перед отправкой)

так что ли? Правда непонятно, зачем эти события отлавливать.

а что должно произойти?

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

Да, и это просто спортивный интерес. Меня полгода назад спросили, можно ли ловить событие вызова какой-нибудь функции, я покрутил пальцем у виска и сказал "нет".

А что оно делает?
Идея в том, что где-то определена функция или метод (даже встроенный, что было продемонстрировано на примере) и ты вешаешь обработчик (псевдообработчик) на её вызов. Я не знаю, как яснее выразиться.

для этого есть отладчик (журналирование, в первую очередь)

ради чего усложняем свою жизнь?

перехватывает событие вызова функции

Я ниже вызвал f() и ничего не произошло, кроме, собственно, вызова функции.Кто усложняет-то?

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

можно было бы запилить с помощью __parent__, но это свойство уже склеило лыжи.

как вариант, можно переопределить функцию!

Это и делается.

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

Я говорил о том, чтобы создавать сразу обёрнутую ф-цию. То есть чтобы a= function(){} сразу давало ф-цию, на которую можно повесить обработчик.

trikadin, встроенные функции-то всё равно ручками оборачивать придётся.

А, да. Об этом я как-то не подумал.

ok, приведу пример ближе к твоему варианту: http://jsfiddle.net/EFmw6/1/

наверное ты хотел спросить: "В чем я себе усложняю жизнь?" И я тебе отвечу: 1) ты создаешь средства отладки, которые не лучше уже имеющихся (firebug, например) или не расширяющие их значительно, 2) зачем выносить отладочные операторы в отдельную функцию, если можно сделать это прямо на месте?

Чтобы не мешать код в кучу. Мухи - отдельно, котлеты - отдельно.

это временный код, ты его должен удалить в результате

Ну так это ещё проще было бы. Отдельный файл с дебагом, регэксповый поиск в основном - на убирание переопределения. Имхо, идея неплохая.

Там всё то же присваивание. Было бы интересно сделать что-то типа такого:

f = function(){
...
}

f.attachCallListener(function{
...
})

f(); //а здесь уже вызывается функция и обработчик

А как это потесняет отладчики (или наоборот)?
А можешь, не меняя кода функции, посмотреть, сколько раз и как она вызывалась?

Точно.

А я бы сделал так:

window.callEvent = function(func, callback){
		return function(){
			var args = Array.prototype.slice.call(arguments);
			var result;
			try {
				result = func.apply(this, arguments); 
			} catch (e) {
				if(callback(e, args, this) !== false) throw e;
			}
			callback(result, args, this);
			return result;				 
		}
	}

FINoM,
Вам бы почитать про Proxy. v8 и SpiderMonkey вполне себе поддерживают.

П.С. Вообще где то на хабре это уже было :)

И мне тогда тоже) Пробежался, выглядит интересно)

trikadin,
Кстати там в самом низу есть ссылки на презентацию Брендана Эйча. Сам ещё не смотрел, но надо бы посмотреть :)

Не осилил ещё до конца) Всё же мой английский пока не идеален)

f = function(){
...
}

f.attachCallListener(function{
...
})

f(); //а здесь уже вызывается функция и обработчик

ты понимаешь, что attachCallListener надо вставить сразу же после определения f, иначе ты можешь пропустить вызов f? А это значит, что ну пусть ты не изменил код функции, но ты должен изменить код рядом с функцией. А о выносе в другой файл вообще речи не должно быть, по-крайней мере в данной абстрактной ситуации. Так что на практике ты к тому же усложняешь себе жизнь тем, что тебе надо думать, в каком месте можно обернуть функцию, чтобы ничего не пропустить.

потом, даже если бы можно было сделать как ты хочешь, как бы это выглядело? Что-то типа jquery.live?

$('/js/script.js:1:f').live(function() {...});

Как указать вызов какой именно функции надо перехватывать?

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

в том-то и дело, что никак

я не знаю, зачем мне это. Все о чем ты говоришь я могу сделать с помощью console.log. Причем я смогу вывести именно тот вариант "как она вызывалась", который мне нужен, а не какой-то универсальный. Я ж так понял, что вывод "как она вызывалась" - это одна из задач твоего инструмента?

если же эта задача представляет академический, а не практический интерес, тогда у меня нету вопросов. Не вижу в этом ничего плохого. Но и интерес к ней у меня тогда автоматически пропадает.

Айка. ай-ай-ай.

melky,
ага, стыдно )

Немного расширил функцию: теперь вместо одного колбека вторым аргументом передается объект

• before (вызывается перед запуском функции)
• success (вызывается, если функция отработала успешно)
• error (если возникла ошибка)
• after (вызывается в любом случае, не зависимо от успешности выполнения)

Каждому обработчику передается объект

• args
• self (контекст)
• name (имя функции)
• status ("error" или "success")
• successNumber (количество успешных вызовов)
• errorNumber (количество вызовов с ошибкой)
• result (результат, если есть)
• error (ошибка, если есть)

Кроме этого, функция addCallListener теперь является частью объекта конструктора Function, во избежание попадания в window или process.

Форкнуть и потестить можно здесь: http://jsfiddle.net/finom/SGhzd/5/