Все функции «обратного вызова» узла «Потенциально асинхронные»?

Question

Я (относительный) узел новичка, попадающий в систему, и весь энтузиазм в сообществе для «просто писать обратные вызовы, все асинхронно и управляться событиями, не волнуйтесь!» оставил меня немного запутанным относительно потока управления в рамках одной программы (или в более узких терминах, поток управления при обработке одного запроса в более крупной программе)

Если у меня есть следующая программа, запускаемая под узлом

var foo = function(){ 
    console.log("Called Foo"); 
}; 

var bar = function(){ 
    console.log("Called Bar"); 
}; 

var doTheThing = function(arg1, callback){ 
    callback(); 
}; 

doTheThing(true, function() { 
    foo(); 
}); 
bar(); 

есть любой шанс, что foo выполнит послеbar? Когда я запускаю программу локально с помощью командной строки, это всегда

Called Foo 
Called Bar 

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

Answer 1

Нет, нет никаких шансов. Не для этого кода.

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

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

Answer 2

Нет

Ваш пример кода 100% синхронные, однопоточный, просто сверху-вниз. Но это потому, что вы не делаете никаких операций ввода-вывода, не имеете настоящих асинхронных вызовов и не используете process.nextTick, setTimeout или setInterval. Для того, чтобы более реалистично имитировать асинхронные вызовы сделать что-то вроде:

function fakeAsync(name, callback) { 
    setTimeout(function() { 
    callback(null, name); 
    }, Math.random() * 5000); 
} 

function logIt(error, result) { 
    console.log(result); 
} 

fakeAsync('one', logIt); 
fakeAsync('two', logIt); 
fakeAsync('three', logIt); 

Run, что несколько раз, и вы увидите испорченные результаты иногда.

Answer 3

Есть ли вероятность того, что foo будет выполняться после строки?

В вашем текущем кодексе нет. Хотя ваша функция doTheThing имеет асинхронную сигнатуру функции (т. Е. Она принимает обратный вызов в качестве последнего аргумента, который для аутсайдера, не знающего о реализации функции, предполагает, что он асинхронный), он фактически полностью синхронный, и callback будет вызван без уступания к времени выполнения.

Однако

Вы действительно не имеют никаких оснований, чтобы дать ваш doTheThing код асинхронной подпись, если вы не вмещающий для введения реального поведения асинхронной в doTheThing в какой-то момент. И в этот момент у вас есть проблема, потому что вызывается порядок, в котором вызывается foo и bar.

На мой взгляд, есть только два хороших способа написания кода, как и вы: либо заставьте его установить в камне, что doTheThing будет синхронным (что самое главное: что он не будет зависеть от ввода-вывода), что означает, что вы можете просто вернуть из функции:

doTheThing = function(arg1){ 
    return null 
}; 
doTheThing() 
foo() 
bar() 

или изменить реализацию заглушки doTheThing непосредственно включить вызов setImmediate, т.е.

var doTheThing = function(arg1, callback){ 
    setImmediate(function() { callback();); 
}; 

Обратите внимание, что это также может быть записан как

var doTheThing = function(arg1, callback){ 
    setImmediate(callback); 
}; 

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

Как только вы это сделаете, bar всегда будет вызываться до foo, и теперь стало безопасным вводить асинхронную функциональность в doTheThing.