Beispielerklärung der asynchronen Verarbeitung unter ES6

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:

1. Verwenden Sie fs.readdir, um die Inhaltsinformationen des angegebenen Verzeichnisses abzurufen

2. Durchlaufen Sie die Inhaltsinformationen und verwenden Sie fs.stat, um die spezifischen Informationen der Datei oder des Verzeichnisses abzurufen

3. Speichern Sie die spezifischen Informationen

4. Wenn alle gespeichert sind, filtern Sie die Dateiinformationen

5. Durchsuchen und vergleichen, um die größte Datei zu finden

6. 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)])
                }
            })
        })
    })
}

wird verwendet als:

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

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)]
        })

}

wird verwendet als:

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

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)]

}

Verwendungsmethode ist:

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

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)]

}

Verwendungsmethode ist:

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

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!