async

Async — это модуль утилит, который предоставляет простые в использовании, но мощные функции для работы с асинхронным JavaScript. Хотя первоначально он был разработан для использования с Node.js и устанавливается через npm install --save async, он также может быть использован непосредственно в браузере.

Источник:

index.js, строка 40

См.:

AsyncFunction

Коллекции

Набор async функций для управления коллекциями, такими как массивы и объекты.

Источник:

index.js, строка 50

Методы

(статический) concat(coll, iteratee, callbackопционально)

import concat from 'async/concat';

Применяет iteratee к каждому элементу в coll, конкатенируя результаты. Возвращает объединённый список. iteratee вызываются параллельно, а результаты конкатенируются по мере их возвращения. Массив результатов будет возвращён в исходном порядке coll , переданных функции iteratee.

Псевдоним:

flatMap

Параметры:

Возвращает:

Пример

async.concat(['dir1','dir2','dir3'], fs.readdir, function(err, files) {
    // files is now a list of filenames that exist in the 3 directories
});

Источник:

concat.js, строка 4

(статический) concatLimit(coll, limit, iteratee, callbackопционально)

import concatLimit from 'async/concatLimit';

Аналогично concat, но выполняет не более limit асинхронных операций одновременно.

Псевдоним:

flatMapLimit

Параметры:

Возвращает:

Источник:

concatLimit.js, строка 5

См.:

async.concat

(статический) concatSeries(coll, iteratee, callbackопционально)

import concatSeries from 'async/concatSeries';

Аналогично concat, но выполняет только по одной асинхронной операции за раз.

Псевдоним:

flatMapSeries

Параметры:

Возвращает:

Источник:

concatSeries.js, строка 4

См.:

async.concat

(статический) detect(coll, iteratee, callbackопционально)

import detect from 'async/detect';

Возвращает первое значение в coll, которое проходит асинхронную проверку истинности. iteratee применяется параллельно, что означает, что первая функция iteratee, возвратившая true, вызовет обратный вызов detect callback с этим результатом. Это означает, что результат может не быть первым элементом в исходном coll (с точки зрения порядка), который проходит проверку. Если порядок в исходном coll важен, то обратите внимание на detectSeries.

Псевдоним:

find

Параметры:

Возвращает:

Пример

async.detect(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // result now equals the first file in the list that exists
});

Источник:

detect.js, строка 5

(статический) detectLimit(coll, limit, iteratee, callbackопционально)

import detectLimit from 'async/detectLimit';

Аналогично detect, но выполняет не более limit асинхронных операций одновременно.

Псевдоним:

findLimit

Параметры:

Возвращаемое значение:

Источник:

detectLimit.js, строка 5

См.:

async.detect

(статический) detectSeries(coll, iteratee, callbackопционально)

import detectSeries from 'async/detectSeries';

То же самое, что и detect, но выполняет только одну асинхронную операцию за раз.

Псевдоним:

findSeries

Параметры:

Возвращаемое значение:

Источник:

detectSeries.js, строка 5

См.:

async.detect

(статический) each(coll, iteratee, callbackопционально) → {Promise}

import each from 'async/each';

Применяет функцию iteratee к каждому элементу в coll, параллельно. Функция iteratee вызывается с элементом из списка и коллбэком, когда она завершена. Если функция iteratee передаёт ошибку в свой коллбэк, основная функция callback (для функции each) немедленно вызывается с ошибкой.

Обратите внимание, что поскольку эта функция применяет iteratee к каждому элементу параллельно, нет гарантии, что функции-итераторы завершатся в порядке.

Псевдоним:

forEach

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

// assuming openFiles is an array of file names and saveFile is a function
// to save the modified contents of that file:

async.each(openFiles, saveFile, function(err){
  // if any of the saves produced an error, err would equal that error
});

// assuming openFiles is an array of file names
async.each(openFiles, function(file, callback) {

    // Perform operation on file here.
    console.log('Processing file ' + file);

    if( file.length > 32 ) {
      console.log('This file name is too long');
      callback('File name too long');
    } else {
      // Do work to process file here
      console.log('File processed');
      callback();
    }
}, function(err) {
    // if any of the file processing produced an error, err would equal that error
    if( err ) {
      // One of the iterations produced an error.
      // All processing will now stop.
      console.log('A file failed to process');
    } else {
      console.log('All files have been processed successfully');
    }
});

Источник:

each.js, строка 6

(статический) eachLimit(coll, limit, iteratee, callbackопционально) → {Promise}

import eachLimit from 'async/eachLimit';

То же самое, что и each, но выполняет не более limit асинхронных операций одновременно.

Псевдоним:

forEachLimit

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

eachLimit.js, строка 6

См.:

async.each

(статический) eachOf(coll, iteratee, callbackопционально) → {Promise}

import eachOf from 'async/eachOf';

Как each, за исключением того, что ключ (или индекс) передаётся в качестве второго аргумента в функцию-итератор.

Псевдоним:

forEachOf

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

var obj = {dev: "/dev.json", test: "/test.json", prod: "/prod.json"};
var configs = {};

async.forEachOf(obj, function (value, key, callback) {
    fs.readFile(__dirname + value, "utf8", function (err, data) {
        if (err) return callback(err);
        try {
            configs[key] = JSON.parse(data);
        } catch (e) {
            return callback(e);
        }
        callback();
    });
}, function (err) {
    if (err) console.error(err.message);
    // configs is now a map of JSON data
    doSomethingWith(configs);
});

Источник:

eachOf.js, строка 42

См.:

async.each

(статический) eachOfLimit(coll, limit, iteratee, callbackопционально) → {Promise}

import eachOfLimit from 'async/eachOfLimit';

То же самое, что и eachOf, но выполняет не более limit асинхронных операций за раз.

Псевдоним:

forEachOfLimit

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

eachOfLimit.js, строка 5

См. также:

async.eachOf

(static) eachOfSeries(coll, iteratee, callbackopt) → {Promise}

import eachOfSeries from 'async/eachOfSeries';

То же самое, что и eachOf, но выполняется только одна асинхронная операция за раз.

Псевдоним:

forEachOfSeries

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

eachOfSeries.js, строка 4

См. также:

async.eachOf

(static) eachSeries(coll, iteratee, callbackopt) → {Promise}

import eachSeries from 'async/eachSeries';

То же самое, что и each, но выполняется только одна асинхронная операция за раз.

Обратите внимание, что в отличие от each, эта функция применяет iteratee к каждому элементу последовательно, и поэтому функции iteratee будут выполняться в порядке следования.

Псевдоним:

forEachSeries

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

eachSeries.js, строка 4

См. также:

async.each

(static) every(coll, iteratee, callbackopt) → {Promise}

import every from 'async/every';

Возвращает true если каждый элемент в coll удовлетворяет асинхронному тесту. Если любая функция iteratee возвращает false, основной callback вызывается немедленно.

Псевдоним:

all

Параметры:

Возвращаемое значение:

Пример

async.every(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // if result is true then every file exists
});

Источник:

every.js, строка 5

(static) everyLimit(coll, limit, iteratee, callbackopt) → {Promise}

import everyLimit from 'async/everyLimit';

То же самое, что и every, но выполняет не более limit асинхронных операций за раз.

Псевдоним:

allLimit

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

everyLimit.js, строка 5

См. также:

async.every

(static) everySeries(coll, iteratee, callbackopt) → {Promise}

import everySeries from 'async/everySeries';

То же самое, что и every, но выполняет только одну асинхронную операцию за раз.

Псевдоним:

allSeries

Параметры:

Возвращает:

Тип

Promise

Источник:

everySeries.js, строка 5

См. также:

async.every

(static) filter(coll, iteratee, callbackopt) → {Promise}

import filter from 'async/filter';

Возвращает новый массив всех значений в coll, которые проходят асинхронную проверку истинности. Эта операция выполняется параллельно, но массив результатов будет в том же порядке, что и исходный.

Псевдоним:

select

Параметры:

Возвращает:

Тип

Promise

Пример

async.filter(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, results) {
    // results now equals an array of the existing files
});

Источник:

filter.js, строка 5

(static) filterLimit(coll, limit, iteratee, callbackopt) → {Promise}

import filterLimit from 'async/filterLimit';

То же самое, что и filter, но выполняет не более limit асинхронных операций одновременно.

Псевдоним:

selectLimit

Параметры:

Возвращает:

Тип

Promise

Источник:

filterLimit.js, строка 5

См. также:

async.filter

(static) filterSeries(coll, iteratee, callbackopt) → {Promise}

import filterSeries from 'async/filterSeries';

То же самое, что и filter, но выполняет только одну асинхронную операцию за раз.

Псевдоним:

selectSeries

Параметры:

Возвращает:

Тип

Promise

Источник:

filterSeries.js, строка 5

См. также:

async.filter

(static) groupBy(coll, iteratee, callbackopt) → {Promise}

import groupBy from 'async/groupBy';

Возвращает новый объект, где каждое значение соответствует массиву элементов из coll, которые вернули соответствующий ключ. То есть, ключи объекта соответствуют значениям, переданным в iteratee обратный вызов.

Примечание: Поскольку эта функция применяет iteratee к каждому элементу параллельно, нет гарантии, что iteratee функции завершатся в порядке. Однако значения для каждого ключа в result будут в том же порядке, что и исходный coll. Для объектов, значения будут приблизительно в порядке исходных ключей объектов (но это может меняться в разных движках JavaScript).

Параметры:

Возвращает:

Тип

Promise

Пример

async.groupBy(['userId1', 'userId2', 'userId3'], function(userId, callback) {
    db.findById(userId, function(err, user) {
        if (err) return callback(err);
        return callback(null, user.age);
    });
}, function(err, result) {
    // result is object containing the userIds grouped by age
    // e.g. { 30: ['userId1', 'userId3'], 42: ['userId2']};
});

Источник:

groupBy.js, строка 3

(статический) groupByLimit(coll, limit, iteratee, callbackнеобязательно) → {Promise}

import groupByLimit from 'async/groupByLimit';

То же самое, что и groupBy, но выполняет не более limit асинхронных операций одновременно.

Параметры:

Возвращаемое значение:

Тип

Обещание

Источник:

groupByLimit.js, строка 5

См.:

async.groupBy

(статический) groupBySeries(coll, iteratee, callbackнеобязательно) → {Promise}

import groupBySeries from 'async/groupBySeries';

То же самое, что и groupBy, но выполняет только одну асинхронную операцию за раз.

Параметры:

Возвращаемое значение:

Тип

Обещание

Источник:

groupBySeries.js, строка 3

См.:

async.groupBy

(статический) map(coll, iteratee, callbackнеобязательно) → {Promise}

import map from 'async/map';

Создает новую коллекцию значений, отображая каждое значение в coll через функцию iteratee. Функция iteratee вызывается с элементом из coll и обратным вызовом, когда она завершила обработку. Каждый из этих обратных вызовов принимает 2 аргумента: error, и преобразованный элемент из coll. Если iteratee передает ошибку в свой обратный вызов, основной callback (для функции map) немедленно вызывается с ошибкой.

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

Если map получает объект, результаты будут массивом. Результаты будут примерно в порядке исходных ключей объекта (но это может варьироваться в разных движках JavaScript).

Параметры:

Возвращаемое значение:

Тип

Обещание

Пример

async.map(['file1','file2','file3'], fs.stat, function(err, results) {
    // results is now an array of stats for each file
});

Источник:

map.js, строка 5

(статический) mapLimit(coll, limit, iteratee, callbackнеобязательно) → {Promise}

import mapLimit from 'async/mapLimit';

То же самое, что и map, но выполняет не более limit асинхронных операций одновременно.

Параметры:

Возвращаемое значение:

Тип

Обещание

Источник:

mapLimit.js, строка 5

См.:

async.map

(статический) mapSeries(coll, iteratee, callbackнеобязательно) → {Promise}

import mapSeries from 'async/mapSeries';

То же самое, что и map, но выполняет только одну асинхронную операцию за раз.

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

mapSeries.js, строка 5

См. также:

async.map

(статический) mapValues(obj, iteratee, callbackнеобязательно) → {Promise}

import mapValues from 'async/mapValues';

Аналог map, предназначенный для работы с объектами.

Создаёт новый объект, отображая каждое значение obj через функцию iteratee. Функция iteratee вызывается для каждого value и key из obj и коллбэка для завершения обработки. Каждый из этих коллбэков принимает два аргумента: error, и преобразованный элемент из obj. Если iteratee передаёт ошибку своему коллбэку, основной коллбэк (для функции mapValues ) немедленно вызывается с ошибкой.

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

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

async.mapValues({
    f1: 'file1',
    f2: 'file2',
    f3: 'file3'
}, function (file, key, callback) {
  fs.stat(file, callback);
}, function(err, result) {
    // result is now a map of stats for each file, e.g.
    // {
    //     f1: [stats for file1],
    //     f2: [stats for file2],
    //     f3: [stats for file3]
    // }
});

Источник:

mapValues.js, строка 3

(статический) mapValuesLimit(obj, limit, iteratee, callbackнеобязательно) → {Promise}

import mapValuesLimit from 'async/mapValuesLimit';

То же, что и mapValues, но выполняет максимум limit асинхронных операций одновременно.

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

mapValuesLimit.js, строка 6

См. также:

async.mapValues

(статический) mapValuesSeries(obj, iteratee, callbackнеобязательно) → {Promise}

import mapValuesSeries from 'async/mapValuesSeries';

То же, что и mapValues, но выполняет только одну асинхронную операцию за раз.

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

mapValuesSeries.js, строка 3

См. также:

async.mapValues

(статический) reduce(coll, memo, iteratee, callbackнеобязательно) → {Promise}

import reduce from 'async/reduce';

Редуцирует coll до единственного значения, используя асинхронную iteratee для возврата каждого следующего шага. memo — начальное состояние редукции. Эта функция работает только в последовательном режиме.

По соображениям производительности, может быть целесообразно разбить вызов этой функции на параллельный map, а затем использовать обычный Array.prototype.reduce на результатах. Эта функция предназначена для ситуаций, когда каждый шаг редукции требует асинхронности; если вы можете получить данные до редукции, то, вероятно, это хорошая идея.

Псевдоним:

foldl

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

async.reduce([1,2,3], 0, function(memo, item, callback) {
    // pointless async:
    process.nextTick(function() {
        callback(null, memo + item)
    });
}, function(err, result) {
    // result is now equal to the last value of memo, which is 6
});

Источник:

reduce.js, строка 6

(статический) reduceRight(array, memo, iteratee, callbackдоп) → {Promise}

import reduceRight from 'async/reduceRight';

То же, что и reduce, но работает с array в обратном порядке.

Псевдоним:

foldr

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

reduceRight.js, строка 3

См.:

async.reduce

(статический) reject(coll, iteratee, callbackдоп) → {Promise}

import reject from 'async/reject';

Обратная функция filter. Удаляет значения, которые проходят async проверку истинности.

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

async.reject(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, results) {
    // results now equals an array of missing files
    createFiles(results);
});

Источник:

reject.js, строка 5

См.:

async.filter

(статический) rejectLimit(coll, limit, iteratee, callbackдоп) → {Promise}

import rejectLimit from 'async/rejectLimit';

То же, что и reject, но выполняет не более limit асинхронных операций одновременно.

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

rejectLimit.js, строка 4

См.:

async.reject

(статический) rejectSeries(coll, iteratee, callbackдоп) → {Promise}

import rejectSeries from 'async/rejectSeries';

То же, что и reject, но выполняет только одну асинхронную операцию за раз.

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

rejectSeries.js, строка 5

См.:

async.reject

(статический) some(coll, iteratee, callbackдоп) → {Promise}

import some from 'async/some';

Возвращает true , если хотя бы один элемент в coll удовлетворяет асинхронному тесту. Если любой вызов iteratee возвращает true, основная callback немедленно вызывается.

Псевдоним:

any

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

async.some(['file1','file2','file3'], function(filePath, callback) {
    fs.access(filePath, function(err) {
        callback(null, !err)
    });
}, function(err, result) {
    // if result is true then at least one of the files exists
});

Источник:

some.js, строка 5

(static) someLimit(coll, limit, iteratee, callbackopt) → {Promise}

import someLimit from 'async/someLimit';

То же самое, что и some, но выполняет не более limit асинхронных операций одновременно.

Псевдоним:

anyLimit

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

someLimit.js, строка 5

См.:

async.some

(static) someSeries(coll, iteratee, callbackopt) → {Promise}

import someSeries from 'async/someSeries';

То же самое, что и some, но выполняет только одну асинхронную операцию за раз.

Псевдоним:

anySeries

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

someSeries.js, строка 5

См.:

async.some

(static) sortBy(coll, iteratee, callback) → {Promise}

import sortBy from 'async/sortBy';

Сортирует список по результатам применения каждого coll значения через асинхронную iteratee.

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

async.sortBy(['file1','file2','file3'], function(file, callback) {
    fs.stat(file, function(err, stats) {
        callback(err, stats.mtime);
    });
}, function(err, results) {
    // results is now the original array of files sorted by
    // modified date
});

// By modifying the callback parameter the
// sorting order can be influenced:

// ascending order
async.sortBy([1,9,3,5], function(x, callback) {
    callback(null, x);
}, function(err,result) {
    // result callback
});

// descending order
async.sortBy([1,9,3,5], function(x, callback) {
    callback(null, x*-1);    //<- x*-1 instead of x, turns the order around
}, function(err,result) {
    // result callback
});

Источник:

sortBy.js, строка 5

(static) transform(coll, accumulatoropt, iteratee, callbackopt) → {Promise}

import transform from 'async/transform';

Аналог reduce. Принимает объект или массив и итерирует по каждому элементу параллельно, каждый шаг потенциально изменяет значение accumulator. Тип аккумулятора по умолчанию совпадает с типом переданной коллекции.

Параметры:

Возвращаемое значение:

Тип

Promise

Примеры

async.transform([1,2,3], function(acc, item, index, callback) {
    // pointless async:
    process.nextTick(function() {
        acc[index] = item * 2
        callback(null)
    });
}, function(err, result) {
    // result is now equal to [2, 4, 6]
});

async.transform({a: 1, b: 2, c: 3}, function (obj, val, key, callback) {
    setImmediate(function () {
        obj[key] = val * 2;
        callback();
    })
}, function (err, result) {
    // result is equal to {a: 2, b: 4, c: 6}
})

Источник:

transform.js, строка 6

Поток управления

Коллекция async функций для управления потоком выполнения скрипта.

Источник:

index.js, строка 56

Методы

(static) applyEach(fns, …argsopt, callbackopt) → {AsyncFunction}

import applyEach from 'async/applyEach';

Применяет предоставленные аргументы к каждой функции в массиве, вызывая callback после завершения всех функций. Если вы предоставляете только первый аргумент, fns, то она вернет функцию, которая позволит вам передать аргументы так, как будто это был единый вызов функции. Если предоставлено больше аргументов, callback требуется, в то время как args все еще необязательно. Результаты каждой примененной асинхронной функции передаются в конечный обратный вызов в виде массива.

Параметры:

Возвращаемое значение:

Тип

AsyncFunction

Пример

const appliedFn = async.applyEach([enableSearch, updateSchema], 'bucket')

appliedFn((err, results) => {
    // results[0] is the results for `enableSearch`
    // results[1] is the results for `updateSchema`
});

// partial application example:
async.each(
    buckets,
    async (bucket) => async.applyEach([enableSearch, updateSchema], bucket)(),
    callback
);

Источник:

applyEach.js, строка 4

(статический) applyEachSeries(fns, …argsопц, callbackопц) → {AsyncFunction}

import applyEachSeries from 'async/applyEachSeries';

То же самое, что и applyEach, но выполняет только одну асинхронную операцию за раз.

Параметры:

Возвращаемое значение:

Тип

AsyncFunction

Источник:

applyEachSeries.js, строка 4

См. также:

async.applyEach

(статический) auto(tasks, concurrencyопц, callbackопц) → {Promise}

import auto from 'async/auto';

Определяет лучший порядок выполнения AsyncFunction в tasks, на основе их требований. Каждая функция может необязательно зависеть от завершения других функций, и каждая функция выполняется как только удовлетворяются ее требования.

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

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

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

async.auto({
    // this function will just be passed a callback
    readData: async.apply(fs.readFile, 'data.txt', 'utf-8'),
    showData: ['readData', function(results, cb) {
        // results.readData is the file's contents
        // ...
    }]
}, callback);

async.auto({
    get_data: function(callback) {
        console.log('in get_data');
        // async code to get some data
        callback(null, 'data', 'converted to array');
    },
    make_folder: function(callback) {
        console.log('in make_folder');
        // async code to create a directory to store a file in
        // this is run at the same time as getting the data
        callback(null, 'folder');
    },
    write_file: ['get_data', 'make_folder', function(results, callback) {
        console.log('in write_file', JSON.stringify(results));
        // once there is some data and the directory exists,
        // write the data to a file in the directory
        callback(null, 'filename');
    }],
    email_link: ['write_file', function(results, callback) {
        console.log('in email_link', JSON.stringify(results));
        // once the file is written let's email a link to it...
        // results.write_file contains the filename returned by write_file.
        callback(null, {'file':results.write_file, 'email':'user@example.com'});
    }]
}, function(err, results) {
    console.log('err = ', err);
    console.log('results = ', results);
});

Источник:

auto.js, строка 6

(статический) autoInject(tasks, callbackопц) → {Promise}

import autoInject from 'async/autoInject';

Версия async.auto с инъекцией зависимостей. Зависимые задачи указываются как параметры функции, после обычного параметра обратного вызова, с именами параметров, соответствующими именам задач, от которых они зависят. Это может сделать графики задач более читаемыми и удобными для поддержки.

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

Функция autoInject — это чисто синтаксический сахар, и ее семантика в остальном эквивалентна async.auto.

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

//  The example from `auto` can be rewritten as follows:
async.autoInject({
    get_data: function(callback) {
        // async code to get some data
        callback(null, 'data', 'converted to array');
    },
    make_folder: function(callback) {
        // async code to create a directory to store a file in
        // this is run at the same time as getting the data
        callback(null, 'folder');
    },
    write_file: function(get_data, make_folder, callback) {
        // once there is some data and the directory exists,
        // write the data to a file in the directory
        callback(null, 'filename');
    },
    email_link: function(write_file, callback) {
        // once the file is written let's email a link to it...
        // write_file contains the filename returned by write_file.
        callback(null, {'file':write_file, 'email':'user@example.com'});
    }
}, function(err, results) {
    console.log('err = ', err);
    console.log('email_link = ', results.email_link);
});

// If you are using a JS minifier that mangles parameter names, `autoInject`
// will not work with plain functions, since the parameter names will be
// collapsed to a single letter identifier.  To work around this, you can
// explicitly specify the names of the parameters your task function needs
// in an array, similar to Angular.js dependency injection.

// This still has an advantage over plain `auto`, since the results a task
// depends on are still spread into arguments.
async.autoInject({
    //...
    write_file: ['get_data', 'make_folder', function(get_data, make_folder, callback) {
        callback(null, 'filename');
    }],
    email_link: ['write_file', function(write_file, callback) {
        callback(null, {'file':write_file, 'email':'user@example.com'});
    }]
    //...
}, function(err, results) {
    console.log('err = ', err);
    console.log('email_link = ', results.email_link);
});

Источник:

autoInject.js, строка 25

См. также:

async.auto

(статический) cargo(worker, payloadопц) → {QueueObject}

import cargo from 'async/cargo';

Создает объект cargo с указанным полезной нагрузкой. Задачи, добавленные в груз, будут обработаны вместе (до предела payload). Если обработка worker уже в процессе, задача помещается в очередь до тех пор, пока не станет доступной. После завершения обработки некоторых задач worker, вызывается каждый обратный вызов этих задач. Ознакомьтесь с этим анимированием для того, как cargo и queue работают.

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

Параметры:

Возвращаемое значение:

Тип

QueueObject

Пример

// create a cargo object with payload 2
var cargo = async.cargo(function(tasks, callback) {
    for (var i=0; i<tasks.length; i++) {
        console.log('hello ' + tasks[i].name);
    }
    callback();
}, 2);

// add some items
cargo.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
cargo.push({name: 'bar'}, function(err) {
    console.log('finished processing bar');
});
await cargo.push({name: 'baz'});
console.log('finished processing baz');

Источник:

cargo.js, строка 3

См.:

async.queue

(static) cargoQueue(worker, concurrencyopt, payloadopt) → {QueueObject}

import cargoQueue from 'async/cargoQueue';

Создает объект cargoQueue с указанным массивом задач. Задачи, добавленные в cargoQueue, будут обработаны вместе (до предела payload ) в concurrency параллельных рабочих процессах. Если все workers заняты, задача помещается в очередь до тех пор, пока один из них не освободится. После завершения обработки некоторых задач worker, вызывается каждый обратный вызов этих задач. Ознакомьтесь с этим анимированием для того, как cargo и queue работают.

В то время как queue передает только одну задачу одному из группы рабочих по очереди, и cargo передает массив задач одному рабочему, cargoQueue передает массив задач нескольким параллельным рабочим процессам.

Параметры:

Возвращаемое значение:

Тип

QueueObject

Пример

// create a cargoQueue object with payload 2 and concurrency 2
var cargoQueue = async.cargoQueue(function(tasks, callback) {
    for (var i=0; i<tasks.length; i++) {
        console.log('hello ' + tasks[i].name);
    }
    callback();
}, 2, 2);

// add some items
cargoQueue.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
cargoQueue.push({name: 'bar'}, function(err) {
    console.log('finished processing bar');
});
cargoQueue.push({name: 'baz'}, function(err) {
    console.log('finished processing baz');
});
cargoQueue.push({name: 'boo'}, function(err) {
    console.log('finished processing boo');
});

Источник:

cargoQueue.js, строка 3

См.:

async.queue

async.cargo

(static) compose(…functions) → {function}

import compose from 'async/compose';

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

Если последний аргумент составленной функции не является функцией, при ее вызове возвращается промис.

Каждая функция выполняется с this связыванием составленной функции.

Параметры:

Возвращаемое значение:

Тип

function

Пример

function add1(n, callback) {
    setTimeout(function () {
        callback(null, n + 1);
    }, 10);
}

function mul3(n, callback) {
    setTimeout(function () {
        callback(null, n * 3);
    }, 10);
}

var add1mul3 = async.compose(mul3, add1);
add1mul3(4, function (err, result) {
    // result now equals 15
});

Источник:

compose.js, строка 3

(static) doUntil(iteratee, test, callbackopt) → {Promise}

import doUntil from 'async/doUntil';

Подобно 'doWhilst', за исключением того, что test инвертирован. Обратите внимание на различие в порядке аргументов по сравнению с until.

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

doUntil.js, строка 4

См.:

async.doWhilst

(static) doWhilst(iteratee, test, callbackopt) → {Promise}

import doWhilst from 'async/doWhilst';

Версия с проверкой после выполнения whilst. Чтобы отразить разницу в порядке операций, аргументы test и iteratee поменяны местами.

doWhilst к whilst так же, как do while к while в обычном JavaScript.

Параметры:

Возвращает:

Тип

Promise

Источник:

doWhilst.js, строка 5

См.:

async.whilst

(статический) forever(fn, errbackнеобязательно) → {Promise}

import forever from 'async/forever';

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

Параметры:

Возвращает:

Тип

Promise

Пример

async.forever(
    function(next) {
        // next is suitable for passing to things that need a callback(err [, whatever]);
        // it will result in this function being called again.
    },
    function(err) {
        // if next is called with a value in its first parameter, it will appear
        // in here as 'err', and execution will stop.
    }
);

Источник:

forever.js, строка 6

(статический) parallel(tasks, callbackнеобязательно) → {Promise}

import parallel from 'async/parallel';

Выполните коллекцию функций tasks параллельно, не дожидаясь завершения предыдущей функции. Если любая из функций передаст ошибку в свой обратный вызов, основной callback немедленно вызывается с значением ошибки. После завершения всех tasks, результаты передаются в конечный callback как массив.

Примечание: parallel касается запуска задач ввода-вывода параллельно, а не параллельного выполнения кода. Если ваши задачи не используют таймеры или не выполняют ввод-вывод, они фактически будут выполняться последовательно. Любые синхронные настройки для каждой задачи будут выполняться одна за другой. JavaScript остается однопоточным.

Подсказка: Используйте reflect, чтобы продолжить выполнение других задач при сбое задачи.

Также можно использовать объект вместо массива. Каждый свойство будет выполняться как функция, а результаты будут переданы в конечный callback как объект вместо массива. Это может быть более читаемым способом обработки результатов из async.parallel.

Параметры:

Возвращает:

Тип

Promise

Пример

async.parallel([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
],
// optional callback
function(err, results) {
    // the results array will equal ['one','two'] even though
    // the second function had a shorter timeout.
});

// an example using an object instead of an array
async.parallel({
    one: function(callback) {
        setTimeout(function() {
            callback(null, 1);
        }, 200);
    },
    two: function(callback) {
        setTimeout(function() {
            callback(null, 2);
        }, 100);
    }
}, function(err, results) {
    // results is now equals to: {one: 1, two: 2}
});

Источник:

parallel.js, строка 4

(статический) parallelLimit(tasks, limit, callbackнеобязательно) → {Promise}

import parallelLimit from 'async/parallelLimit';

То же самое, что и parallel, но выполняет не более limit асинхронных операций одновременно.

Параметры:

Возвращает:

Тип

Promise

Источник:

parallelLimit.js, строка 4

См.:

async.parallel

(статический) priorityQueue(worker, concurrency) → {QueueObject}

import priorityQueue from 'async/priorityQueue';

То же самое, что и async.queue, только задачи получают приоритет и завершаются в порядке возрастания приоритета.

Параметры:

Возвращает:

Тип

QueueObject

Источник:

priorityQueue.js, строка 5

См.:

async.queue

(статический) queue(worker, concurrencyнеобязательно) → {QueueObject}

import queue from 'async/queue';

Создаёт объект queue со специфицированным concurrency. Задачи, добавленные в queue, обрабатываются параллельно (до предела concurrency). Если все worker находятся в процессе обработки, задача помещается в очередь до тех пор, пока не освободится ресурс. После завершения worker обработки task, вызывается обратный вызов task.

Параметры:

Возвращаемое значение:

Тип

QueueObject

Пример

// create a queue object with concurrency 2
var q = async.queue(function(task, callback) {
    console.log('hello ' + task.name);
    callback();
}, 2);

// assign a callback
q.drain(function() {
    console.log('all items have been processed');
});
// or await the end
await q.drain()

// assign an error callback
q.error(function(err, task) {
    console.error('task experienced an error');
});

// add some items to the queue
q.push({name: 'foo'}, function(err) {
    console.log('finished processing foo');
});
// callback is optional
q.push({name: 'bar'});

// add some items to the queue (batch-wise)
q.push([{name: 'baz'},{name: 'bay'},{name: 'bax'}], function(err) {
    console.log('finished processing item');
});

// add some items to the front of the queue
q.unshift({name: 'bar'}, function (err) {
    console.log('finished processing bar');
});

Источник:

queue.js, строка 89

(статический) race(tasks, callback)

import race from 'async/race';

Выполняет массив функций tasks параллельно, без ожидания завершения предыдущей функции. После завершения любой из функций или передачи ошибки в её обратный вызов, основной обратный вызов callback вызывается немедленно. Эквивалентно Promise.race().

Параметры:

Возвращаемое значение:

Пример

async.race([
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
],
// main callback
function(err, result) {
    // the result will be equal to 'two' as it finishes earlier
});

Источник:

race.js, строка 5

(статический) retry(optsopt, task, callbackopt) → {Promise}

import retry from 'async/retry';

Попытки получить успешный ответ от task не более times раз перед возвращением ошибки. Если задача выполнена успешно, callback получит результат успешной задачи. Если все попытки завершатся неудачно, обратный вызов получит ошибку и результат (если есть) последней попытки.

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

// The `retry` function can be used as a stand-alone control flow by passing
// a callback, as shown below:

// try calling apiMethod 3 times
async.retry(3, apiMethod, function(err, result) {
    // do something with the result
});

// try calling apiMethod 3 times, waiting 200 ms between each retry
async.retry({times: 3, interval: 200}, apiMethod, function(err, result) {
    // do something with the result
});

// try calling apiMethod 10 times with exponential backoff
// (i.e. intervals of 100, 200, 400, 800, 1600, ... milliseconds)
async.retry({
  times: 10,
  interval: function(retryCount) {
    return 50 * Math.pow(2, retryCount);
  }
}, apiMethod, function(err, result) {
    // do something with the result
});

// try calling apiMethod the default 5 times no delay between each retry
async.retry(apiMethod, function(err, result) {
    // do something with the result
});

// try calling apiMethod only when error condition satisfies, all other
// errors will abort the retry control flow and return to final callback
async.retry({
  errorFilter: function(err) {
    return err.message === 'Temporary error'; // only retry on a specific error
  }
}, apiMethod, function(err, result) {
    // do something with the result
});

// to retry individual methods that are not as reliable within other
// control flow functions, use the `retryable` wrapper:
async.auto({
    users: api.getUsers.bind(api),
    payments: async.retryable(3, api.getPayments.bind(api))
}, function(err, results) {
    // do something with the results
});

Источник:

retry.js, строка 10

См.:

async.retryable

(статический) retryable(optsopt, task) → {AsyncFunction}

import retryable from 'async/retryable';

Тесная родственница метода retry. Этот метод оборачивает задачу и делает её повторно выполняемой, а не вызывает её сразу с повторами.

Параметры:

Возвращаемое значение:

Тип

AsyncFunction

Пример

async.auto({
    dep1: async.retryable(3, getFromFlakyService),
    process: ["dep1", async.retryable(3, function (results, cb) {
        maybeProcessData(results.dep1, cb);
    })]
}, callback);

Источник:

retryable.js, строка 6

См.:

async.retry

(статический) seq(…functions) → {function}

import seq from 'async/seq';

Версия функции compose, которая более естественна для чтения. Каждая функция потребляет возвращаемое значение предыдущей функции. Это эквивалентно compose с перевёрнутыми аргументами.

Каждая функция выполняется с контекстом this составленной функции.

Параметры:

Возвращаемое значение:

Тип

функция

Пример

// Requires lodash (or underscore), express3 and dresende's orm2.
// Part of an app, that fetches cats of the logged user.
// This example uses `seq` function to avoid overnesting and error
// handling clutter.
app.get('/cats', function(request, response) {
    var User = request.models.User;
    async.seq(
        _.bind(User.get, User),  // 'User.get' has signature (id, callback(err, data))
        function(user, fn) {
            user.getCats(fn);      // 'getCats' has signature (callback(err, data))
        }
    )(req.session.user_id, function (err, cats) {
        if (err) {
            console.error(err);
            response.json({ status: 'error', message: err.message });
        } else {
            response.json({ status: 'ok', message: 'Cats found', data: cats });
        }
    });
});

Источник:

seq.js, строка 5

См.:

async.compose

(статический) series(tasks, callbackopt) → {Promise}

import series from 'async/series';

Выполняет функции в коллекции tasks последовательно, каждая выполняется после завершения предыдущей функции. Если любая функция в последовательности передаёт ошибку в её обратный вызов, больше функций не выполняется, и callback немедленно вызывается со значением ошибки. В противном случае, callback получает массив результатов, когда tasks завершаются.

Также можно использовать объект вместо массива. Каждая свойство будет выполнена как функция, а результаты будут переданы в конечную callback как объект вместо массива. Это может быть более удобным способом обработки результатов из async.series.

Обратите внимание, что, хотя многие реализации сохраняют порядок свойств объекта, Спецификация языка ECMAScript явно указывает, что

Механизм и порядок перечисления свойств не определены.

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

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

async.series([
    function(callback) {
        // do some stuff ...
        callback(null, 'one');
    },
    function(callback) {
        // do some more stuff ...
        callback(null, 'two');
    }
],
// optional callback
function(err, results) {
    // results is now equal to ['one', 'two']
});

async.series({
    one: function(callback) {
        setTimeout(function() {
            callback(null, 1);
        }, 200);
    },
    two: function(callback){
        setTimeout(function() {
            callback(null, 2);
        }, 100);
    }
}, function(err, results) {
    // results is now equal to: {one: 1, two: 2}
});

Источник:

series.js, строка 4

(статический) times(n, iteratee, callback) → {Promise}

import times from 'async/times';

Вызывает функцию iteratee n раз и накапливает результаты аналогичным образом, как вы бы использовали с map.

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

// Pretend this is some complicated async factory
var createUser = function(id, callback) {
    callback(null, {
        id: 'user' + id
    });
};

// generate 5 users
async.times(5, function(n, next) {
    createUser(n, function(err, user) {
        next(err, user);
    });
}, function(err, users) {
    // we should now have 5 users
});

Источник:

times.js, строка 3

См.:

async.map

(статический) timesLimit(count, limit, iteratee, callback) → {Promise}

import timesLimit from 'async/timesLimit';

То же, что и times, но выполняет максимальное количество limit асинхронных операций одновременно.

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

timesLimit.js, строка 5

См.:

async.times

(статический) timesSeries(n, iteratee, callback) → {Promise}

import timesSeries from 'async/timesSeries';

То же, что и times, но выполняет только одну асинхронную операцию за раз.

Параметры:

Возвращаемое значение:

Тип

Promise

Источник:

timesSeries.js, строка 3

См.:

async.times

(статический) tryEach(tasks, callbackopt) → {Promise}

import tryEach from 'async/tryEach';

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

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

async.tryEach([
    function getDataFromFirstWebsite(callback) {
        // Try getting the data from the first website
        callback(err, data);
    },
    function getDataFromSecondWebsite(callback) {
        // First website failed,
        // Try getting the data from the backup website
        callback(err, data);
    }
],
// optional callback
function(err, results) {
    Now do something with the data.
});

Источник:

tryEach.js, строка 5

(статический) until(test, iteratee, callbackopt) → {Promise}

import until from 'async/until';

Повторяет вызов iteratee до тех пор, пока test не вернёт true. Вызывает callback при остановке или возникновении ошибки. callback получит ошибку и любые аргументы, переданные в обратный вызов последней iteratee.

Обратное к whilst.

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

const results = []
let finished = false
async.until(function test(page, cb) {
    cb(null, finished)
}, function iter(next) {
    fetchPage(url, (err, body) => {
        if (err) return next(err)
        results = results.concat(body.objects)
        finished = !!body.next
        next(err)
    })
}, function done (err) {
    // all pages have been fetched
})

Источник:

until.js, строка 4

См. также:

async.whilst

(static) waterfall(tasks, callbackopt)

import waterfall from 'async/waterfall';

Выполняет массив функций tasks последовательно, каждая передает свои результаты следующей в массиве. Однако, если любая из функций tasks передаст ошибку в свой обратный вызов, следующая функция не выполняется, и основной обратный вызов callback сразу же вызывается с ошибкой.

Параметры:

Возвращаемое значение:

Пример

async.waterfall([
    function(callback) {
        callback(null, 'one', 'two');
    },
    function(arg1, arg2, callback) {
        // arg1 now equals 'one' and arg2 now equals 'two'
        callback(null, 'three');
    },
    function(arg1, callback) {
        // arg1 now equals 'three'
        callback(null, 'done');
    }
], function (err, result) {
    // result now equals 'done'
});

// Or, with named functions:
async.waterfall([
    myFirstFunction,
    mySecondFunction,
    myLastFunction,
], function (err, result) {
    // result now equals 'done'
});
function myFirstFunction(callback) {
    callback(null, 'one', 'two');
}
function mySecondFunction(arg1, arg2, callback) {
    // arg1 now equals 'one' and arg2 now equals 'two'
    callback(null, 'three');
}
function myLastFunction(arg1, callback) {
    // arg1 now equals 'three'
    callback(null, 'done');
}

Источник:

waterfall.js, строка 7

(static) whilst(test, iteratee, callbackopt) → {Promise}

import whilst from 'async/whilst';

Повторно вызывает iteratee, пока test возвращает true. Вызывает callback при остановке или возникновении ошибки.

Параметры:

Возвращаемое значение:

Тип

Promise

Пример

var count = 0;
async.whilst(
    function test(cb) { cb(null, count < 5); },
    function iter(callback) {
        count++;
        setTimeout(function() {
            callback(null, count);
        }, 1000);
    },
    function (err, n) {
        // 5 seconds have passed, n = 5
    }
);

Источник:

whilst.js, строка 5

Определения типов

QueueObject

import queue from 'async/queue';

Очередь задач для завершения функцией-обработчиком.

Тип:

• Итерируемый объект

Свойства:

Источник:

queue.js, строка 4

Пример

const q = async.queue(worker, 2)
q.push(item1)
q.push(item2)
q.push(item3)
// queues are iterable, spread into an array to inspect
const items = [...q] // [item1, item2, item3]
// or use for of
for (let item of q) {
    console.log(item)
}

q.drain(() => {
    console.log('all done')
})
// or
await q.drain()

Утилиты

Коллекция async утилитных функций.

Источник:

index.js, строка 61

Методы

(статический) apply(fn) → {функция}

import apply from 'async/apply';

Создаёт функцию-продолжение с уже применёнными аргументами.

Полезно в качестве сокращения в сочетании с другими функциями управления потоком. Любые аргументы, переданные возвращаемой функции, добавляются к аргументам, первоначально переданным apply.

Параметры:

Возвращает:

Тип

функция

Пример

// using apply
async.parallel([
    async.apply(fs.writeFile, 'testfile1', 'test1'),
    async.apply(fs.writeFile, 'testfile2', 'test2')
]);


// the same process without using apply
async.parallel([
    function(callback) {
        fs.writeFile('testfile1', 'test1', callback);
    },
    function(callback) {
        fs.writeFile('testfile2', 'test2', callback);
    }
]);

// It's possible to pass any number of additional arguments when calling the
// continuation:

node> var fn = async.apply(sys.puts, 'one');
node> fn('two', 'three');
one
two
three

Источник:

apply.js, строка 1

(статический) asyncify(func) → {AsyncFunction}

import asyncify from 'async/asyncify';

Принимает синхронную функцию и делает её асинхронной, передавая её возвращаемое значение в обратный вызов. Это полезно для подключения синхронных функций к функции водопада, последовательности или другим асинхронным функциям. Любые аргументы, переданные сгенерированной функции, будут переданы обернутой функции (кроме последнего аргумента обратного вызова). Исключение ошибки будет передано обратному вызову.

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

Это также означает, что вы можете асинхронизировать функции ES2017 async.

Псевдоним:

wrapSync

Параметры:

Возвращает:

Тип

AsyncFunction

Пример

// passing a regular synchronous function
async.waterfall([
    async.apply(fs.readFile, filename, "utf8"),
    async.asyncify(JSON.parse),
    function (data, next) {
        // data is the result of parsing the text.
        // If there was a parsing error, it would have been caught.
    }
], callback);

// passing a function returning a promise
async.waterfall([
    async.apply(fs.readFile, filename, "utf8"),
    async.asyncify(function (contents) {
        return db.model.create(contents);
    }),
    function (model, next) {
        // `model` is the instantiated model object.
        // If there was an error, this function would be skipped.
    }
], callback);

// es2017 example, though `asyncify` is not needed if your JS environment
// supports async functions out of the box
var q = async.queue(async.asyncify(async function(file) {
    var intermediateStep = await processFile(file);
    return await somePromise(intermediateStep)
}));

q.push(files);

Источник:

asyncify.js, строка 5

(статический) constant() → {AsyncFunction}

import constant from 'async/constant';

Возвращает функцию, которая при вызове вызывает обратный вызов с предоставленными значениями. Полезно в качестве первой функции в waterfall или для подстановки значений в auto.

Параметры:

Возвращаемое значение:

Тип

AsyncFunction

Пример

async.waterfall([
    async.constant(42),
    function (value, next) {
        // value === 42
    },
    //...
], callback);

async.waterfall([
    async.constant(filename, "utf8"),
    fs.readFile,
    function (fileData, next) {
        //...
    }
    //...
], callback);

async.auto({
    hostname: async.constant("https://server.net/"),
    port: findFreePort,
    launchServer: ["hostname", "port", function (options, cb) {
        startServer(options, cb);
    }],
    //...
}, callback);

Источник:

constant.js, строка 1

(статический) dir(function)

import dir from 'async/dir';

Выводит результат асинхронной функции async функции в консоль, используя console для отображения свойств результирующего объекта. Работает только в Node.js или в браузерах, которые поддерживают console.dir и console.error (например, FF и Chrome). Если асинхронная функция возвращает несколько аргументов, console.dir вызывается для каждого аргумента в порядке следования.

Параметры:

Пример

// in a module
var hello = function(name, callback) {
    setTimeout(function() {
        callback(null, {hello: name});
    }, 1000);
};

// in the node repl
node> async.dir(hello, 'world');
{hello: 'world'}

Источник:

dir.js, строка 3

(статический) ensureAsync(fn) → {AsyncFunction}

import ensureAsync from 'async/ensureAsync';

Оборачивает асинхронную функцию и гарантирует, что она вызывает свой обратный вызов на последующем цикле событий. Если функция уже вызывает обратный вызов на следующем цикле, дополнительная отложенность не добавляется. Это полезно для предотвращения переполнения стека (RangeError: Maximum call stack size exceeded) и в целом для поддержания Zalgo в рамках заданных ограничений. Функции ES2017 async возвращаются как есть — они устойчивы к искажающему влиянию Zalgo, так как всегда разрешаются на последующем цикле.

Параметры:

Возвращаемое значение:

Тип

AsyncFunction

Пример

function sometimesAsync(arg, callback) {
    if (cache[arg]) {
        return callback(null, cache[arg]); // this would be synchronous!!
    } else {
        doSomeIO(arg, callback); // this IO would be asynchronous
    }
}

// this has a risk of stack overflows if many results are cached in a row
async.mapSeries(args, sometimesAsync, done);

// this will defer sometimesAsync's callback if necessary,
// preventing stack overflows
async.mapSeries(args, async.ensureAsync(sometimesAsync), done);

Источник:

ensureAsync.js, строка 4

(статический) log(function)

import log from 'async/log';

Выводит результат асинхронной async функции в консоль. Работает только в Node.js или в браузерах, которые поддерживают console.log и console.error (например, FF и Chrome). Если асинхронная функция возвращает несколько аргументов, console.log вызывается для каждого аргумента в порядке следования.

Параметры:

Пример

// in a module
var hello = function(name, callback) {
    setTimeout(function() {
        callback(null, 'hello ' + name);
    }, 1000);
};

// in the node repl
node> async.log(hello, 'world');
'hello world'

Источник:

log.js, строка 3

(статический) memoize(fn, hasher) → {AsyncFunction}

import memoize from 'async/memoize';

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

Примечание: если асинхронная функция возвращает ошибку, результат не будет кэширован, и последующие вызовы будут вызывать обернутую функцию.

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

Кэш результатов доступен как свойство memo функции, возвращенной memoize.

Параметры:

Возвращаемое значение:

Тип

AsyncFunction

Пример

var slow_fn = function(name, callback) {
    // do something
    callback(null, result);
};
var fn = async.memoize(slow_fn);

// fn can now be used as if it were slow_fn
fn('some name', function() {
    // callback
});

Источник:

memoize.js, строка 5

(статический) nextTick(callback)

import nextTick from 'async/nextTick';

Вызывает callback на последующем цикле событий. В Node.js это просто вызывает process.nextTick. В браузере будет использоваться setImmediate если доступно, иначе setTimeout(callback, 0), что означает, что другие события с более высоким приоритетом могут предшествовать выполнению callback.

Используется внутри для обеспечения совместимости с браузером.

Параметры:

Пример

var call_order = [];
async.nextTick(function() {
    call_order.push('two');
    // call_order now equals ['one','two']
});
call_order.push('one');

async.setImmediate(function (a, b, c) {
    // a, b, and c equal 1, 2, and 3
}, 1, 2, 3);

Источник:

nextTick.js, строка 5

См.:

async.setImmediate

(статический) reflect(fn) → {function}

import reflect from 'async/reflect';

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

Объект результата имеет свойство error или value.

Параметры:

Возвращаемое значение:

Тип

функция

Пример

async.parallel([
    async.reflect(function(callback) {
        // do some stuff ...
        callback(null, 'one');
    }),
    async.reflect(function(callback) {
        // do some more stuff but error ...
        callback('bad stuff happened');
    }),
    async.reflect(function(callback) {
        // do some more stuff ...
        callback(null, 'two');
    })
],
// optional callback
function(err, results) {
    // values
    // results[0].value = 'one'
    // results[1].error = 'bad stuff happened'
    // results[2].value = 'two'
});

Источник:

reflect.js, строка 4

(static) reflectAll(tasks) → {Array}

import reflectAll from 'async/reflectAll';

Функция-помощник, которая оборачивает массив или объект функций с reflect.

Параметры:

Возвращаемое значение:

Тип

Массив

Пример

let tasks = [
    function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    function(callback) {
        // do some more stuff but error ...
        callback(new Error('bad stuff happened'));
    },
    function(callback) {
        setTimeout(function() {
            callback(null, 'two');
        }, 100);
    }
];

async.parallel(async.reflectAll(tasks),
// optional callback
function(err, results) {
    // values
    // results[0].value = 'one'
    // results[1].error = Error('bad stuff happened')
    // results[2].value = 'two'
});

// an example using an object instead of an array
let tasks = {
    one: function(callback) {
        setTimeout(function() {
            callback(null, 'one');
        }, 200);
    },
    two: function(callback) {
        callback('two');
    },
    three: function(callback) {
        setTimeout(function() {
            callback(null, 'three');
        }, 100);
    }
};

async.parallel(async.reflectAll(tasks),
// optional callback
function(err, results) {
    // values
    // results.one.value = 'one'
    // results.two.error = 'two'
    // results.three.value = 'three'
});

Источник:

reflectAll.js, строка 3

См.:

async.reflect

(static) setImmediate(callback)

import setImmediate from 'async/setImmediate';

Вызывает callback в последующем цикле обработки событий. В Node.js это просто вызывает setImmediate. В браузере будет использоваться setImmediate если доступно, в противном случае setTimeout(callback, 0), что означает, что другие события с более высоким приоритетом могут предшествовать выполнению callback.

Используется внутренне для обеспечения совместимости с браузером.

Параметры:

Пример

var call_order = [];
async.nextTick(function() {
    call_order.push('two');
    // call_order now equals ['one','two']
});
call_order.push('one');

async.setImmediate(function (a, b, c) {
    // a, b, and c equal 1, 2, and 3
}, 1, 2, 3);

Источник:

setImmediate.js, строка 3

См.:

async.nextTick

(static) timeout(asyncFn, milliseconds, infoopt) → {AsyncFunction}

import timeout from 'async/timeout';

Устанавливает лимит времени для асинхронной функции. Если функция не вызовет свой колбэк в течение указанных миллисекунд, она будет вызвана с ошибкой таймаута. Свойство code объекта ошибки будет 'ETIMEDOUT'.

Параметры:

Возвращаемое значение:

Тип

AsyncFunction

Пример

function myFunction(foo, callback) {
    doAsyncTask(foo, function(err, data) {
        // handle errors
        if (err) return callback(err);

        // do some stuff ...

        // return processed data
        return callback(null, data);
    });
}

var wrapped = async.timeout(myFunction, 1000);

// call `wrapped` as you would `myFunction`
wrapped({ bar: 'bar' }, function(err, data) {
    // if `myFunction` takes < 1000 ms to execute, `err`
    // and `data` will have their expected values

    // else `err` will be an Error with the code 'ETIMEDOUT'
});

Источник:

timeout.js, строка 4

(static) unmemoize(fn) → {AsyncFunction}

import unmemoize from 'async/unmemoize';

Отменяет кэширование функции memoize, возвращая её к исходной, некэшированной форме. Полезно для тестирования.

Параметры:

Возвращаемое значение:

Тип

AsyncFunction

Источник:

unmemoize.js, строка 1

См.:

async.memoize