async.js の使い方

 [Home]


概要

asyncは非同期動作の多いnode.jsで、見かけ上、他の言語での同期動作のようなことを実現するモジュールである。asyncは20種類のメソッド(map, filter, each ...)を持っていて、様々な形態をサポートしている。

asyncはnpmでインストールできる(グローバルインストールの場合にはスイッチ-gを付ける)。

  npm install async

 asyncには次のカテゴリーに属するメソッドが含まれる。


使い方

var async = require('async');

async.map(data, asyncProcess, function(err, results) {
  console.log(results);
});

ブラウザで使う場合は次のようなタグを追加する。

<script type="text/javascript" src="async.js"></script>

コレクション

制御フロー


ユーティリティ

 

メソッドの詳細

async.each(collection, func, error)


// asyncがインストールされていないとダメ
var async = require('async');

// テスト用配列
var arr = ['async', 'bypass', 'call', 'do', 'express', 'finish'];
// 繰り返し動作はパラレルなので注意 (配列の要素順に実行される保証はない)
async.each(
  // 繰り返し対象の配列
  arr, 
  // 各要素に対して繰り返す関数
  function(s, callback) {
    console.log(s.toUpperCase());
    callback();  // 処理が終わったことをasyncに通知。
  }, 
  // すべてのeach動作が終わった時コールされる関数
  function(err) {
    if (err) {
      console.log(err);
    }
    else {
      console.log("Everything done.");
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.eachSeries


// asyncがインストールされていないとダメ
var async = require('async');

// テスト用配列
var arr = ['async', 'bypass', 'call', 'do', 'express', 'finish'];
var arr2 = new Array();
var i = 0;

// 繰り返し動作はコレクションの要素順
async.eachSeries(
  // 繰り返し処理対象の配列
  arr, 
  // 各要素に対して繰り返す関数
  function(s, callback) {
    arr2.push(s.toUpperCase());
    i++;
    console.log(i);
    callback();
  }, 
  // すべてのeachSeries動作が終わった時コールされる関数
  function(err) {
    if (err) {
      console.log(err);
    }
    else {
      // 上の関数でarrの要素を保存しておいた配列の内容を表示
      for (var j in arr2) {
        console.log(arr2[j]);
      }
      console.log("Everything done.");
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.eachLimit


/*
   表示結果は下のようになる。つまり回数制限ではない。
   
ASYNC
BYPASS
CALL
DO
EXPRESS
FINISH
Everything done.

*/

// asyncがインストールされていないとダメ
var async = require('async');


// テスト用配列
var arr = ['async', 'bypass', 'call', 'do', 'express', 'finish'];

// 基本動作は async.eachと同じだが回数制限がある。
async.eachLimit(
  // 繰り返し対象の配列
  arr, 
  3,  // <== イテレータの制限
  // 各要素に対して繰り返す関数
  function(s, callback) {
    console.log(s.toUpperCase());
    callback();  // 処理が終わったことをasyncに通知。
  }, 
  // すべてのeach動作が終わった時コールされる関数
  function(err) {
    if (err) {
      console.log(err);
    }
    else {
      console.log("Everything done.");
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.map


var fs = require('fs');
 // asyncがインストールされていないとダメ
var async = require('async');

var arr = ['C:\\Windows\\notepad.exe', 'C:\\Windows\\winhlp32.exe', 'C:\\Windows\\write.exe', 'C:\\Windows\\regedit.exe'];

async.map(
  arr,  // 変換対象の配列
  // 変換関数
  function(item, callback) {
    var st = fs.statSync(item);
    callback(null, st.size);  // ここで変換結果を返す。
  },
  // 結果(新しい配列result)を受け取る関数
  function(err, result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.mapSeries


var fs = require('fs');

// asyncがインストールされていないとダメ
var async = require('async');

var arr = ['C:\\Windows\\notepad.exe', 'C:\\Windows\\winhlp32.exe', 'C:\\Windows\\write.exe', 'C:\\Windows\\regedit.exe'];

async.mapSeries(
  arr,  // 変換対象の配列
  // 変換関数
  function(item, callback) {
    var st = fs.statSync(item);
    callback(null, st.size);  // ここで変換結果を返す。
  },
  // 結果(新しい配列result)を受け取る関数
  function(err, result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.mapLimit


var fs = require('fs');

// asyncがインストールされていないとダメ
var async = require('async');

var arr = ['C:\\Windows\\notepad.exe', 'C:\\Windows\\winhlp32.exe', 'C:\\Windows\\write.exe', 'C:\\Windows\\regedit.exe'];

async.mapLimit(
  arr,  // 変換対象の配列
  1, // 同時にマップ動作をする制限
  // 変換関数
  function(item, callback) {
    var st = fs.statSync(item);
    callback(null, st.size);  // ここで変換結果を返す。
  },
  // 結果(新しい配列result)を受け取る関数
  function(err, result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.filter


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

//  第二引数で指定した関数に従ってコレクションのフィルタリングを行った新しいコレクションを取得する。
//   動作はコレクションの順番に行われることは保証されない。
async.filter(
  arr,
  // 奇数のみフィルタする関数
  function(item, callback) {
    callback(item % 2 > 0);  // itemが奇数であることをasyncに通知する。
  },
  // 結果を受け取る関数
  function(result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.filterSeries


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

//  第二引数で指定した関数に従ってコレクションのフィルタリングを行った新しいコレクションを取得する。
//   動作はコレクションの順番に行われる(async.filterは順番は保証されない。)
async.filterSeries(
  arr,
  // 奇数のみフィルタする関数
  function(item, callback) {
    callback(item % 2 == 0);  // itemが偶数であることをasyncに通知する。
  },
  // 結果を受け取る関数
  function(result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.reject


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

//  第二引数で指定した関数に従ってコレクションのフィルタリング(filterの逆動作)を行った新しいコレクションを取得する。
//   動作はコレクションの順番に行われることは保証されない。
async.reject(
  arr,
  // 配列の中の0をリジェクトする関数
  function(item, callback) {
    callback(item == 0);  // itemが0であるをasyncに通知する。
  },
  // 結果を受け取る関数
  function(result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.rejectSeries


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];

//  第二引数で指定した関数に従ってコレクションのフィルタリング(filterの逆動作)を行った新しいコレクションを取得する。
//   動作はコレクションの順番に行われる。
async.rejectSeries(
  arr,
  // 配列の中の0をリジェクトする関数
  function(item, callback) {
    callback(item == 0);  // itemが0であるをasyncに通知する。
  },
  // 結果を受け取る関数
  function(result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.reduce


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [1, 2, 3, 4, 5];

// コレクションの要素に対して関数を適用してスカラー値を求める。
// 整数配列 arr の要素の総和を求める。
async.reduce(
  arr,  // 処理対象の配列
  0,    // 総和を求めるときの初期値
  // 足し算を行う関数。memoの初期値は上の値。
  function(memo, item, callback) {
     callback(null, memo + item);  // asyncに中間結果を通知する。
  },
  // 最終結果(総和)が返される関数
  function(err, result) {
     console.log(result);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.reduceRight


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [1, 2, 3, 4, 5];

// 整数配列 arr の要素の総和を求める。reduceとの違いは配列の右側からitemが選ばれること。
async.reduceRight(
  arr,  // 処理対象の配列
  0,    // 総和を求めるときの初期値
  // 足し算を行う関数。memoの初期値は上の値。
  function(memo, item, callback) {
     callback(null, memo + item);  // asyncに中間結果を通知する。
  },
  // 最終結果(総和)が返される関数
  function(err, result) {
     console.log(result);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.detect


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 13, 8, -5, 4, 77, -16, -70, 92];

//  第二引数で指定した関数に従ってコレクションの要素から目的のものを探す。
//  最初に見つかったものを第3引数で指定した関数にパラメータとして渡す。(配列の要素順とは限らない)
async.detect(
  arr,
  // 負の数を見つける関数
  function(item, callback) {
    callback(item < 0);  // itemが負であることをasyncに通知する。
  },
  // 結果を受け取る関数
  function(result) {
    console.log(result);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.detectSeries


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 13, 8, -5, 4, 77, -16, -70, 92];

//  第二引数で指定した関数に従ってコレクションの要素から目的のものを探す。
//  最初に見つかったものを第3引数で指定した関数にパラメータとして渡す。(これは配列の要素順の最初のものになる)
async.detectSeries(
  arr,
  // 負の数を見つける関数
  function(item, callback) {
    callback(item < 0);  // itemが負であることをasyncに通知する。
  },
  // 結果を受け取る関数
  function(result) {
    console.log(result);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.sortBy


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 13, 8, 5, 4, 77];

//  第2引数で指定した関数に従ってコレクションの要素を並べ替える。
//  結果を第3引数で指定した関数にパラメータとして渡す。
async.sortBy(
  arr,
  // 配列を逆順に並べ替えるための関数(callbackで返される値(第2パラメータ)をキーとして元の配列を並び替える)
  function(item, callback) {
    callback(null, -item);
  },
  // 結果を受け取る関数
  function(err, result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.some


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 13, 8, 5, 4, 77];

//  第2引数で指定した関数に従ってコレクションの要素を調べ、条件に合うものがあったらtrueを結果として返す。(everyの逆関数)
//  結果(true/false)を第3引数で指定した関数にパラメータとして渡す。
async.some(
  arr,
  // 配列から条件に合う要素の有無を検出するための関数(負の数があればtrueを返す)
  function(item, callback) {
    callback(item < 0);
  },
  // 結果を受け取る関数
  function(result) {
    console.log(result);  // arrには負数がないのでfalseになる。arrの要素をどれかひとつでも負にするとtrueが返される。
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.every


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [0, 13, 8, 5, 4, 77];

//  第2引数で指定した関数に従ってコレクションの要素を調べ、全要素が条件に合う場合、trueを結果として返す。(someの逆関数)
//  結果(true/false)を第3引数で指定した関数にパラメータとして渡す。
async.every(
  arr,
  // 配列から条件に合う要素の有無を検出するための関数
  function(item, callback) {
    callback(item >= 0);
  },
  // 結果を受け取る関数
  function(result) {
    console.log(result);  // arrには負数がないのでtrueになる。どれか一つの要素を負にするとfalseになる。
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.concat


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [2, 4];

//  第一引数で指定する配列の各要素に第二引数で指定される関数を適用する。
//  この関数は第一引数の配列の各要素をもとにして(パラメータとして)、得られた配列を返す。
//  配列の要素は配列の並び順に処理関数に渡されるとは限らない。
async.concat(
  arr,
  // 上の配列の各要素の値の数だけの要素からなる配列を返す。
  function(item, callback) {
    var a = [];
    // itemの値に従った長さ配列を作る。各要素の値はitemとする。
    for (var i = 0; i < item; i++) {
      a.push(item);
    }
    callback(null, a);  // 第二引数にこのitemに対応したasyncに返す結果(配列)をセットする。
  },
  // 結果を受け取る関数
  function(err, result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);

// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.concatSeries


// asyncがインストールされていないとダメ
var async = require('async');

var arr = [2, 4];

//  第一引数で指定する配列の各要素に第二引数で指定される関数を適用する。
//  この関数は第一引数の配列の各要素をもとにして(パラメータとして)、得られた配列を返す。
//  配列の要素は配列の並び順に処理関数に渡される。
async.concatSeries(
  arr,
  // 上の配列の各要素の値の数だけの要素からなる配列を返す。
  function(item, callback) {
    var a = [];
    // itemの値に従った長さ配列を作る。各要素の値はitemとする。
    for (var i = 0; i < item; i++) {
      a.push(item);
    }
    callback(null, a);  // 第二引数にこのitemに対応したasyncに返す結果(配列)をセットする。
  },
  // 結果を受け取る関数
  function(err, result) {
    for (var i in result) {
      console.log(result[i]);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.series


// asyncがインストールされていないとダメ
var async = require('async');
var n = 0;

// 最初のパラメータ(関数配列)で定義された関数の順番通りに実行される。
async.series(
  [
    // 最初に実行される関数
    function(callback) {
      n++;
      console.log("function No." + n);
      callback(null, n);
    },
    // 二番目に実行される関数
    function(callback) {
      n++;
      console.log("Function No." + n);
      callback(null, n);
    },
    // 三番目に実行される関数
    function(callback) {
      n++;
      console.log("FunctioN No." + n);
      callback(null, n);
    }
  ],
  // 結果を受け取る関数(オプション)
  function(err, result) {
     console.log("result = " + result);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.parallel


// asyncがインストールされていないとダメ
var async = require('async');
var n = 0;

// 最初のパラメータ(関数配列)で定義された関数を並列に実行する。
async.parallel(
  [
    // 一番目の関数
    function(callback) {
      n++;
      console.log("function No." + n);
      callback(null, n);
    },
    // 二番目の関数
    function(callback) {
      n++;
      console.log("Function No." + n);
      callback(null, n);
    },
    // 三番目の関数
    function(callback) {
      n++;
      console.log("FunctioN No." + n);
      callback(null, n);
    }
  ],
  // すべての関数が終了したとき実行される関数(オプション)
  function(err, result) {
     console.log("result = " + result);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.parallel


// asyncがインストールされていないとダメ
var async = require('async');
var n = 0;

// 最初のパラメータ(関数配列)で定義された関数を並列に実行する。
//  同時に実行される関数は第二パラメータで制限できる。
async.parallelLimit(
  [
    // 一番目の関数
    function(callback) {
      n++;
      console.log("function No." + n);
      callback(null, n);
    },
    // 二番目の関数
    function(callback) {
      n++;
      console.log("Function No." + n);
      callback(null, n);
    },
    // 三番目の関数
    function(callback) {
      n++;
      console.log("FunctioN No." + n);
      callback(null, n);
    }
  ],
  1,  // 同時実行数の制限
  // すべての関数が終了したとき実行される関数(オプション)
  function(err, result) {
     console.log("result = " + result);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.whilst


// asyncがインストールされていないとダメ
var async = require('async');
var n = 0;

// 第一引数の関数で繰り返し条件を管理する。第二引数の関数が繰り返し実行される。
async.whilst(
  // 繰り返し終了ならfalseを返す関数。
  function() {
    return (n < 10);
  },
  // 繰り返し実行される関数。
  function(callback) {
    console.log(n);
    n++;
    callback(null);  // エラーがなければnullをasyncに通知する。
  },
  // 最後にエラーの有無を確認できる。
  function(err) {
    if (err) {
      console.error(err.message);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.doWhilst


// asyncがインストールされていないとダメ
var async = require('async');
var n = 0;

// 第一引数の関数で繰り返し条件を管理する。第二引数の関数が繰り返し実行される。
// whilstとの違いは関数が実行された後に繰り返し条件をチェックするかどうか。(JavaScriptのdo .. whileと同様)
// (注意) 引数の順番がwhilstとは異なる点に注意。
async.doWhilst(
  // 繰り返し実行される関数。
  function(callback) {
    console.log(n);
    n++;
    callback(null);  // エラーがなければnullをasyncに通知する。
  },
  // 繰り返し終了ならfalseを返す関数。
  function() {
    return (n < 10);
  },
  // 最後にエラーの有無を確認できる。
  function(err) {
    if (err) {
      console.error(err.message);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.until


// asyncがインストールされていないとダメ
var async = require('async');
var n = 0;

// 第一引数の関数で繰り返し終了条件を管理する。第二引数の関数が繰り返し実行される。
// whilstとの違いは、条件が逆になる点。
async.until(
  // 繰り返し終了ならtrueを返す関数。
  function() {
    return (n == 10);
  },
  // 繰り返し実行される関数。
  function(callback) {
    console.log(n);
    n++;
    callback(null);  // エラーがなければnullをasyncに通知する。
  },
  // 最後にエラーの有無を確認できる。
  function(err) {
    if (err) {
      console.error(err.message);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.doUntil


// asyncがインストールされていないとダメ
var async = require('async');
var n = 0;

// 第一引数の関数で繰り返し終了条件を管理する。第二引数の関数が繰り返し実行される。
// untilとの違いは、関数が実行された後に繰り返し条件をチェックするかどうか。
// (注意) 引数の順番がuntilとは異なる点に注意。
async.doUntil(
  // 繰り返し実行される関数。
  function(callback) {
    console.log(n);
    n++;
    callback(null);  // エラーがなければnullをasyncに通知する。
  },
  // 繰り返し終了ならtrueを返す関数。
  function() {
    return (n == 10);
  },
  // 最後にエラーの有無を確認できる。
  function(err) {
    if (err) {
      console.error(err.message);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.forever


// asyncがインストールされていないとダメ
var async = require('async');
var n = 10;

// 無限ループ。終了条件はエラー検出時のみ。
async.forever(
  // 繰り返し実行される関数。
  function(callback) {
    console.log(n);
    n--;
    if (n >= 0) {
      callback(null);  // エラーがなければnullをasyncに通知する。
    }
    else {
      callback(new Error("minus value!"));
    }
  },
  function(err) {
    if (err) {
      console.error(err.message);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.waterfall


// asyncがインストールされていないとダメ
var async = require('async');


// 第二引数の関数配列の要素順に関数を実行する。
// エラーがなければ全部の関数を実行する(エラーがあればその関数で実行を打ち切る)
// 実行されるcallback関数のパラメータは最初の1個(エラーの有無をasyncに通知する)を除き、任意の数を指定可能。
async.waterfall(
  [
    // 最初の関数
    function(callback) {
      console.log("No.1");
      callback(null, "A");
    },
    // 2番目の関数
    function(arg1, callback) {
      console.log("No.2 " + arg1);
      callback(null, arg1, "B");
    },
    // 3番目の関数
    function(arg1, arg2, callback) {
      console.log("No.3 " + arg1 + arg2);
      callback(null, arg1, arg2, "C");
    },
    // 4番目の関数
    function(arg1, arg2, arg3, callback) {
      console.log("No.4 " + arg1 + arg2 + arg3);
      callback(null, "Done.");
    }
  ],
  
  // 結果を受け取る関数
  function(err, result) {
    if (err) {
      console.error(err.message);
    }
    else {
      console.log(result);
    }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.compose


// asyncがインストールされていないとダメ
var async = require('async');

// 関数1
function init(n, callback) {
  console.log("init(" + n + ")");
  callback(null, n);
}

// 関数2
function inc(n, callback) {
  console.log("inc(" + n + ")");
  callback(null, n + 1);
}

// 関数1と関数2から新しい関数を作る。
//  実行順に注意。compose関数の最後の引数から実行される。
var fcomposed = async.compose(inc, inc, init);

// 新しい関数の実行
//  第一引数は最初に実行される関数に渡される。
fcomposed(
  5,
  // 結果を受け取る関数
  function(err, result) {
    console.log(result);
  }
);

// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.applyEach


// asyncがインストールされていないとダメ
var async = require('async');

// 第一引数で与えられる関数配列の要素(関数)に、第二引数(第三引数以上も可能)で与えられる値を適用する。
// エラーの有無は最後の引数で指定する関数で取得できる。
// 関数の実行はパラレルなので注意。
async.applyEach(
  [
    // 関数1
    function(n, callback) {
      n++;
      console.log(n);
      callback(null);
    },
    // 関数2
    function(n, callback) {
      n--;
      console.log(n);
      callback(null);
    }
  ],
  5, // 上の関数の引数として与えられる。
  // エラーの有無を取得する関数
  function(err) {
    if (err)
      console.log(err.message);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.applyEachSeries


// asyncがインストールされていないとダメ
var async = require('async');

// 第一引数で与えられる関数配列の要素(関数)に、第二引数(第三引数以上も可能)で与えられる値を適用する。
// エラーの有無は最後の引数で指定する関数で取得できる。
// 関数の実行はapllyEachと違いシリアル(順次実行)。
async.applyEachSeries(
  [
    // 関数1
    function(n, callback) {
      n++;
      console.log(n);
      callback(null);
    },
    // 関数2
    function(n, callback) {
      n--;
      console.log(n);
      callback(null);
    },
    // 関数3
    function(n, callback) {
      n -= 2;
      console.log(n);
      callback(null);
    }
  ],
  5, // 上の関数の引数として与えられる。
  // エラーの有無を取得する関数
  function(err) {
    if (err)
      console.log(err.message);
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.queue


// asyncがインストールされていないとダメ
var async = require('async');

// 関数を待ち行列に入れて実行する。実行順はいれた順番とは限らないが、
// 第二引数を1にすれば同時に実行されることがないはずなので、
// 順番に実行されるはず。
// 第一引数は関数で待ち行列に入った時、実行される。
// 第二引数は同時に実行可能な関数の数。
var q = async.queue(
  function(task, callback) {
    console.log("Queued " + task.name);
    callback(null);
  },
  1
);

// 最後に実行される関数
q.drain = function() {
  console.log("run Last func!");
}

// 待ち行列に追加
q.push(
  {name:"func1"},
  function(err) {
    console.log("run func1");
  }
);

// 待ち行列に追加
q.push(
  {name:"func2"},
  function(err) {
    console.log("run func2");
  }
);

// 待ち行列の最初に追加
q.unshift(
  {name:"func3"},
  function(err) {
    console.log("run func3");
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.cargo


// asyncがインストールされていないとダメ
var async = require('async');

// 関数をコレクションに入れて実行する。実行順は入れた順番とは限らないが、
// 第二引数を1にすれば同時に実行されることがないはずなので、
// 順番に実行されるはず。
// 第一引数は関数が待ち行列に入った時、実行される。
// 第二引数は同時に実行可能な関数の数。
var c = async.cargo(
  function(worker, callback) {
    console.log("Loaded.");
    callback(null);
  },
  2
);

// 貨物に追加
c.push(
  {name:"func1"},
  function(err) {
    console.log("run func1");
  }
);

// 貨物に追加
c.push(
  {name:"func2"},
  function(err) {
    console.log("run func2");
  }
);

// 貨物に追加
c.push(
  {name:"func3"},
  function(err) {
    console.log("run func3");
  }
);

// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.auto


// asyncがインストールされていないとダメ
var async = require('async');

// 名前を付けた関数のリスト(ハッシュ)に含まれる関数を実行する。
// 関数は他の関数に結果を渡すことができるので、その内容に従って処理を行うことができる。
async.auto(
  {
     // first関数
     first: function(callback) {
       console.log("first");
       callback(null, false);
     },
     // second関数
     second: function(callback, result) {
       console.log(result);
       if (result.first == true) {
          // firstがtrueを返したとき
       console.log('second first=true');
         callback(null, true);
       }
       else {
         // firstがfalseを返したとき
         console.log("second first=false");
         callback(null, false);
       }
     },
     // third関数
     third: function(callback, result) {
       if (result.first == true && result.second == true) {
          // firstとsecondがtrueを返したとき
          console.log("third first=true & second=true");
          callback(null, true);
       }
       else {
          // そうでないとき
          console.log('third end.');
          callback(null);
       }
     }
  }
);
// 上の動作は、非同期なのでここに結果を確認するコードを書いてもダメ。

[Top]

async.iterator


// asyncがインストールされていないとダメ
var async = require('async');

// 関数の反復子を作る。これはasyncで内部的に使われるが、ユーザが使うこともできる。
var iterator = async.iterator(
  [
    function() { console.log('1'); },
    function() { console.log('2'); },
    function() { console.log('3'); }
  ]
);

iterator();  // 最初の関数を実行する
var it = iterator.next(); // 次のイテレータを得る。
it();  // 2番目の関数を実行
it = it.next(); // 次のイテレータを得る。
it();  // 3番目の関数を実行

[Top]

async.apply


// asyncがインストールされていないとダメ
var async = require('async');

function test(n, callback) {
  console.log(n);
  callback(null);
}

// async.applyは他の制御フロー関数と一緒に使うと、簡略な書き方ができる。
async.series([
  async.apply(test, 1),
  async.apply(test, 2),
  async.apply(test, 3),
  async.apply(test, 4)
]);

// async.applyを使わない場合
async.series([
  function(callback) { console.log(-1); callback(null); },
  function(callback) { console.log(-2); callback(null); },
  function(callback) { console.log(-3); callback(null); },
  function(callback) { console.log(-4); callback(null); }
]);

[Top]

async.nextTick


// asyncがインストールされていないとダメ
var async = require('async');

var call_order = [];

// この関数は主にブラウザの互換性を維持するため、asyncで内部的に使われる。
// 次の単位動作でこれが行われる。
async.nextTick(function(){
    call_order.push('two');
    console.log(call_order);
});

// この動作が最初に行われる。
call_order.push('one')

[Top]

async.times


// asyncがインストールされていないとダメ
var async = require('async');

// 第一引数で指定した回数、第二引数の関数を実行する。
// 順次実行は保証されない。
async.times(
  5,
  function(n) {
    console.log(n);
  }
);

[Top]

async.timesSeries


// asyncがインストールされていないとダメ
var async = require('async');

// 第一引数で指定した回数、第二引数の関数を実行する。
// 順次実行が保証される。
async.timesSeries(
  5,
  function(n, callback) {
    console.log(n);
    if (n < 4)  // 最後の値ではcallbackが未定義になる。
      callback(null);
  }
);

[Top]

async.memoize


// asyncがインストールされていないとダメ
var async = require('async');

// 結果を取得するためのターゲット関数(重い処理をするとき意味がある)
var func = function(name, callback) {
  result = name + name.toUpperCase();
  callback(null, result);
}

// ここで上の関数をmemoizeのパラメータとして登録する。
var fn = async.memoize(func);

// ここでコールバックで結果を受け取る。
fn('memo', function(err, result) {
  console.log(result);
});

[Top]

async.log

var async = require('async');

// 時間のかかる処理
var hello = function(name, callback){
    setTimeout(function(){
        callback(null, 'hello ' + name);
    }, 1000);
};

// 関数の実行時間がかかってもログを表示する。
async.log(hello, 'world');

[Top]

async.dir


var async = require('async');

// 時間のかかる処理
var hello = function(name, callback){
    setTimeout(function(){
        callback(null, {hello: name});
    }, 1000);
};

// 関数の実行時間がかかってもログを表示する。logとの違いはプロパティを表示すること。
async.dir(hello, 'world');






 

ページの先頭へ