Простой, но сложный. Как принудительно запускать внешние функции libs?

Question

Если у нас есть две функции в javascript, один slow и один быстрый. Например:

function slow() { 
    setTimeout(function() {console.log("slow finished")}, 10000); 
} 

function fast() { 
    console.log("fast"); 
} 

И эти функции не имеют внутри них новых структур, таких как promisses (если мы не реализуем их после).

Как мы можем заставить эти функции работать в порядке? Например:

function run() { 
    slow(); 
    fast(); 
} 

run(); 

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

Есть ли способ сделать это?

Идея моя впрыскивает функцию обратного вызова между функциями. И этот обратный вызов вызывается в конце slow функция, вызывающая быстро функция.

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

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

Как мы можем это сделать?

Редактировать

Он Я был пытается решить проблему слияния ответы. Пока нет успеха. Я изменил slow, но это не разрешено. Я изменил его на то, что происходит с a. Я не мог получить что-то интересное, потому что становится неопределенным сразу, а не после того, как медленно отделки ...

var a = "adsfadsfadsf"; 
    function slow() { 
    setTimeout(function() {console.log("slow done"); console.log("a2", window.a);}, 3000); 
    } 

    function fast() { 
    console.log("a3", window.a); 
    console.log("fast done"); 
    } 

    var newSlow = function() { 
    return new Promise(function(resolve, reject){ 
     window.a = slow(); 
     console.log("a", a); 
     resolve("Sucess"); 
    }); 
    }; 

    newSlow().then(function(resolve){fast();}, function(reject){console.log("error");}); 

Я попытался с решимостью (медленно()); нет sucess тоже.

Answer 1

Это очень интересный вопрос. Ну, я могу думать о том, где, если он меняет какую-то глобальную переменную «g» на некоторое значение, скажем «true». В этом случае, если вы можете запустить их последовательно, как,

<script> 
var g = false; 
var i; 
function slow() { 
setTimeout(function() {console.log("slow finished");g=true;}, 10000); 
} 

function fast() { 
    console.log("fast"); 
} 
    function run() { 
    slow(); 
    i = setInterval(function(){check();},1000); 
} 
function check(){ 

    if(g){ 
     fast(); 
     clearInterval(i); 
    }  
} 
run(); 
</script> 

As in this demo

UPDATE: Что-то ударил меня, и я думаю, мы могли бы добавить функцию обратного вызова slow() даже если мы можем» t получить доступ к нему напрямую.

Если функция вызывается без скобок, тогда вся функция в качестве содержимого возвращается в виде строки, поэтому мы можем редактировать эту строку, добавив fast() к ней, зарегистрировав эту строку как функцию, используя eval().

function run() { 
    var myFun = slow+""; 
    myFun = myFun.substring(0,myFun.length-1); 
    alert(myFun); 
    myFun += "fast();}"; 

    //to register the string "myFun" as a function 
    eval(myFun); 

    slow(); 
} 

Так в основном наша slow() функция становится,

function slow(){ 

    //function code 

    //the appended function 
    fast(); 

} 

Примечание: Это не работал в приведенном выше примере, где GarouDan намеренно добавил предел SetTimeout воссоздать сценарий, при котором функция slow() принимает больше времени, чем функция fast(). Однако в реальном сценарии я уверен, что этот подход определенно сработает.

Answer 2

Вы можете использовать шаблон Promise.

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

Моя личная любимая библиотека, которая реализует шаблон Promise: RSVP.

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

function doFoo() { 

    var promise = new RSVP.Promise(function(resolve, reject) { 

    // do some long-running operation, like retrieve 
    // data from a slow site... 

    if (data.Status && data.Status === 200) { 
     resolve(data); 
    } else { 
     reject(data.Error) 
     } 

    }); 
    return promise; 
} 

function doBar() { 
    var promise = new RSVP.Promise(function(resolve, reject) { 

     // do some fast operation, like count to 10 
     for (i = 0; i < 10; i++) { 
      console.log(i); 
     } 

     resolve(""); 
    }); 
    return promise; 
} 

Теперь вы можете позвонить:

function inOrder() { 
    doFoo().then(function(success) { 
     doBar(); 
    }).catch (function(failure) { 
     console.log("oops! " + failure); 
    } 
    }); 
} 

Это работает doFoo, и работает только после того, как Dobar doFoo завершилась успешно. Обратите внимание, что вы также можете запустить doBar, даже если doFoo не удалось.