Новое поколение цепочек - ассинхронность
 

Пока фреймворк в стадии наполнения и допиливания, но в нем реализована полная ассинхронность цепочечных команд:

A=$().test('a').test('b').sync(true);
setTimeout(function(){
	A.sync(false);
	},1000)
A.test('c').sync(function(){
	this.sync(1000).test('e').test('f');
	console.log(11);
	return this;
	}).test('d').test('g');
console.log('end');
test: function(str){console.log(str)}

В логе следующее:
a
b
end
проходит секунда
c
11 - раздвоение потоков
d
g
проходит секунда
e
f

а еще на подходе очень мощные селекторы, которые уже не уступая Sizzle, чаще обгоняют его в 3-6 раз.

Теперь и в JS можно писать ассинхронно!

Спасибо, поржал.

Теперь немного критики:
0) Для заценки своих проектов есть отдельная ветка форума

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

2) Как следствие из пункта 1: вы не привели ни какого намека даже на документацию. Из вашего кода и результата его работы остается только догадываться как именно работает и используется ваш фреймворк.
Метод sync у вас может принимать три типа параметров.
И достаточно трудно понять, как именно они работают.

Например, моим первым предположением было, что .sync(true) переключает очередь функций в синхронный режим.
Но, тогда непонятно, почему 'c' выводится после 'end', хотя в синхронном режиме оно вполне раньше должно сработать.
Через 5-10 минут анализа, я понял, что .sync(true) вообще останавливает очередь, до тех пор, пока не будет вызван .sync(false). Кстати, не удивлюсь, если я ошибся, и вообще другую идею вкладывали в .sync(true)
Без документации, или кода проекта остается только догадываться о том, как это все работает, и как используется.

3)Я не нашел в вашем примере асинхронности
Все пользовательские функции в вашем примере - синхронные
Может покажите, как в вашем фреймворке будет выглядеть набор из 3х последовательны AJAX запросов?
Ну или что-нибудь другое асинхронное?

именно. они синхронно выполняются но задавать их можно ассинхронно.

$().sync().ajax(fn1).ajax(fn2).ajax(fn3)

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

может все-таки наоборот?
в вашем втором примере, вы синхронно задали выполнение трех AJAX-, запросов и обработчиков к ним.
Или между выполнением .ajax(fn1) и .ajax(fn2) может быть выполнен еще какой-нибудь код?
а вот выполняется код уже асинхронно(я ж полагаю, между срабатыванием fn1 и срабатыванием fn2 браузер не зависает, и может быть выполнен другой код?), хотя и последовательно(опять-таки предположение).

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


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

все верно. браузер не виснет

Небыло никогда необходимости сделать ассинхронные запросы но что бы они были выполненныс последовательно?
для этого как все мы знаем, мы проделываем такое:

ajax({...,onSuccess:function(){ ajax({...,onSuccess}) }});

А если таких запросов куча? такой код и читать сложно а уж темболее писать.

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

У меня же ассинхронность распространяется абсолютно на все методы обьекта.

А как такое реализует Deffered:

A=$().test('a').test('b').sync(true);
setTimeout(function(){
    A.sync(false);
    },1000)
A.test('c').sync(function(){
    this.sync(true).test('e').test('f');
    console.log(11);
    return this;
    }).test('d').test('g');
console.log('end');

В логе следующее:
a
b
end
проходит секунда
c
11
e
f
d
g

при этом this.sync(true).test('e').test('f'); может и не исполнятся тогда после "11" будет просто d и g

Упрощенный Deferred.

В некоторых задачах возникает такая необходимость
Для этого умные люди придумали Deferred
jQuery > 1.5

var url = 'http://ya.ru';
	var fn1 = function() {
		console.log('start1');
		return jQuery.ajax({
			url: url,
			success:function(res){console.log([1, res.length])}
		})
	};
	var fn2 = function() {
		console.log('start2');
		return jQuery.ajax({
			url: url,
			success:function(res){console.log([2, res.length])}
		})
	};
	var fn3 = function() {
		console.log('start3');
		return jQuery.ajax({
			url: url,
			success:function(res){console.log([3, res.length])}
		})
	};
	var def = jQuery.Deferred();
	def.pipe(fn1).pipe(fn2).pipe(fn3);
	def.resolve();

вывод

Например как-то так

function test(a){
		return function(){console.log(a);}
	}
	
	var pause = $.Deferred();
	A = A.pipe(test('a')).pipe(test('b')).pipe(function(){return pause;})
	setTimeout(function(){
		pause.resolve();
		},1000)
	A.pipe(test('c')).pipe(function(){
		var tmp = $.Deferred();
		tmp.pipe(test('e')).pipe(test('f'));
		console.log(11);
		
		tmp.resolve();
		return tmp;
	}).pipe(test('d')).pipe(test('g'));
	console.log('end');

Замечания о том, что этот код делает не тоже, что и ваш код, рассматриваются только после того, как вы дадите ответы на следующие вопросы:
а)что все-таки делают на самом деле .sync(true) .sync(false) ?
б) почему this.sync(true).test('e').test('f') может выполнится, а может и нет? от чего это зависит
в) Если я правильно понял(догадался) работу .sync(true), то после него не будут выполнены ни .test('e').test('f'), ни .test('d').test('g'); до тех пор, пока не будет вызван еще один .sync(false)

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

Так что давайте уже ссылку на него.
На документацию тоже давайте, если есть. Если нету - не беда.

мм. интересно а как система узнает что аякс закончен? предполагаю что они переделали его под дефферед. и как обчно у jQ все через левое ухо.

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

А до тех пор какой смысл тогда хвастать? Не серьезно как-то. Да и беспредметный топик получается, как уже было замечено Gvozd.

Да, именно так и есть.
Мне кажется, вы недопонимаете концепцию Deferred
Хотя реализация(непривычные имена методов, выделение типа Promise, и метода pipe) в jQuery не сильно мне нравится, но она работает, и работает как надо.

На пальцах:
Deferred(в jQuery - Promise) - это своего рода обещание результата.
То есть функция может вернуть этот тип данных.
И тогда те, кто его используют понимают: надо повесить callback на этот объект, и получить результат позже.
метод pipe позволяет навешивать callback прозрачным образом, по цепочке.

Вообще, концепция Deferred очень красивая и удобная, если ее понять, и позволяет удобно писать асинхронные приложения

Наверное у него что-то вроде этого: http://habrahabr.ru/blogs/nodejs/116124/.

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

показывал бы хоть что-то.

это есть в Deferred
Мой пример с AJAX-ом, как раз это и показывает
Три последовательных асинхронных запроса.
Каждый новый будет создан после того как будет выполнен предыдущий, и никак не раньше.
Или вы не про это?