Beispielerklärung der asynchronen Verarbeitung unter ES6-js-Tutorial-php.cn

Beispielerklärung der asynchronen Verarbeitung unter ES6

不言

Freigeben： 2018-10-25 16:04:15

nach vorne

1439 Leute haben es durchsucht

Dieser Artikel bietet Ihnen eine beispielhafte Erklärung der asynchronen Verarbeitung unter ES6. Ich hoffe, dass er für Freunde in Not hilfreich ist.

Vorwort

Nehmen wir als Beispiel die Rückruffunktion von

-> Promise ->

Änderungen in der asynchronen Verarbeitung.

API-Einführung

Um diese Funktion zu implementieren, müssen wir mehrere Nodejs-APIs verwenden, also stellen wir sie kurz vor.

fs.readdir

readdir-Methode wird zum Lesen eines Verzeichnisses verwendet und gibt ein Array mit Dateien und Verzeichnissen zurück.

fs.stat

Der Parameter der stat-Methode ist eine Datei oder ein Verzeichnis und generiert ein Objekt, das spezifische Informationen über die Datei oder das Verzeichnis enthält. Darüber hinaus verfügt das Objekt auch über eine isFile()-Methode, die feststellen kann, ob es sich um eine Datei oder ein Verzeichnis handelt, das verarbeitet wird.

Ideenanalyse

Unsere grundlegende Implementierungsidee ist:

Verwenden Sie fs.readdir, um die Inhaltsinformationen des angegebenen Verzeichnisses abzurufen
Durchlaufen Sie die Inhaltsinformationen und verwenden Sie fs.stat, um die spezifischen Informationen der Datei oder des Verzeichnisses abzurufen
Speichern Sie die spezifischen Informationen
Wenn alle gespeichert sind, filtern Sie die Dateiinformationen
Durchsuchen und vergleichen, um die größte Datei zu finden
Holen Sie sich die Datei und geben Sie sie zurück größte Datei

Dann gehen wir direkt zum Code.

Rückruffunktion

var fs = require('fs');
var path = require('path');

function findLargest(dir, cb) {
    // 读取目录下的所有文件
    fs.readdir(dir, function(er, files) {
        if (er) return cb(er);

        var counter = files.length;
        var errored = false;
        var stats = [];

        files.forEach(function(file, index) {
            // 读取文件信息
            fs.stat(path.join(dir, file), function(er, stat) {

                if (errored) return;

                if (er) {
                    errored = true;
                    return cb(er);
                }

                stats[index] = stat;

                // 事先算好有多少个文件，读完 1 个文件信息，计数减 1，当为 0 时，说明读取完毕，此时执行最终的比较操作
                if (--counter == 0) {

                    var largest = stats
                        .filter(function(stat) { return stat.isFile() })
                        .reduce(function(prev, next) {
                            if (prev.size > next.size) return prev
                            return next
                        })

                    cb(null, files[stats.indexOf(largest)])
                }
            })
        })
    })
}

Nach dem Login kopieren

wird verwendet als:

// 查找当前目录最大的文件
findLargest('./', function(er, filename) {
    if (er) return console.error(er)
    console.log('largest file was:', filename)
});

Nach dem Login kopieren

Versprechen

var fs = require('fs');
var path = require('path');

var readDir = function(dir) {
    return new Promise(function(resolve, reject) {
        fs.readdir(dir, function(err, files) {
            if (err) reject(err);
            resolve(files)
        })
    })
}

var stat = function(path) {
    return new Promise(function(resolve, reject) {
        fs.stat(path, function(err, stat) {
            if (err) reject(err)
            resolve(stat)
        })
    })
}

function findLargest(dir) {
    return readDir(dir)
        .then(function(files) {
            let promises = files.map(file => stat(path.join(dir, file)))
            return Promise.all(promises).then(function(stats) {
                return { stats, files }
            })
        })
        .then(data => {

            let largest = data.stats
                .filter(function(stat) { return stat.isFile() })
                .reduce((prev, next) => {
                    if (prev.size > next.size) return prev
                    return next
                })

            return data.files[data.stats.indexOf(largest)]
        })

}

Nach dem Login kopieren

wird verwendet als:

findLargest('./')
.then(function(filename) {
    console.log('largest file was:', filename);
})
.catch(function() {
    console.log(error);
});

Nach dem Login kopieren

Generator

var fs = require('fs');
var path = require('path');

var co = require('co')

var readDir = function(dir) {
    return new Promise(function(resolve, reject) {
        fs.readdir(dir, function(err, files) {
            if (err) reject(err);
            resolve(files)
        })
    })
}

var stat = function(path) {
    return new Promise(function(resolve, reject) {
        fs.stat(path, function(err, stat) {
            if (err) reject(err)
            resolve(stat)
        })
    })
}

function* findLargest(dir) {
    var files = yield readDir(dir);
    var stats = yield files.map(function(file) {
        return stat(path.join(dir, file))
    })

    let largest = stats
        .filter(function(stat) { return stat.isFile() })
        .reduce((prev, next) => {
            if (prev.size > next.size) return prev
            return next
        })

    return files[stats.indexOf(largest)]

}

Nach dem Login kopieren

Verwendungsmethode ist:

co(findLargest, './')
.then(function(filename) {
    console.log('largest file was:', filename);
})
.catch(function() {
    console.log(error);
});

Nach dem Login kopieren

Async

var fs = require('fs');
var path = require('path');

var readDir = function(dir) {
    return new Promise(function(resolve, reject) {
        fs.readdir(dir, function(err, files) {
            if (err) reject(err);
            resolve(files)
        })
    })
}

var stat = function(path) {
    return new Promise(function(resolve, reject) {
        fs.stat(path, function(err, stat) {
            if (err) reject(err)
            resolve(stat)
        })
    })
}

async function findLargest(dir) {
    var files = await readDir(dir);

    let promises = files.map(file => stat(path.join(dir, file)))
    var stats = await Promise.all(promises)

    let largest = stats
        .filter(function(stat) { return stat.isFile() })
        .reduce((prev, next) => {
            if (prev.size > next.size) return prev
            return next
        })

    return files[stats.indexOf(largest)]

}

Nach dem Login kopieren

Verwendungsmethode ist:

findLargest('./')
.then(function(filename) {
    console.log('largest file was:', filename);
})
.catch(function() {
    console.log(error);
});

Nach dem Login kopieren

https://github.com/mqyqingfeng/Blog

Das obige ist der detaillierte Inhalt vonBeispielerklärung der asynchronen Verarbeitung unter ES6. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!