Eşzamansız işlev çağrılarını Node.js veya Javascript'te bir eşitleme işlevine nasıl sarabilirim?

Bir işlevi açığa çıkaran bir kitaplık tuttuğunuzu varsayalım getData. Kullanıcılarınız gerçek verileri almak için onu çağırır:
var output = getData();
Başlık altında veriler bir dosyaya kaydedilir, böylece getDatayerleşik Node.js kullanarak uygulayabilirsiniz fs.readFileSync. Her ikisi de açıktır getDatave fs.readFileSyncsenkronizasyon işlevleridir. Bir gün, temeldeki veri kaynağını yalnızca eşzamansız olarak erişilebilen MongoDB gibi bir depoya geçirmeniz söylendi. Ayrıca kullanıcılarınızı kızdırmaktan kaçınmanız söylendi, getDataAPI yalnızca bir söz verecek veya bir geri arama parametresi talep edecek şekilde değiştirilemez. Her iki gereksinimi nasıl karşılıyorsunuz?

Geri arama / söz kullanan asenkron işlev, JavasSript ve Node.js'nin DNA'sıdır. Önemsiz olmayan herhangi bir JS uygulamasına muhtemelen bu kodlama stiline nüfuz edilmiştir. Ancak bu uygulama, sözde geri arama piramidine kolayca yol açabilir. Daha da kötüsü, çağrı zincirindeki herhangi bir arayıcıdaki herhangi bir kod zaman uyumsuz işlevin sonucuna bağlıysa, bu kodun da geri arama işlevine sarılması gerekir, bu da arayana bir kodlama stili kısıtlaması getirir. Zaman zaman, devasa global yeniden faktörlemeden kaçınmak için bir eşzamansız işlevi (genellikle bir 3. taraf kitaplığında sağlanır) bir eşitleme işlevine kapsülleme ihtiyacını buluyorum. Bu konuda bir çözüm aramak genellikle Node Fibers ile sonuçlandıveya ondan türetilen npm paketleri. Ancak Fibers karşılaştığım sorunu çözemiyor. Fibers'in yazarının sağladığı örnek bile eksikliği gösterdi:

...
Fiber(function() {
    console.log('wait... ' + new Date);
    sleep(1000);
    console.log('ok... ' + new Date);
}).run();
console.log('back in main');

Gerçek çıktı:

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
back in main
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)

Fiber işlevi, eşzamansız işlev uykusunu gerçekten eşzamanlı hale getiriyorsa, çıktı şu şekilde olmalıdır:

wait... Fri Jan 21 2011 22:42:04 GMT+0900 (JST)
ok... Fri Jan 21 2011 22:42:05 GMT+0900 (JST)
back in main

JSFiddle'da başka bir basit örnek oluşturdum ve beklenen çıktıyı verecek kod aradım . Yalnızca Node.js'de çalışan bir çözümü kabul edeceğim, böylece JSFiddle'da çalışmamasına rağmen herhangi bir npm paketine ihtiyaç duymakta özgürsünüz.

deasync , JavaScript katmanında Node.js olay döngüsünü çağırarak bir engelleme mekanizmasıyla uygulanan eşzamansız işlevi senkronizasyona dönüştürür. Sonuç olarak, deasync yalnızca sonraki kodun tüm iş parçacığını engellemeden veya meşgul beklemeye maruz kalmadan çalışmasını engeller. Bu modülle, işte jsFiddle meydan okumasının cevabı:

function AnticipatedSyncFunction(){
  var ret;
  setTimeout(function(){
      ret = "hello";
  },3000);
  while(ret === undefined) {
    require('deasync').runLoopOnce();
  }
  return ret;    
}


var output = AnticipatedSyncFunction();
//expected: output=hello (after waiting for 3 sec)
console.log("output="+output);
//actual: output=hello (after waiting for 3 sec)

(sorumluluk reddi: adlı kitabın ortak yazarıyım deasync. Modül, bu soruyu gönderdikten sonra oluşturuldu ve uygulanabilir bir öneri bulamadı.)

Ayrıca bir npm senkronizasyon modülü de vardır. Sorguyu yürütme sürecini senkronize etmek için kullanılır.

Paralel sorguları eşzamanlı olarak çalıştırmak istediğinizde, düğüm bunu yapmak için kısıtlar çünkü yanıt için asla beklemez. ve senkronizasyon modülü bu tür bir çözüm için çok mükemmeldir.

Basit kod

/*require sync module*/
var Sync = require('sync');
    app.get('/',function(req,res,next){
      story.find().exec(function(err,data){
        var sync_function_data = find_user.sync(null, {name: "sanjeev"});
          res.send({story:data,user:sync_function_data});
        });
    });


    /*****sync function defined here *******/
    function find_user(req_json, callback) {
        process.nextTick(function () {

            users.find(req_json,function (err,data)
            {
                if (!err) {
                    callback(null, data);
                } else {
                    callback(null, err);
                }
            });
        });
    }

referans bağlantısı: https://www.npmjs.com/package/sync

İşlev Fiber gerçekten eşzamansız işlev uykusunu eşzamanlı hale getiriyorsa

Evet. Fiberin içinde, fonksiyon kayıt yapmadan önce bekler ok. Fiberler eşzamansız işlevleri eşzamanlı yapmazlar, ancak eşzamanlı olmayan işlevler kullanan eşzamanlı görünümlü kodların yazılmasına izin verir ve sonra bir Fiber.

Zaman zaman, büyük çaplı küresel yeniden faktörlemeden kaçınmak için bir eşzamansız işlevi bir senkronizasyon işlevine kapsülleme ihtiyacını buluyorum.

Yapamazsın. Eşzamansız kodu eşzamanlı yapmak imkansızdır. Bunu global kodunuzda tahmin etmeniz ve baştan itibaren asenkron tarzda yazmanız gerekecek. Global kodu bir fibere sarmanız, sözler, vaat oluşturucular veya basit geri aramalar kullanmanız tercihlerinize bağlıdır.

Amacım, veri toplama yöntemi senkronizasyondan zaman uyumsuzluğa değiştirildiğinde arayan üzerindeki etkiyi en aza indirmektir.

Hem sözler hem de lifler bunu yapabilir.

Sözleri kullanmalısın:

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async () => {
    return await asyncOperation();
}

const topDog = () => {
    asyncFunction().then((res) => {
        console.log(res);
    });
}

Ok işlevi tanımlarını daha çok seviyorum. Ancak "() => {...}" biçimindeki herhangi bir dizge, "function () {...}" olarak da yazılabilir

Dolayısıyla topDog, eşzamansız bir işlevi çağırmasına rağmen eşzamansız değildir.

DÜZENLEME: Zaman uyumsuz bir işlevi bir eşzamanlama işlevi içinde sarmalamanız gerektiğinin çoğu zaman bir denetleyicinin içinde olduğunun farkındayım. Bu durumlar için, işte bir parti numarası:

const getDemSweetDataz = (req, res) => {
    (async () => {
        try{
            res.status(200).json(
                await asyncOperation()
            );
        }
        catch(e){
            res.status(500).json(serviceResponse); //or whatever
        }
    })() //So we defined and immediately called this async function.
}

Bunu geri aramalarla kullanarak, vaatleri kullanmayan bir sarmalama yapabilirsiniz:

const asyncOperation = () => {
    return new Promise((resolve, reject) => {
        setTimeout(()=>{resolve("hi")}, 3000)
    })
}

const asyncFunction = async (callback) => {
    let res = await asyncOperation();
    callback(res);
}

const topDog = () => {
    let callback = (res) => {
        console.log(res);
    };

    (async () => {
        await asyncFunction(callback)
    })()
}

Bu numarayı bir EventEmiter'a uygulayarak aynı sonuçları elde edebilirsiniz. Geri aramayı tanımladığım EventEmitter dinleyicisini tanımlayın ve geri aramayı çağırdığım olayı yayınlayın.

Düğüm lifleri kullanılarak çözülemeyen bir senaryo bulamıyorum. Düğüm liflerini kullanarak sağladığınız örnek beklendiği gibi davranıyor. Önemli olan tüm ilgili kodu bir fiber içinde çalıştırmaktır, böylece rastgele pozisyonlarda yeni bir fibere başlamak zorunda kalmazsınız.

Bir örnek görelim: Uygulamanızın giriş noktası olan bazı çerçeve kullandığınızı varsayalım (bu çerçeveyi değiştiremezsiniz). Bu çerçeve nodejs modüllerini eklenti olarak yükler ve eklentiler üzerinde bazı yöntemleri çağırır. Bu çerçevenin yalnızca eşzamanlı işlevleri kabul ettiğini ve lifleri kendi başına kullanmadığını söyleyelim.

Eklentilerinizden birinde kullanmak istediğiniz bir kitaplık var, ancak bu kitaplık eşzamansızdır ve onu değiştirmek de istemezsiniz.

Hiçbir fiber çalışmadığında ana iş parçacığı verilemez, ancak yine de fiber kullanarak eklentiler oluşturabilirsiniz! Tüm çerçeveyi bir fiber içinde başlatan bir sarmalayıcı girişi oluşturun, böylece eklentilerden yürütmeyi sağlayabilirsiniz.

Dezavantajı: Çerçeve dahili olarak kullanıyorsa setTimeoutveya kullanıyorsa Promise, fiber bağlamdan kaçacaktır. Bu alay tarafından çalışılan setTimeout, Promise.thenve tüm olay işleyicileri.

Yani a Promiseçözülene kadar bu şekilde lif elde edebilirsiniz . Bu kod, zaman uyumsuz (Promise dönen) işlevi alır ve söz çözüldüğünde fiberi devam ettirir:

Çerçeve-entry.js

console.log(require("./my-plugin").run());

async-lib.js

exports.getValueAsync = () => {
  return new Promise(resolve => {
    setTimeout(() => {
      resolve("Async Value");
    }, 100);
  });
};

my-plugin.js

const Fiber = require("fibers");

function fiberWaitFor(promiseOrValue) {
  var fiber = Fiber.current, error, value;
  Promise.resolve(promiseOrValue).then(v => {
    error = false;
    value = v;
    fiber.run();
  }, e => {
    error = true;
    value = e;
    fiber.run();
  });
  Fiber.yield();
  if (error) {
    throw value;
  } else {
    return value;
  }
}

const asyncLib = require("./async-lib");

exports.run = () => {
  return fiberWaitFor(asyncLib.getValueAsync());
};

my-entry.js

require("fibers")(() => {
  require("./framework-entry");
}).run();

Eğer çalıştırdığınızda node framework-entry.jsbir hata atar: Error: yield() called with no fiber running. Çalıştırırsanız node my-entry.jsbeklendiği gibi çalışır.

Node.js kod senkronizasyonunun yapılması, veritabanı gibi birkaç açıdan önemlidir. Ancak Node.js'nin gerçek avantajı eşzamansız kodda yatmaktadır. Tek iş parçacığı tıkanmaz olduğu için.

önemli işlevselliği kullanarak senkronize edebiliriz Fiber () Kullanın await () ve defer () await () kullanarak tüm yöntemleri çağırırız. daha sonra geri arama işlevlerini defer () ile değiştirin.

Normal Eşzamansız kod Bu, CallBack işlevlerini kullanır.

function add (var a, var b, function(err,res){
       console.log(res);
});

 function sub (var res2, var b, function(err,res1){
           console.log(res);
    });

 function div (var res2, var b, function(err,res3){
           console.log(res3);
    });

Fiber (), await () ve defer () kullanarak yukarıdaki kodu senkronize edin

fiber(function(){
     var obj1 = await(function add(var a, var b,defer()));
     var obj2 = await(function sub(var obj1, var b, defer()));
     var obj3 = await(function sub(var obj2, var b, defer()));

});

Umarım bu yardımcı olacak. Teşekkür ederim

Günümüzde bu jeneratör modeli birçok durumda bir çözüm olabilir.

Burada, eşzamansız readline.question işlevini kullanan düğümlerdeki sıralı konsol istemlerinin bir örneği:

var main = (function* () {

  // just import and initialize 'readline' in nodejs
  var r = require('readline')
  var rl = r.createInterface({input: process.stdin, output: process.stdout })

  // magic here, the callback is the iterator.next
  var answerA = yield rl.question('do you want this? ', r=>main.next(r))    

  // and again, in a sync fashion
  var answerB = yield rl.question('are you sure? ', r=>main.next(r))        

  // readline boilerplate
  rl.close()

  console.log(answerA, answerB)

})()  // <-- executed: iterator created from generator
main.next()     // kick off the iterator, 
                // runs until the first 'yield', including rightmost code
                // and waits until another main.next() happens

Elyafı oluşturan çağrı etrafında ne olduğuna değil , elyafın içinde ne olduğuna bakmalısınız . Fiberin içine girdikten sonra senkron tarzda programlayabilirsiniz. Örneğin:

function f1 () {
    console.log ('bekle ...' + yeni Tarih);
    uyku (1000);
    console.log ('tamam ...' + yeni Tarih);   
}

function f2 () {
    f1 ();
    f1 ();
}

Lif (işlev () {
    f2 ();
}).Çalıştırmak();

Lif İçinde Aramak f1, f2ve sleepsanki onlar senkronizasyon idi.

Tipik bir web uygulamasında, Fiber'i HTTP istek dağıtıcınızda oluşturacaksınız. Bunu yaptıktan sonra, tüm istek işleme mantığınızı, eşzamansız işlevleri (fs, veritabanları, vb.) Çağırsa bile, eşitleme stilinde yazabilirsiniz.

İlk başta node.js ile bununla uğraştım ve async.js, bununla başa çıkmanıza yardımcı olmak için bulduğum en iyi kitaplık. Düğüm ile eşzamanlı kod yazmak istiyorsanız, yaklaşım bu şekildedir.

var async = require('async');

console.log('in main');

doABunchOfThings(function() {
  console.log('back in main');
});

function doABunchOfThings(fnCallback) {
  async.series([
    function(callback) {
      console.log('step 1');
      callback();
    },
    function(callback) {
      setTimeout(callback, 1000);
    },
    function(callback) {
      console.log('step 2');
      callback();
    },
    function(callback) {
      setTimeout(callback, 2000);
    },
    function(callback) {
      console.log('step 3');
      callback();
    },
  ], function(err, results) {
    console.log('done with things');
    fnCallback();
  });
}

bu program DAİMA aşağıdakileri üretecektir ...

in main
step 1
step 2
step 3
done with things
back in main

Javascript tek iş parçacıklı bir dildir, tüm sunucunuzu engellemek istemezsiniz! Zaman uyumsuz kod, bağımlılıkları açık hale getirerek yarış koşullarını ortadan kaldırır.

Eşzamansız kodu sevmeyi öğrenin!

Bir promisesgeri arama cehennemi piramidi oluşturmadan zaman uyumsuz koda bir göz atın . Node.js için promiseQ kitaplığını öneririm

httpGet(url.parse("http://example.org/")).then(function (res) {
    console.log(res.statusCode);  // maybe 302
    return httpGet(url.parse(res.headers["location"]));
}).then(function (res) {
    console.log(res.statusCode);  // maybe 200
});

http://howtonode.org/promises

DÜZENLEME: Bu, açık ara en tartışmalı cevabım, node'un artık verim anahtar kelimesi var, bu da eşzamansız kodu eşzamanlıymış gibi ele almanıza izin veriyor. http://blog.alexmaccaw.com/how-yield-will-transform-node