How to use iterator method in Best

Best JavaScript code snippet using best

async.js

Source:async.js

...2206 function arrayEachSync(array, iterator) {2207 var index = -1;2208 var size = array.length;2209 while (++index < size) {2210 iterator(array[index], index);2211 }2212 return array;2213 }2214 /**2215 * @private2216 * @param {Object} object - The object to iterate over.2217 * @param {Function} iterator - The function invoked per iteration.2218 * @param {Array} keys2219 */2220 function baseEachSync(object, iterator, keys) {2221 var index = -1;2222 var size = keys.length;2223 while (++index < size) {2224 var key = keys[index];2225 iterator(object[key], key);2226 }2227 return object;2228 }2229 /**2230 * @private2231 * @param {number} n2232 * @param {Function} iterator2233 */2234 function timesSync(n, iterator) {2235 var index = -1;2236 while (++index < n) {2237 iterator(index);2238 }2239 }2240 /**2241 * @private2242 * @param {Array} array2243 * @param {number[]} criteria2244 */2245 function sortByCriteria(array, criteria) {2246 var l = array.length;2247 var indices = Array(l);2248 var i;2249 for (i = 0; i < l; i++) {2250 indices[i] = i;2251 }2252 quickSort(criteria, 0, l - 1, indices);2253 var result = Array(l);2254 for (var n = 0; n < l; n++) {2255 i = indices[n];2256 result[n] = i === undefined ? array[n] : array[i];2257 }2258 return result;2259 }2260 function partition(array, i, j, mid, indices) {2261 var l = i;2262 var r = j;2263 while (l <= r) {2264 i = l;2265 while (l < r && array[l] < mid) {2266 l++;2267 }2268 while (r >= i && array[r] >= mid) {2269 r--;2270 }2271 if (l > r) {2272 break;2273 }2274 swap(array, indices, l++, r--);2275 }2276 return l;2277 }2278 function swap(array, indices, l, r) {2279 var n = array[l];2280 array[l] = array[r];2281 array[r] = n;2282 var i = indices[l];2283 indices[l] = indices[r];2284 indices[r] = i;2285 }2286 function quickSort(array, i, j, indices) {2287 if (i === j) {2288 return;2289 }2290 var k = i;2291 while (++k <= j && array[i] === array[k]) {2292 var l = k - 1;2293 if (indices[l] > indices[k]) {2294 var index = indices[l];2295 indices[l] = indices[k];2296 indices[k] = index;2297 }2298 }2299 if (k > j) {2300 return;2301 }2302 var p = array[i] > array[k] ? i : k;2303 k = partition(array, i, j, array[p], indices);2304 quickSort(array, i, k - 1, indices);2305 quickSort(array, k, j, indices);2306 }2307 /**2308 * @Private2309 */2310 function makeConcatResult(array) {2311 var result = [];2312 arrayEachSync(array, function(value) {2313 if (value === noop) {2314 return;2315 }2316 if (isArray(value)) {2317 nativePush.apply(result, value);2318 } else {2319 result.push(value);2320 }2321 });2322 return result;2323 }2324 /* async functions */2325 /**2326 * @private2327 */2328 function arrayEach(array, iterator, callback) {2329 var index = -1;2330 var size = array.length;2331 if (iterator.length === 3) {2332 while (++index < size) {2333 iterator(array[index], index, onlyOnce(callback));2334 }2335 } else {2336 while (++index < size) {2337 iterator(array[index], onlyOnce(callback));2338 }2339 }2340 }2341 /**2342 * @private2343 */2344 function baseEach(object, iterator, callback, keys) {2345 var key;2346 var index = -1;2347 var size = keys.length;2348 if (iterator.length === 3) {2349 while (++index < size) {2350 key = keys[index];2351 iterator(object[key], key, onlyOnce(callback));2352 }2353 } else {2354 while (++index < size) {2355 iterator(object[keys[index]], onlyOnce(callback));2356 }2357 }2358 }2359 /**2360 * @private2361 */2362 function symbolEach(collection, iterator, callback) {2363 var iter = collection[iteratorSymbol]();2364 var index = 0;2365 var item;2366 if (iterator.length === 3) {2367 while ((item = iter.next()).done === false) {2368 iterator(item.value, index++, onlyOnce(callback));2369 }2370 } else {2371 while ((item = iter.next()).done === false) {2372 index++;2373 iterator(item.value, onlyOnce(callback));2374 }2375 }2376 return index;2377 }2378 /**2379 * @private2380 */2381 function arrayEachResult(array, result, iterator, callback) {2382 var index = -1;2383 var size = array.length;2384 if (iterator.length === 4) {2385 while (++index < size) {2386 iterator(result, array[index], index, onlyOnce(callback));2387 }2388 } else {2389 while (++index < size) {2390 iterator(result, array[index], onlyOnce(callback));2391 }2392 }2393 }2394 /**2395 * @private2396 */2397 function baseEachResult(object, result, iterator, callback, keys) {2398 var key;2399 var index = -1;2400 var size = keys.length;2401 if (iterator.length === 4) {2402 while (++index < size) {2403 key = keys[index];2404 iterator(result, object[key], key, onlyOnce(callback));2405 }2406 } else {2407 while (++index < size) {2408 iterator(result, object[keys[index]], onlyOnce(callback));2409 }2410 }2411 }2412 /**2413 * @private2414 */2415 function symbolEachResult(collection, result, iterator, callback) {2416 var item;2417 var index = 0;2418 var iter = collection[iteratorSymbol]();2419 if (iterator.length === 4) {2420 while ((item = iter.next()).done === false) {2421 iterator(result, item.value, index++, onlyOnce(callback));2422 }2423 } else {2424 while ((item = iter.next()).done === false) {2425 index++;2426 iterator(result, item.value, onlyOnce(callback));2427 }2428 }2429 return index;2430 }2431 /**2432 * @private2433 */2434 function arrayEachFunc(array, createCallback) {2435 var index = -1;2436 var size = array.length;2437 while (++index < size) {2438 array[index](createCallback(index));2439 }2440 }2441 /**2442 * @private2443 */2444 function baseEachFunc(object, createCallback, keys) {2445 var key;2446 var index = -1;2447 var size = keys.length;2448 while (++index < size) {2449 key = keys[index];2450 object[key](createCallback(key));2451 }2452 }2453 /**2454 * @private2455 */2456 function arrayEachIndex(array, iterator, createCallback) {2457 var index = -1;2458 var size = array.length;2459 if (iterator.length === 3) {2460 while (++index < size) {2461 iterator(array[index], index, createCallback(index));2462 }2463 } else {2464 while (++index < size) {2465 iterator(array[index], createCallback(index));2466 }2467 }2468 }2469 /**2470 * @private2471 */2472 function baseEachIndex(object, iterator, createCallback, keys) {2473 var key;2474 var index = -1;2475 var size = keys.length;2476 if (iterator.length === 3) {2477 while (++index < size) {2478 key = keys[index];2479 iterator(object[key], key, createCallback(index));2480 }2481 } else {2482 while (++index < size) {2483 iterator(object[keys[index]], createCallback(index));2484 }2485 }2486 }2487 /**2488 * @private2489 */2490 function symbolEachIndex(collection, iterator, createCallback) {2491 var item;2492 var index = 0;2493 var iter = collection[iteratorSymbol]();2494 if (iterator.length === 3) {2495 while ((item = iter.next()).done === false) {2496 iterator(item.value, index, createCallback(index++));2497 }2498 } else {2499 while ((item = iter.next()).done === false) {2500 iterator(item.value, createCallback(index++));2501 }2502 }2503 return index;2504 }2505 /**2506 * @private2507 */2508 function baseEachKey(object, iterator, createCallback, keys) {2509 var key;2510 var index = -1;2511 var size = keys.length;2512 if (iterator.length === 3) {2513 while (++index < size) {2514 key = keys[index];2515 iterator(object[key], key, createCallback(key));2516 }2517 } else {2518 while (++index < size) {2519 key = keys[index];2520 iterator(object[key], createCallback(key));2521 }2522 }2523 }2524 /**2525 * @private2526 */2527 function symbolEachKey(collection, iterator, createCallback) {2528 var item;2529 var index = 0;2530 var iter = collection[iteratorSymbol]();2531 if (iterator.length === 3) {2532 while ((item = iter.next()).done === false) {2533 iterator(item.value, index, createCallback(index++));2534 }2535 } else {2536 while ((item = iter.next()).done === false) {2537 iterator(item.value, createCallback(index++));2538 }2539 }2540 return index;2541 }2542 /**2543 * @private2544 */2545 function arrayEachValue(array, iterator, createCallback) {2546 var value;2547 var index = -1;2548 var size = array.length;2549 if (iterator.length === 3) {2550 while (++index < size) {2551 value = array[index];2552 iterator(value, index, createCallback(value));2553 }2554 } else {2555 while (++index < size) {2556 value = array[index];2557 iterator(value, createCallback(value));2558 }2559 }2560 }2561 /**2562 * @private2563 */2564 function baseEachValue(object, iterator, createCallback, keys) {2565 var key, value;2566 var index = -1;2567 var size = keys.length;2568 if (iterator.length === 3) {2569 while (++index < size) {2570 key = keys[index];2571 value = object[key];2572 iterator(value, key, createCallback(value));2573 }2574 } else {2575 while (++index < size) {2576 value = object[keys[index]];2577 iterator(value, createCallback(value));2578 }2579 }2580 }2581 /**2582 * @private2583 */2584 function symbolEachValue(collection, iterator, createCallback) {2585 var value, item;2586 var index = 0;2587 var iter = collection[iteratorSymbol]();2588 if (iterator.length === 3) {2589 while ((item = iter.next()).done === false) {2590 value = item.value;2591 iterator(value, index++, createCallback(value));2592 }2593 } else {2594 while ((item = iter.next()).done === false) {2595 index++;2596 value = item.value;2597 iterator(value, createCallback(value));2598 }2599 }2600 return index;2601 }2602 /**2603 * @private2604 */2605 function arrayEachIndexValue(array, iterator, createCallback) {2606 var value;2607 var index = -1;2608 var size = array.length;2609 if (iterator.length === 3) {2610 while (++index < size) {2611 value = array[index];2612 iterator(value, index, createCallback(index, value));2613 }2614 } else {2615 while (++index < size) {2616 value = array[index];2617 iterator(value, createCallback(index, value));2618 }2619 }2620 }2621 /**2622 * @private2623 */2624 function baseEachIndexValue(object, iterator, createCallback, keys) {2625 var key, value;2626 var index = -1;2627 var size = keys.length;2628 if (iterator.length === 3) {2629 while (++index < size) {2630 key = keys[index];2631 value = object[key];2632 iterator(value, key, createCallback(index, value));2633 }2634 } else {2635 while (++index < size) {2636 value = object[keys[index]];2637 iterator(value, createCallback(index, value));2638 }2639 }2640 }2641 /**2642 * @private2643 */2644 function symbolEachIndexValue(collection, iterator, createCallback) {2645 var value, item;2646 var index = 0;2647 var iter = collection[iteratorSymbol]();2648 if (iterator.length === 3) {2649 while ((item = iter.next()).done === false) {2650 value = item.value;2651 iterator(value, index, createCallback(index++, value));2652 }2653 } else {2654 while ((item = iter.next()).done === false) {2655 value = item.value;2656 iterator(value, createCallback(index++, value));2657 }2658 }2659 return index;2660 }2661 /**2662 * @private2663 */2664 function baseEachKeyValue(object, iterator, createCallback, keys) {2665 var key, value;2666 var index = -1;2667 var size = keys.length;2668 if (iterator.length === 3) {2669 while (++index < size) {2670 key = keys[index];2671 value = object[key];2672 iterator(value, key, createCallback(key, value));2673 }2674 } else {2675 while (++index < size) {2676 key = keys[index];2677 value = object[key];2678 iterator(value, createCallback(key, value));2679 }2680 }2681 }2682 /**2683 * @private2684 */2685 function symbolEachKeyValue(collection, iterator, createCallback) {2686 var value, item;2687 var index = 0;2688 var iter = collection[iteratorSymbol]();2689 if (iterator.length === 3) {2690 while ((item = iter.next()).done === false) {2691 value = item.value;2692 iterator(value, index, createCallback(index++, value));2693 }2694 } else {2695 while ((item = iter.next()).done === false) {2696 value = item.value;2697 iterator(value, createCallback(index++, value));2698 }2699 }2700 return index;2701 }2702 /**2703 * @private2704 * @param {Function} func2705 */2706 function onlyOnce(func) {2707 return function(err, res) {2708 var fn = func;2709 func = throwError;2710 fn(err, res);2711 };2712 }2713 /**2714 * @private2715 * @param {Function} func2716 */2717 function once(func) {2718 return function(err, res) {2719 var fn = func;2720 func = noop;2721 fn(err, res);2722 };2723 }2724 /**2725 * @private2726 * @param {Function} arrayEach2727 * @param {Function} baseEach2728 */2729 function createEach(arrayEach, baseEach, symbolEach) {2730 return function each(collection, iterator, callback) {2731 callback = once(callback || noop);2732 var size, keys;2733 var completed = 0;2734 if (isArray(collection)) {2735 size = collection.length;2736 arrayEach(collection, iterator, done);2737 } else if (!collection) {2738 } else if (iteratorSymbol && collection[iteratorSymbol]) {2739 size = symbolEach(collection, iterator, done);2740 size && size === completed && callback(null);2741 } else if (typeof collection === obj) {2742 keys = nativeKeys(collection);2743 size = keys.length;2744 baseEach(collection, iterator, done, keys);2745 }2746 if (!size) {2747 callback(null);2748 }2749 function done(err, bool) {2750 if (err) {2751 callback = once(callback);2752 callback(err);2753 } else if (++completed === size) {2754 callback(null);2755 } else if (bool === false) {2756 callback = once(callback);2757 callback(null);2758 }2759 }2760 };2761 }2762 /**2763 * @private2764 * @param {Function} arrayEach2765 * @param {Function} baseEach2766 * @param {Function} symbolEach2767 */2768 function createMap(arrayEach, baseEach, symbolEach, useArray) {2769 var init, clone;2770 if (useArray) {2771 init = Array;2772 clone = createArray;2773 } else {2774 init = function() {2775 return {};2776 };2777 clone = objectClone;2778 }2779 return function(collection, iterator, callback) {2780 callback = callback || noop;2781 var size, keys, result;2782 var completed = 0;2783 if (isArray(collection)) {2784 size = collection.length;2785 result = init(size);2786 arrayEach(collection, iterator, createCallback);2787 } else if (!collection) {2788 } else if (iteratorSymbol && collection[iteratorSymbol]) {2789 // TODO: size could be changed2790 result = init(0);2791 size = symbolEach(collection, iterator, createCallback);2792 size && size === completed && callback(null, result);2793 } else if (typeof collection === obj) {2794 keys = nativeKeys(collection);2795 size = keys.length;2796 result = init(size);2797 baseEach(collection, iterator, createCallback, keys);2798 }2799 if (!size) {2800 callback(null, init());2801 }2802 function createCallback(key) {2803 return function done(err, res) {2804 if (key === null) {2805 throwError();2806 }2807 if (err) {2808 key = null;2809 callback = once(callback);2810 callback(err, clone(result));2811 return;2812 }2813 result[key] = res;2814 key = null;2815 if (++completed === size) {2816 callback(null, result);2817 }2818 };2819 }2820 };2821 }2822 /**2823 * @private2824 * @param {Function} arrayEach2825 * @param {Function} baseEach2826 * @param {Function} symbolEach2827 * @param {boolean} bool2828 */2829 function createFilter(arrayEach, baseEach, symbolEach, bool) {2830 return function(collection, iterator, callback) {2831 callback = callback || noop;2832 var size, keys, result;2833 var completed = 0;2834 if (isArray(collection)) {2835 size = collection.length;2836 result = Array(size);2837 arrayEach(collection, iterator, createCallback);2838 } else if (!collection) {2839 } else if (iteratorSymbol && collection[iteratorSymbol]) {2840 result = [];2841 size = symbolEach(collection, iterator, createCallback);2842 size && size === completed && callback(null, compact(result));2843 } else if (typeof collection === obj) {2844 keys = nativeKeys(collection);2845 size = keys.length;2846 result = Array(size);2847 baseEach(collection, iterator, createCallback, keys);2848 }2849 if (!size) {2850 return callback(null, []);2851 }2852 function createCallback(index, value) {2853 return function done(err, res) {2854 if (index === null) {2855 throwError();2856 }2857 if (err) {2858 index = null;2859 callback = once(callback);2860 callback(err);2861 return;2862 }2863 if (!!res === bool) {2864 result[index] = value;2865 }2866 index = null;2867 if (++completed === size) {2868 callback(null, compact(result));2869 }2870 };2871 }2872 };2873 }2874 /**2875 * @private2876 * @param {boolean} bool2877 */2878 function createFilterSeries(bool) {2879 return function(collection, iterator, callback) {2880 callback = onlyOnce(callback || noop);2881 var size, key, value, keys, iter, item, iterate;2882 var sync = false;2883 var completed = 0;2884 var result = [];2885 if (isArray(collection)) {2886 size = collection.length;2887 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;2888 } else if (!collection) {2889 } else if (iteratorSymbol && collection[iteratorSymbol]) {2890 size = Infinity;2891 iter = collection[iteratorSymbol]();2892 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;2893 } else if (typeof collection === obj) {2894 keys = nativeKeys(collection);2895 size = keys.length;2896 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;2897 }2898 if (!size) {2899 return callback(null, []);2900 }2901 iterate();2902 function arrayIterator() {2903 value = collection[completed];2904 iterator(value, done);2905 }2906 function arrayIteratorWithIndex() {2907 value = collection[completed];2908 iterator(value, completed, done);2909 }2910 function symbolIterator() {2911 item = iter.next();2912 value = item.value;2913 item.done ? callback(null, result) : iterator(value, done);2914 }2915 function symbolIteratorWithKey() {2916 item = iter.next();2917 value = item.value;2918 item.done ? callback(null, result) : iterator(value, completed, done);2919 }2920 function objectIterator() {2921 key = keys[completed];2922 value = collection[key];2923 iterator(value, done);2924 }2925 function objectIteratorWithKey() {2926 key = keys[completed];2927 value = collection[key];2928 iterator(value, key, done);2929 }2930 function done(err, res) {2931 if (err) {2932 callback(err);2933 return;2934 }2935 if (!!res === bool) {2936 result[result.length] = value;2937 }2938 if (++completed === size) {2939 iterate = throwError;2940 callback(null, result);2941 } else if (sync) {2942 nextTick(iterate);2943 } else {2944 sync = true;2945 iterate();2946 }2947 sync = false;2948 }2949 };2950 }2951 /**2952 * @private2953 * @param {boolean} bool2954 */2955 function createFilterLimit(bool) {2956 return function(collection, limit, iterator, callback) {2957 callback = callback || noop;2958 var size, index, key, value, keys, iter, item, iterate, result;2959 var sync = false;2960 var started = 0;2961 var completed = 0;2962 if (isArray(collection)) {2963 size = collection.length;2964 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;2965 } else if (!collection) {2966 } else if (iteratorSymbol && collection[iteratorSymbol]) {2967 size = Infinity;2968 result = [];2969 iter = collection[iteratorSymbol]();2970 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;2971 } else if (typeof collection === obj) {2972 keys = nativeKeys(collection);2973 size = keys.length;2974 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;2975 }2976 if (!size || isNaN(limit) || limit < 1) {2977 return callback(null, []);2978 }2979 result = result || Array(size);2980 timesSync(limit > size ? size : limit, iterate);2981 function arrayIterator() {2982 index = started++;2983 if (index < size) {2984 value = collection[index];2985 iterator(value, createCallback(value, index));2986 }2987 }2988 function arrayIteratorWithIndex() {2989 index = started++;2990 if (index < size) {2991 value = collection[index];2992 iterator(value, index, createCallback(value, index));2993 }2994 }2995 function symbolIterator() {2996 item = iter.next();2997 if (item.done === false) {2998 value = item.value;2999 iterator(value, createCallback(value, started++));3000 } else if (completed === started && iterator !== noop) {3001 iterator = noop;3002 callback(null, compact(result));3003 }3004 }3005 function symbolIteratorWithKey() {3006 item = iter.next();3007 if (item.done === false) {3008 value = item.value;3009 iterator(value, started, createCallback(value, started++));3010 } else if (completed === started && iterator !== noop) {3011 iterator = noop;3012 callback(null, compact(result));3013 }3014 }3015 function objectIterator() {3016 index = started++;3017 if (index < size) {3018 value = collection[keys[index]];3019 iterator(value, createCallback(value, index));3020 }3021 }3022 function objectIteratorWithKey() {3023 index = started++;3024 if (index < size) {3025 key = keys[index];3026 value = collection[key];3027 iterator(value, key, createCallback(value, index));3028 }3029 }3030 function createCallback(value, index) {3031 return function(err, res) {3032 if (index === null) {3033 throwError();3034 }3035 if (err) {3036 index = null;3037 iterate = noop;3038 callback = once(callback);3039 callback(err);3040 return;3041 }3042 if (!!res === bool) {3043 result[index] = value;3044 }3045 index = null;3046 if (++completed === size) {3047 callback = onlyOnce(callback);3048 callback(null, compact(result));3049 } else if (sync) {3050 nextTick(iterate);3051 } else {3052 sync = true;3053 iterate();3054 }3055 sync = false;3056 };3057 }3058 };3059 }3060 /**3061 * @memberof async3062 * @namespace eachSeries3063 * @param {Array|Object} collection3064 * @param {Function} iterator3065 * @param {Function} callback3066 * @example3067 *3068 * // array3069 * var order = [];3070 * var array = [1, 3, 2];3071 * var iterator = function(num, done) {3072 * setTimeout(function() {3073 * order.push(num);3074 * done();3075 * }, num * 10);3076 * };3077 * async.eachSeries(array, iterator, function(err, res) {3078 * console.log(res); // undefined3079 * console.log(order); // [1, 3, 2]3080 * });3081 *3082 * @example3083 *3084 * // array with index3085 * var order = [];3086 * var array = [1, 3, 2];3087 * var iterator = function(num, index, done) {3088 * setTimeout(function() {3089 * order.push([num, index]);3090 * done();3091 * }, num * 10);3092 * };3093 * async.eachSeries(array, iterator, function(err, res) {3094 * console.log(res); // undefined3095 * console.log(order); // [[1, 0], [3, 1], [2, 2]]3096 * });3097 *3098 * @example3099 *3100 * // object3101 * var order = [];3102 * var object = { a: 1, b: 3, c: 2 };3103 * var iterator = function(num, done) {3104 * setTimeout(function() {3105 * order.push(num);3106 * done();3107 * }, num * 10);3108 * };3109 * async.eachSeries(object, iterator, function(err, res) {3110 * console.log(res); // undefined3111 * console.log(order); // [1, 3, 2]3112 * });3113 *3114 * @example3115 *3116 * // object with key3117 * var order = [];3118 * var object = { a: 1, b: 3, c: 2 };3119 * var iterator = function(num, key, done) {3120 * setTimeout(function() {3121 * order.push([num, key]);3122 * done();3123 * }, num * 10);3124 * };3125 * async.eachSeries(object, iterator, function(err, res) {3126 * console.log(res); // undefined3127 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b']]3128 * });3129 *3130 * @example3131 *3132 * // break3133 * var order = [];3134 * var array = [1, 3, 2];3135 * var iterator = function(num, done) {3136 * setTimeout(function() {3137 * order.push(num);3138 * done(null, num !== 3);3139 * }, num * 10);3140 * };3141 * async.eachSeries(array, iterator, function(err, res) {3142 * console.log(res); // undefined3143 * console.log(order); // [1, 3]3144 * });3145 */3146 function eachSeries(collection, iterator, callback) {3147 callback = onlyOnce(callback || noop);3148 var size, key, keys, iter, item, iterate;3149 var sync = false;3150 var completed = 0;3151 if (isArray(collection)) {3152 size = collection.length;3153 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;3154 } else if (!collection) {3155 } else if (iteratorSymbol && collection[iteratorSymbol]) {3156 size = Infinity;3157 iter = collection[iteratorSymbol]();3158 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;3159 } else if (typeof collection === obj) {3160 keys = nativeKeys(collection);3161 size = keys.length;3162 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;3163 }3164 if (!size) {3165 return callback(null);3166 }3167 iterate();3168 function arrayIterator() {3169 iterator(collection[completed], done);3170 }3171 function arrayIteratorWithIndex() {3172 iterator(collection[completed], completed, done);3173 }3174 function symbolIterator() {3175 item = iter.next();3176 item.done ? callback(null) : iterator(item.value, done);3177 }3178 function symbolIteratorWithKey() {3179 item = iter.next();3180 item.done ? callback(null) : iterator(item.value, completed, done);3181 }3182 function objectIterator() {3183 iterator(collection[keys[completed]], done);3184 }3185 function objectIteratorWithKey() {3186 key = keys[completed];3187 iterator(collection[key], key, done);3188 }3189 function done(err, bool) {3190 if (err) {3191 callback(err);3192 } else if (++completed === size || bool === false) {3193 iterate = throwError;3194 callback(null);3195 } else if (sync) {3196 nextTick(iterate);3197 } else {3198 sync = true;3199 iterate();3200 }3201 sync = false;3202 }3203 }3204 /**3205 * @memberof async3206 * @namespace eachLimit3207 * @param {Array|Object} collection3208 * @param {number} limit - limit >= 13209 * @param {Function} iterator3210 * @param {Function} callback3211 * @example3212 *3213 * // array3214 * var order = [];3215 * var array = [1, 5, 3, 4, 2];3216 * var iterator = function(num, done) {3217 * setTimeout(function() {3218 * order.push(num);3219 * done();3220 * }, num * 10);3221 * };3222 * async.eachLimit(array, 2, iterator, function(err, res) {3223 * console.log(res); // undefined3224 * console.log(order); // [1, 3, 5, 2, 4]3225 * });3226 *3227 * @example3228 *3229 * // array with index3230 * var order = [];3231 * var array = [1, 5, 3, 4, 2];3232 * var iterator = function(num, index, done) {3233 * setTimeout(function() {3234 * order.push([num, index]);3235 * done();3236 * }, num * 10);3237 * };3238 * async.eachLimit(array, 2, iterator, function(err, res) {3239 * console.log(res); // undefined3240 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]3241 * });3242 *3243 * @example3244 *3245 * // object3246 * var order = [];3247 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };3248 * var iterator = function(num, done) {3249 * setTimeout(function() {3250 * order.push(num);3251 * done();3252 * }, num * 10);3253 * };3254 * async.eachLimit(object, 2, iterator, function(err, res) {3255 * console.log(res); // undefined3256 * console.log(order); // [1, 3, 5, 2, 4]3257 * });3258 *3259 * @example3260 *3261 * // object with key3262 * var order = [];3263 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };3264 * var iterator = function(num, key, done) {3265 * setTimeout(function() {3266 * order.push([num, key]);3267 * done();3268 * }, num * 10);3269 * };3270 * async.eachLimit(object, 2, iterator, function(err, res) {3271 * console.log(res); // undefined3272 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]3273 * });3274 *3275 * @example3276 *3277 * // break3278 * var order = [];3279 * var array = [1, 5, 3, 4, 2];3280 * var iterator = function(num, done) {3281 * setTimeout(function() {3282 * order.push(num);3283 * done(null, num !== 5);3284 * }, num * 10);3285 * };3286 * async.eachLimit(array, 2, iterator, function(err, res) {3287 * console.log(res); // undefined3288 * console.log(order); // [1, 3, 5]3289 * });3290 *3291 */3292 function eachLimit(collection, limit, iterator, callback) {3293 callback = callback || noop;3294 var size, index, key, keys, iter, item, iterate;3295 var sync = false;3296 var started = 0;3297 var completed = 0;3298 if (isArray(collection)) {3299 size = collection.length;3300 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;3301 } else if (!collection) {3302 } else if (iteratorSymbol && collection[iteratorSymbol]) {3303 size = Infinity;3304 iter = collection[iteratorSymbol]();3305 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;3306 } else if (typeof collection === obj) {3307 keys = nativeKeys(collection);3308 size = keys.length;3309 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;3310 } else {3311 return callback(null);3312 }3313 if (!size || isNaN(limit) || limit < 1) {3314 return callback(null);3315 }3316 timesSync(limit > size ? size : limit, iterate);3317 function arrayIterator() {3318 if (started < size) {3319 iterator(collection[started++], done);3320 }3321 }3322 function arrayIteratorWithIndex() {3323 index = started++;3324 if (index < size) {3325 iterator(collection[index], index, done);3326 }3327 }3328 function symbolIterator() {3329 item = iter.next();3330 if (item.done === false) {3331 started++;3332 iterator(item.value, done);3333 } else if (completed === started && iterator !== noop) {3334 iterator = noop;3335 callback(null);3336 }3337 }3338 function symbolIteratorWithKey() {3339 item = iter.next();3340 if (item.done === false) {3341 iterator(item.value, started++, done);3342 } else if (completed === started && iterator !== noop) {3343 iterator = noop;3344 callback(null);3345 }3346 }3347 function objectIterator() {3348 if (started < size) {3349 iterator(collection[keys[started++]], done);3350 }3351 }3352 function objectIteratorWithKey() {3353 index = started++;3354 if (index < size) {3355 key = keys[index];3356 iterator(collection[key], key, done);3357 }3358 }3359 function done(err, bool) {3360 if (err || bool === false) {3361 iterate = noop;3362 callback = once(callback);3363 callback(err);3364 } else if (++completed === size) {3365 iterator = noop;3366 iterate = throwError;3367 callback = onlyOnce(callback);3368 callback(null);3369 } else if (sync) {3370 nextTick(iterate);3371 } else {3372 sync = true;3373 iterate();3374 }3375 sync = false;3376 }3377 }3378 /**3379 * @memberof async3380 * @namespace mapSeries3381 * @param {Array|Object} collection3382 * @param {Function} iterator3383 * @param {Function} callback3384 * @example3385 *3386 * // array3387 * var order = [];3388 * var array = [1, 3, 2];3389 * var iterator = function(num, done) {3390 * setTimeout(function() {3391 * order.push(num);3392 * done(null, num);3393 * }, num * 10);3394 * };3395 * async.mapSeries(array, iterator, function(err, res) {3396 * console.log(res); // [1, 3, 2];3397 * console.log(order); // [1, 3, 2]3398 * });3399 *3400 * @example3401 *3402 * // array with index3403 * var order = [];3404 * var array = [1, 3, 2];3405 * var iterator = function(num, index, done) {3406 * setTimeout(function() {3407 * order.push([num, index]);3408 * done(null, num);3409 * }, num * 10);3410 * };3411 * async.mapSeries(array, iterator, function(err, res) {3412 * console.log(res); // [1, 3, 2]3413 * console.log(order); // [[1, 0], [3, 1], [2, 2]]3414 * });3415 *3416 * @example3417 *3418 * // object3419 * var order = [];3420 * var object = { a: 1, b: 3, c: 2 };3421 * var iterator = function(num, done) {3422 * setTimeout(function() {3423 * order.push(num);3424 * done(null, num);3425 * }, num * 10);3426 * };3427 * async.mapSeries(object, iterator, function(err, res) {3428 * console.log(res); // [1, 3, 2]3429 * console.log(order); // [1, 3, 2]3430 * });3431 *3432 * @example3433 *3434 * // object with key3435 * var order = [];3436 * var object = { a: 1, b: 3, c: 2 };3437 * var iterator = function(num, key, done) {3438 * setTimeout(function() {3439 * order.push([num, key]);3440 * done(null, num);3441 * }, num * 10);3442 * };3443 * async.mapSeries(object, iterator, function(err, res) {3444 * console.log(res); // [1, 3, 2]3445 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]3446 * });3447 *3448 */3449 function mapSeries(collection, iterator, callback) {3450 callback = callback || noop;3451 var size, key, keys, iter, item, result, iterate;3452 var sync = false;3453 var completed = 0;3454 if (isArray(collection)) {3455 size = collection.length;3456 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;3457 } else if (!collection) {3458 } else if (iteratorSymbol && collection[iteratorSymbol]) {3459 size = Infinity;3460 result = [];3461 iter = collection[iteratorSymbol]();3462 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;3463 } else if (typeof collection === obj) {3464 keys = nativeKeys(collection);3465 size = keys.length;3466 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;3467 }3468 if (!size) {3469 return callback(null, []);3470 }3471 result = result || Array(size);3472 iterate();3473 function arrayIterator() {3474 iterator(collection[completed], done);3475 }3476 function arrayIteratorWithIndex() {3477 iterator(collection[completed], completed, done);3478 }3479 function symbolIterator() {3480 item = iter.next();3481 item.done ? callback(null, result) : iterator(item.value, done);3482 }3483 function symbolIteratorWithKey() {3484 item = iter.next();3485 item.done ? callback(null, result) : iterator(item.value, completed, done);3486 }3487 function objectIterator() {3488 iterator(collection[keys[completed]], done);3489 }3490 function objectIteratorWithKey() {3491 key = keys[completed];3492 iterator(collection[key], key, done);3493 }3494 function done(err, res) {3495 if (err) {3496 iterate = throwError;3497 callback = onlyOnce(callback);3498 callback(err, createArray(result));3499 return;3500 }3501 result[completed] = res;3502 if (++completed === size) {3503 iterate = throwError;3504 callback(null, result);3505 callback = throwError;3506 } else if (sync) {3507 nextTick(iterate);3508 } else {3509 sync = true;3510 iterate();3511 }3512 sync = false;3513 }3514 }3515 /**3516 * @memberof async3517 * @namespace mapLimit3518 * @param {Array|Object} collection3519 * @param {number} limit - limit >= 13520 * @param {Function} iterator3521 * @param {Function} callback3522 * @example3523 *3524 * // array3525 * var order = [];3526 * var array = [1, 5, 3, 4, 2];3527 * var iterator = function(num, done) {3528 * setTimeout(function() {3529 * order.push(num);3530 * done(null, num);3531 * }, num * 10);3532 * };3533 * async.mapLimit(array, 2, iterator, function(err, res) {3534 * console.log(res); // [1, 5, 3, 4, 2]3535 * console.log(order); // [1, 3, 5, 2, 4]3536 * });3537 *3538 * @example3539 *3540 * // array with index3541 * var order = [];3542 * var array = [1, 5, 3, 4, 2];3543 * var iterator = function(num, index, done) {3544 * setTimeout(function() {3545 * order.push([num, index]);3546 * done(null, num);3547 * }, num * 10);3548 * };3549 * async.mapLimit(array, 2, iterator, function(err, res) {3550 * console.log(res); // [1, 5, 3, 4, 2]3551 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]3552 * });3553 *3554 * @example3555 *3556 * // object3557 * var order = [];3558 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };3559 * var iterator = function(num, done) {3560 * setTimeout(function() {3561 * order.push(num);3562 * done(null, num);3563 * }, num * 10);3564 * };3565 * async.mapLimit(object, 2, iterator, function(err, res) {3566 * console.log(res); // [1, 5, 3, 4, 2]3567 * console.log(order); // [1, 3, 5, 2, 4]3568 * });3569 *3570 * @example3571 *3572 * // object with key3573 * var order = [];3574 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };3575 * var iterator = function(num, key, done) {3576 * setTimeout(function() {3577 * order.push([num, key]);3578 * done(null, num);3579 * }, num * 10);3580 * };3581 * async.mapLimit(object, 2, iterator, function(err, res) {3582 * console.log(res); // [1, 5, 3, 4, 2]3583 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]3584 * });3585 *3586 */3587 function mapLimit(collection, limit, iterator, callback) {3588 callback = callback || noop;3589 var size, index, key, keys, iter, item, result, iterate;3590 var sync = false;3591 var started = 0;3592 var completed = 0;3593 if (isArray(collection)) {3594 size = collection.length;3595 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;3596 } else if (!collection) {3597 } else if (iteratorSymbol && collection[iteratorSymbol]) {3598 size = Infinity;3599 result = [];3600 iter = collection[iteratorSymbol]();3601 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;3602 } else if (typeof collection === obj) {3603 keys = nativeKeys(collection);3604 size = keys.length;3605 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;3606 }3607 if (!size || isNaN(limit) || limit < 1) {3608 return callback(null, []);3609 }3610 result = result || Array(size);3611 timesSync(limit > size ? size : limit, iterate);3612 function arrayIterator() {3613 index = started++;3614 if (index < size) {3615 iterator(collection[index], createCallback(index));3616 }3617 }3618 function arrayIteratorWithIndex() {3619 index = started++;3620 if (index < size) {3621 iterator(collection[index], index, createCallback(index));3622 }3623 }3624 function symbolIterator() {3625 item = iter.next();3626 if (item.done === false) {3627 iterator(item.value, createCallback(started++));3628 } else if (completed === started && iterator !== noop) {3629 iterator = noop;3630 callback(null, result);3631 }3632 }3633 function symbolIteratorWithKey() {3634 item = iter.next();3635 if (item.done === false) {3636 iterator(item.value, started, createCallback(started++));3637 } else if (completed === started && iterator !== noop) {3638 iterator = noop;3639 callback(null, result);3640 }3641 }3642 function objectIterator() {3643 index = started++;3644 if (index < size) {3645 iterator(collection[keys[index]], createCallback(index));3646 }3647 }3648 function objectIteratorWithKey() {3649 index = started++;3650 if (index < size) {3651 key = keys[index];3652 iterator(collection[key], key, createCallback(index));3653 }3654 }3655 function createCallback(index) {3656 return function(err, res) {3657 if (index === null) {3658 throwError();3659 }3660 if (err) {3661 index = null;3662 iterate = noop;3663 callback = once(callback);3664 callback(err, createArray(result));3665 return;3666 }3667 result[index] = res;3668 index = null;3669 if (++completed === size) {3670 iterate = throwError;3671 callback(null, result);3672 callback = throwError;3673 } else if (sync) {3674 nextTick(iterate);3675 } else {3676 sync = true;3677 iterate();3678 }3679 sync = false;3680 };3681 }3682 }3683 /**3684 * @memberof async3685 * @namespace mapValuesSeries3686 * @param {Array|Object} collection3687 * @param {Function} iterator3688 * @param {Function} callback3689 * @example3690 *3691 * // array3692 * var order = [];3693 * var array = [1, 3, 2];3694 * var iterator = function(num, done) {3695 * setTimeout(function() {3696 * order.push(num);3697 * done(null, num);3698 * }, num * 10);3699 * };3700 * async.mapValuesSeries(array, iterator, function(err, res) {3701 * console.log(res); // { '0': 1, '1': 3, '2': 2 }3702 * console.log(order); // [1, 3, 2]3703 * });3704 *3705 * @example3706 *3707 * // array with index3708 * var order = [];3709 * var array = [1, 3, 2];3710 * var iterator = function(num, index, done) {3711 * setTimeout(function() {3712 * order.push([num, index]);3713 * done(null, num);3714 * }, num * 10);3715 * };3716 * async.mapValuesSeries(array, iterator, function(err, res) {3717 * console.log(res); // { '0': 1, '1': 3, '2': 2 }3718 * console.log(order); // [[1, 0], [3, 1], [2, 2]]3719 * });3720 *3721 * @example3722 *3723 * // object3724 * var order = [];3725 * var object = { a: 1, b: 3, c: 2 };3726 * var iterator = function(num, done) {3727 * setTimeout(function() {3728 * order.push(num);3729 * done(null, num);3730 * }, num * 10);3731 * };3732 * async.mapValuesSeries(object, iterator, function(err, res) {3733 * console.log(res); // { a: 1, b: 3, c: 2 }3734 * console.log(order); // [1, 3, 2]3735 * });3736 *3737 * @example3738 *3739 * // object with key3740 * var order = [];3741 * var object = { a: 1, b: 3, c: 2 };3742 * var iterator = function(num, key, done) {3743 * setTimeout(function() {3744 * order.push([num, key]);3745 * done(null, num);3746 * }, num * 10);3747 * };3748 * async.mapValuesSeries(object, iterator, function(err, res) {3749 * console.log(res); // { a: 1, b: 3, c: 2 }3750 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]3751 * });3752 *3753 */3754 function mapValuesSeries(collection, iterator, callback) {3755 callback = callback || noop;3756 var size, key, keys, iter, item, iterate;3757 var sync = false;3758 var result = {};3759 var completed = 0;3760 if (isArray(collection)) {3761 size = collection.length;3762 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;3763 } else if (!collection) {3764 } else if (iteratorSymbol && collection[iteratorSymbol]) {3765 size = Infinity;3766 iter = collection[iteratorSymbol]();3767 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;3768 } else if (typeof collection === obj) {3769 keys = nativeKeys(collection);3770 size = keys.length;3771 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;3772 }3773 if (!size) {3774 return callback(null, result);3775 }3776 iterate();3777 function arrayIterator() {3778 key = completed;3779 iterator(collection[completed], done);3780 }3781 function arrayIteratorWithIndex() {3782 key = completed;3783 iterator(collection[completed], completed, done);3784 }3785 function symbolIterator() {3786 key = completed;3787 item = iter.next();3788 item.done ? callback(null, result) : iterator(item.value, done);3789 }3790 function symbolIteratorWithKey() {3791 key = completed;3792 item = iter.next();3793 item.done ? callback(null, result) : iterator(item.value, completed, done);3794 }3795 function objectIterator() {3796 key = keys[completed];3797 iterator(collection[key], done);3798 }3799 function objectIteratorWithKey() {3800 key = keys[completed];3801 iterator(collection[key], key, done);3802 }3803 function done(err, res) {3804 if (err) {3805 iterate = throwError;3806 callback = onlyOnce(callback);3807 callback(err, objectClone(result));3808 return;3809 }3810 result[key] = res;3811 if (++completed === size) {3812 iterate = throwError;3813 callback(null, result);3814 callback = throwError;3815 } else if (sync) {3816 nextTick(iterate);3817 } else {3818 sync = true;3819 iterate();3820 }3821 sync = false;3822 }3823 }3824 /**3825 * @memberof async3826 * @namespace mapValuesLimit3827 * @param {Array|Object} collection3828 * @param {number} limit - limit >= 13829 * @param {Function} iterator3830 * @param {Function} callback3831 * @example3832 *3833 * // array3834 * var order = [];3835 * var array = [1, 5, 3, 4, 2];3836 * var iterator = function(num, done) {3837 * setTimeout(function() {3838 * order.push(num);3839 * done(null, num);3840 * }, num * 10);3841 * };3842 * async.mapValuesLimit(array, 2, iterator, function(err, res) {3843 * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }3844 * console.log(order); // [1, 3, 5, 2, 4]3845 * });3846 *3847 * @example3848 *3849 * // array with index3850 * var order = [];3851 * var array = [1, 5, 3, 4, 2];3852 * var iterator = function(num, index, done) {3853 * setTimeout(function() {3854 * order.push([num, index]);3855 * done(null, num);3856 * }, num * 10);3857 * };3858 * async.mapValuesLimit(array, 2, iterator, function(err, res) {3859 * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }3860 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]3861 * });3862 *3863 * @example3864 *3865 * // object3866 * var order = [];3867 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };3868 * var iterator = function(num, done) {3869 * setTimeout(function() {3870 * order.push(num);3871 * done(null, num);3872 * }, num * 10);3873 * };3874 * async.mapValuesLimit(object, 2, iterator, function(err, res) {3875 * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }3876 * console.log(order); // [1, 3, 5, 2, 4]3877 * });3878 *3879 * @example3880 *3881 * // object with key3882 * var order = [];3883 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };3884 * var iterator = function(num, key, done) {3885 * setTimeout(function() {3886 * order.push([num, key]);3887 * done(null, num);3888 * }, num * 10);3889 * };3890 * async.mapValuesLimit(object, 2, iterator, function(err, res) {3891 * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 }3892 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]3893 * });3894 *3895 */3896 function mapValuesLimit(collection, limit, iterator, callback) {3897 callback = callback || noop;3898 var size, index, key, keys, iter, item, iterate;3899 var sync = false;3900 var result = {};3901 var started = 0;3902 var completed = 0;3903 if (isArray(collection)) {3904 size = collection.length;3905 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;3906 } else if (!collection) {3907 } else if (iteratorSymbol && collection[iteratorSymbol]) {3908 size = Infinity;3909 iter = collection[iteratorSymbol]();3910 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;3911 } else if (typeof collection === obj) {3912 keys = nativeKeys(collection);3913 size = keys.length;3914 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;3915 }3916 if (!size || isNaN(limit) || limit < 1) {3917 return callback(null, result);3918 }3919 timesSync(limit > size ? size : limit, iterate);3920 function arrayIterator() {3921 index = started++;3922 if (index < size) {3923 iterator(collection[index], createCallback(index));3924 }3925 }3926 function arrayIteratorWithIndex() {3927 index = started++;3928 if (index < size) {3929 iterator(collection[index], index, createCallback(index));3930 }3931 }3932 function symbolIterator() {3933 item = iter.next();3934 if (item.done === false) {3935 iterator(item.value, createCallback(started++));3936 } else if (completed === started && iterator !== noop) {3937 iterator = noop;3938 callback(null, result);3939 }3940 }3941 function symbolIteratorWithKey() {3942 item = iter.next();3943 if (item.done === false) {3944 iterator(item.value, started, createCallback(started++));3945 } else if (completed === started && iterator !== noop) {3946 iterator = noop;3947 callback(null, result);3948 }3949 }3950 function objectIterator() {3951 index = started++;3952 if (index < size) {3953 key = keys[index];3954 iterator(collection[key], createCallback(key));3955 }3956 }3957 function objectIteratorWithKey() {3958 index = started++;3959 if (index < size) {3960 key = keys[index];3961 iterator(collection[key], key, createCallback(key));3962 }3963 }3964 function createCallback(key) {3965 return function(err, res) {3966 if (key === null) {3967 throwError();3968 }3969 if (err) {3970 key = null;3971 iterate = noop;3972 callback = once(callback);3973 callback(err, objectClone(result));3974 return;3975 }3976 result[key] = res;3977 key = null;3978 if (++completed === size) {3979 callback(null, result);3980 } else if (sync) {3981 nextTick(iterate);3982 } else {3983 sync = true;3984 iterate();3985 }3986 sync = false;3987 };3988 }3989 }3990 /**3991 * @private3992 * @param {Function} arrayEach3993 * @param {Function} baseEach3994 * @param {Function} symbolEach3995 * @param {boolean} bool3996 */3997 function createDetect(arrayEach, baseEach, symbolEach, bool) {3998 return function(collection, iterator, callback) {3999 callback = callback || noop;4000 var size, keys;4001 var completed = 0;4002 if (isArray(collection)) {4003 size = collection.length;4004 arrayEach(collection, iterator, createCallback);4005 } else if (!collection) {4006 } else if (iteratorSymbol && collection[iteratorSymbol]) {4007 size = symbolEach(collection, iterator, createCallback);4008 size && size === completed && callback(null);4009 } else if (typeof collection === obj) {4010 keys = nativeKeys(collection);4011 size = keys.length;4012 baseEach(collection, iterator, createCallback, keys);4013 }4014 if (!size) {4015 callback(null);4016 }4017 function createCallback(value) {4018 var called = false;4019 return function done(err, res) {4020 if (called) {4021 throwError();4022 }4023 called = true;4024 if (err) {4025 callback = once(callback);4026 callback(err);4027 } else if (!!res === bool) {4028 callback = once(callback);4029 callback(null, value);4030 } else if (++completed === size) {4031 callback(null);4032 }4033 };4034 }4035 };4036 }4037 /**4038 * @private4039 * @param {boolean} bool4040 */4041 function createDetectSeries(bool) {4042 return function(collection, iterator, callback) {4043 callback = onlyOnce(callback || noop);4044 var size, key, value, keys, iter, item, iterate;4045 var sync = false;4046 var completed = 0;4047 if (isArray(collection)) {4048 size = collection.length;4049 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;4050 } else if (!collection) {4051 } else if (iteratorSymbol && collection[iteratorSymbol]) {4052 size = Infinity;4053 iter = collection[iteratorSymbol]();4054 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;4055 } else if (typeof collection === obj) {4056 keys = nativeKeys(collection);4057 size = keys.length;4058 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;4059 }4060 if (!size) {4061 return callback(null);4062 }4063 iterate();4064 function arrayIterator() {4065 value = collection[completed];4066 iterator(value, done);4067 }4068 function arrayIteratorWithIndex() {4069 value = collection[completed];4070 iterator(value, completed, done);4071 }4072 function symbolIterator() {4073 item = iter.next();4074 value = item.value;4075 item.done ? callback(null) : iterator(value, done);4076 }4077 function symbolIteratorWithKey() {4078 item = iter.next();4079 value = item.value;4080 item.done ? callback(null) : iterator(value, completed, done);4081 }4082 function objectIterator() {4083 value = collection[keys[completed]];4084 iterator(value, done);4085 }4086 function objectIteratorWithKey() {4087 key = keys[completed];4088 value = collection[key];4089 iterator(value, key, done);4090 }4091 function done(err, res) {4092 if (err) {4093 callback(err);4094 } else if (!!res === bool) {4095 iterate = throwError;4096 callback(null, value);4097 } else if (++completed === size) {4098 iterate = throwError;4099 callback(null);4100 } else if (sync) {4101 nextTick(iterate);4102 } else {4103 sync = true;4104 iterate();4105 }4106 sync = false;4107 }4108 };4109 }4110 /**4111 * @private4112 * @param {boolean} bool4113 */4114 function createDetectLimit(bool) {4115 return function(collection, limit, iterator, callback) {4116 callback = callback || noop;4117 var size, index, key, value, keys, iter, item, iterate;4118 var sync = false;4119 var started = 0;4120 var completed = 0;4121 if (isArray(collection)) {4122 size = collection.length;4123 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;4124 } else if (!collection) {4125 } else if (iteratorSymbol && collection[iteratorSymbol]) {4126 size = Infinity;4127 iter = collection[iteratorSymbol]();4128 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;4129 } else if (typeof collection === obj) {4130 keys = nativeKeys(collection);4131 size = keys.length;4132 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;4133 }4134 if (!size || isNaN(limit) || limit < 1) {4135 return callback(null);4136 }4137 timesSync(limit > size ? size : limit, iterate);4138 function arrayIterator() {4139 index = started++;4140 if (index < size) {4141 value = collection[index];4142 iterator(value, createCallback(value));4143 }4144 }4145 function arrayIteratorWithIndex() {4146 index = started++;4147 if (index < size) {4148 value = collection[index];4149 iterator(value, index, createCallback(value));4150 }4151 }4152 function symbolIterator() {4153 item = iter.next();4154 if (item.done === false) {4155 started++;4156 value = item.value;4157 iterator(value, createCallback(value));4158 } else if (completed === started && iterator !== noop) {4159 iterator = noop;4160 callback(null);4161 }4162 }4163 function symbolIteratorWithKey() {4164 item = iter.next();4165 if (item.done === false) {4166 value = item.value;4167 iterator(value, started++, createCallback(value));4168 } else if (completed === started && iterator !== noop) {4169 iterator = noop;4170 callback(null);4171 }4172 }4173 function objectIterator() {4174 index = started++;4175 if (index < size) {4176 value = collection[keys[index]];4177 iterator(value, createCallback(value));4178 }4179 }4180 function objectIteratorWithKey() {4181 if (started < size) {4182 key = keys[started++];4183 value = collection[key];4184 iterator(value, key, createCallback(value));4185 }4186 }4187 function createCallback(value) {4188 var called = false;4189 return function(err, res) {4190 if (called) {4191 throwError();4192 }4193 called = true;4194 if (err) {4195 iterate = noop;4196 callback = once(callback);4197 callback(err);4198 } else if (!!res === bool) {4199 iterate = noop;4200 callback = once(callback);4201 callback(null, value);4202 } else if (++completed === size) {4203 callback(null);4204 } else if (sync) {4205 nextTick(iterate);4206 } else {4207 sync = true;4208 iterate();4209 }4210 sync = false;4211 };4212 }4213 };4214 }4215 /**4216 * @private4217 * @param {Function} arrayEach4218 * @param {Function} baseEach4219 * @param {Function} symbolEach4220 * @param {boolean} bool4221 */4222 function createPick(arrayEach, baseEach, symbolEach, bool) {4223 return function(collection, iterator, callback) {4224 callback = callback || noop;4225 var size, keys;4226 var completed = 0;4227 var result = {};4228 if (isArray(collection)) {4229 size = collection.length;4230 arrayEach(collection, iterator, createCallback);4231 } else if (!collection) {4232 } else if (iteratorSymbol && collection[iteratorSymbol]) {4233 size = symbolEach(collection, iterator, createCallback);4234 size && size === completed && callback(null, result);4235 } else if (typeof collection === obj) {4236 keys = nativeKeys(collection);4237 size = keys.length;4238 baseEach(collection, iterator, createCallback, keys);4239 }4240 if (!size) {4241 return callback(null, {});4242 }4243 function createCallback(key, value) {4244 return function done(err, res) {4245 if (key === null) {4246 throwError();4247 }4248 if (err) {4249 key = null;4250 callback = once(callback);4251 callback(err, objectClone(result));4252 return;4253 }4254 if (!!res === bool) {4255 result[key] = value;4256 }4257 key = null;4258 if (++completed === size) {4259 callback(null, result);4260 }4261 };4262 }4263 };4264 }4265 /**4266 * @private4267 * @param {boolean} bool4268 */4269 function createPickSeries(bool) {4270 return function(collection, iterator, callback) {4271 callback = onlyOnce(callback || noop);4272 var size, key, value, keys, iter, item, iterate;4273 var sync = false;4274 var result = {};4275 var completed = 0;4276 if (isArray(collection)) {4277 size = collection.length;4278 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;4279 } else if (!collection) {4280 } else if (iteratorSymbol && collection[iteratorSymbol]) {4281 size = Infinity;4282 iter = collection[iteratorSymbol]();4283 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;4284 } else if (typeof collection === obj) {4285 keys = nativeKeys(collection);4286 size = keys.length;4287 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;4288 }4289 if (!size) {4290 return callback(null, {});4291 }4292 iterate();4293 function arrayIterator() {4294 key = completed;4295 value = collection[completed];4296 iterator(value, done);4297 }4298 function arrayIteratorWithIndex() {4299 key = completed;4300 value = collection[completed];4301 iterator(value, completed, done);4302 }4303 function symbolIterator() {4304 key = completed;4305 item = iter.next();4306 value = item.value;4307 item.done ? callback(null, result) : iterator(value, done);4308 }4309 function symbolIteratorWithKey() {4310 key = completed;4311 item = iter.next();4312 value = item.value;4313 item.done ? callback(null, result) : iterator(value, key, done);4314 }4315 function objectIterator() {4316 key = keys[completed];4317 value = collection[key];4318 iterator(value, done);4319 }4320 function objectIteratorWithKey() {4321 key = keys[completed];4322 value = collection[key];4323 iterator(value, key, done);4324 }4325 function done(err, res) {4326 if (err) {4327 callback(err, result);4328 return;4329 }4330 if (!!res === bool) {4331 result[key] = value;4332 }4333 if (++completed === size) {4334 iterate = throwError;4335 callback(null, result);4336 } else if (sync) {4337 nextTick(iterate);4338 } else {4339 sync = true;4340 iterate();4341 }4342 sync = false;4343 }4344 };4345 }4346 /**4347 * @private4348 * @param {boolean} bool4349 */4350 function createPickLimit(bool) {4351 return function(collection, limit, iterator, callback) {4352 callback = callback || noop;4353 var size, index, key, value, keys, iter, item, iterate;4354 var sync = false;4355 var result = {};4356 var started = 0;4357 var completed = 0;4358 if (isArray(collection)) {4359 size = collection.length;4360 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;4361 } else if (!collection) {4362 } else if (iteratorSymbol && collection[iteratorSymbol]) {4363 size = Infinity;4364 iter = collection[iteratorSymbol]();4365 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;4366 } else if (typeof collection === obj) {4367 keys = nativeKeys(collection);4368 size = keys.length;4369 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;4370 }4371 if (!size || isNaN(limit) || limit < 1) {4372 return callback(null, {});4373 }4374 timesSync(limit > size ? size : limit, iterate);4375 function arrayIterator() {4376 index = started++;4377 if (index < size) {4378 value = collection[index];4379 iterator(value, createCallback(value, index));4380 }4381 }4382 function arrayIteratorWithIndex() {4383 index = started++;4384 if (index < size) {4385 value = collection[index];4386 iterator(value, index, createCallback(value, index));4387 }4388 }4389 function symbolIterator() {4390 item = iter.next();4391 if (item.done === false) {4392 value = item.value;4393 iterator(value, createCallback(value, started++));4394 } else if (completed === started && iterator !== noop) {4395 iterator = noop;4396 callback(null, result);4397 }4398 }4399 function symbolIteratorWithKey() {4400 item = iter.next();4401 if (item.done === false) {4402 value = item.value;4403 iterator(value, started, createCallback(value, started++));4404 } else if (completed === started && iterator !== noop) {4405 iterator = noop;4406 callback(null, result);4407 }4408 }4409 function objectIterator() {4410 if (started < size) {4411 key = keys[started++];4412 value = collection[key];4413 iterator(value, createCallback(value, key));4414 }4415 }4416 function objectIteratorWithKey() {4417 if (started < size) {4418 key = keys[started++];4419 value = collection[key];4420 iterator(value, key, createCallback(value, key));4421 }4422 }4423 function createCallback(value, key) {4424 return function(err, res) {4425 if (key === null) {4426 throwError();4427 }4428 if (err) {4429 key = null;4430 iterate = noop;4431 callback = once(callback);4432 callback(err, objectClone(result));4433 return;4434 }4435 if (!!res === bool) {4436 result[key] = value;4437 }4438 key = null;4439 if (++completed === size) {4440 iterate = throwError;4441 callback = onlyOnce(callback);4442 callback(null, result);4443 } else if (sync) {4444 nextTick(iterate);4445 } else {4446 sync = true;4447 iterate();4448 }4449 sync = false;4450 };4451 }4452 };4453 }4454 /**4455 * @memberof async4456 * @namespace reduce4457 * @param {Array|Object} collection4458 * @param {*} result4459 * @param {Function} iterator4460 * @param {Function} callback4461 * @example4462 *4463 * // array4464 * var order = [];4465 * var collection = [1, 3, 2, 4];4466 * var iterator = function(result, num, done) {4467 * setTimeout(function() {4468 * order.push(num);4469 * done(null, result + num);4470 * }, num * 10);4471 * };4472 * async.reduce(collection, 0, iterator, function(err, res) {4473 * console.log(res); // 104474 * console.log(order); // [1, 3, 2, 4]4475 * });4476 *4477 * @example4478 *4479 * // array with index4480 * var order = [];4481 * var collection = [1, 3, 2, 4];4482 * var iterator = function(result, num, index, done) {4483 * setTimeout(function() {4484 * order.push([num, index]);4485 * done(null, result + num);4486 * }, num * 10);4487 * };4488 * async.reduce(collection, '', iterator, function(err, res) {4489 * console.log(res); // '1324'4490 * console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]4491 * });4492 *4493 * @example4494 *4495 * // object4496 * var order = [];4497 * var object = { a: 1, b: 3, c: 2, d: 4 };4498 * var iterator = function(result, num, done) {4499 * setTimeout(function() {4500 * order.push(num);4501 * done(null, result + num);4502 * }, num * 10);4503 * };4504 * async.reduce(collection, '', iterator, function(err, res) {4505 * console.log(res); // '1324'4506 * console.log(order); // [1, 3, 2, 4]4507 * });4508 *4509 * @example4510 *4511 * // object with key4512 * var order = [];4513 * var object = { a: 1, b: 3, c: 2, d: 4 };4514 * var iterator = function(result, num, key, done) {4515 * setTimeout(function() {4516 * order.push([num, key]);4517 * done(null, result + num);4518 * }, num * 10);4519 * };4520 * async.reduce(collection, 0, iterator, function(err, res) {4521 * console.log(res); // 104522 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]4523 * });4524 *4525 */4526 function reduce(collection, result, iterator, callback) {4527 callback = onlyOnce(callback || noop);4528 var size, key, keys, iter, item, iterate;4529 var sync = false;4530 var completed = 0;4531 if (isArray(collection)) {4532 size = collection.length;4533 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;4534 } else if (!collection) {4535 } else if (iteratorSymbol && collection[iteratorSymbol]) {4536 size = Infinity;4537 iter = collection[iteratorSymbol]();4538 iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;4539 } else if (typeof collection === obj) {4540 keys = nativeKeys(collection);4541 size = keys.length;4542 iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;4543 }4544 if (!size) {4545 return callback(null, result);4546 }4547 iterate(result);4548 function arrayIterator(result) {4549 iterator(result, collection[completed], done);4550 }4551 function arrayIteratorWithIndex(result) {4552 iterator(result, collection[completed], completed, done);4553 }4554 function symbolIterator(result) {4555 item = iter.next();4556 item.done ? callback(null, result) : iterator(result, item.value, done);4557 }4558 function symbolIteratorWithKey(result) {4559 item = iter.next();4560 item.done ? callback(null, result) : iterator(result, item.value, completed, done);4561 }4562 function objectIterator(result) {4563 iterator(result, collection[keys[completed]], done);4564 }4565 function objectIteratorWithKey(result) {4566 key = keys[completed];4567 iterator(result, collection[key], key, done);4568 }4569 function done(err, result) {4570 if (err) {4571 callback(err, result);4572 } else if (++completed === size) {4573 iterator = throwError;4574 callback(null, result);4575 } else if (sync) {4576 nextTick(function() {4577 iterate(result);4578 });4579 } else {4580 sync = true;4581 iterate(result);4582 }4583 sync = false;4584 }4585 }4586 /**4587 * @memberof async4588 * @namespace reduceRight4589 * @param {Array|Object} collection4590 * @param {*} result4591 * @param {Function} iterator4592 * @param {Function} callback4593 * @example4594 *4595 * // array4596 * var order = [];4597 * var collection = [1, 3, 2, 4];4598 * var iterator = function(result, num, done) {4599 * setTimeout(function() {4600 * order.push(num);4601 * done(null, result + num);4602 * }, num * 10);4603 * };4604 * async.reduceRight(collection, 0, iterator, function(err, res) {4605 * console.log(res); // 104606 * console.log(order); // [4, 2, 3, 1]4607 * });4608 *4609 * @example4610 *4611 * // array with index4612 * var order = [];4613 * var collection = [1, 3, 2, 4];4614 * var iterator = function(result, num, index, done) {4615 * setTimeout(function() {4616 * order.push([num, index]);4617 * done(null, result + num);4618 * }, num * 10);4619 * };4620 * async.reduceRight(collection, '', iterator, function(err, res) {4621 * console.log(res); // '4231'4622 * console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]4623 * });4624 *4625 * @example4626 *4627 * // object4628 * var order = [];4629 * var object = { a: 1, b: 3, c: 2, d: 4 };4630 * var iterator = function(result, num, done) {4631 * setTimeout(function() {4632 * order.push(num);4633 * done(null, result + num);4634 * }, num * 10);4635 * };4636 * async.reduceRight(collection, '', iterator, function(err, res) {4637 * console.log(res); // '4231'4638 * console.log(order); // [4, 2, 3, 1]4639 * });4640 *4641 * @example4642 *4643 * // object with key4644 * var order = [];4645 * var object = { a: 1, b: 3, c: 2, d: 4 };4646 * var iterator = function(result, num, key, done) {4647 * setTimeout(function() {4648 * order.push([num, key]);4649 * done(null, result + num);4650 * }, num * 10);4651 * };4652 * async.reduceRight(collection, 0, iterator, function(err, res) {4653 * console.log(res); // 104654 * console.log(order); // [[4, 3], [2, 2], [3, 1], [1, 0]]4655 * });4656 *4657 */4658 function reduceRight(collection, result, iterator, callback) {4659 callback = onlyOnce(callback || noop);4660 var resIndex, index, key, keys, iter, item, col, iterate;4661 var sync = false;4662 if (isArray(collection)) {4663 resIndex = collection.length;4664 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;4665 } else if (!collection) {4666 } else if (iteratorSymbol && collection[iteratorSymbol]) {4667 col = [];4668 iter = collection[iteratorSymbol]();4669 index = -1;4670 while ((item = iter.next()).done === false) {4671 col[++index] = item.value;4672 }4673 collection = col;4674 resIndex = col.length;4675 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;4676 } else if (typeof collection === obj) {4677 keys = nativeKeys(collection);4678 resIndex = keys.length;4679 iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;4680 }4681 if (!resIndex) {4682 return callback(null, result);4683 }4684 iterate(result);4685 function arrayIterator(result) {4686 iterator(result, collection[--resIndex], done);4687 }4688 function arrayIteratorWithIndex(result) {4689 iterator(result, collection[--resIndex], resIndex, done);4690 }4691 function objectIterator(result) {4692 iterator(result, collection[keys[--resIndex]], done);4693 }4694 function objectIteratorWithKey(result) {4695 key = keys[--resIndex];4696 iterator(result, collection[key], key, done);4697 }4698 function done(err, result) {4699 if (err) {4700 callback(err, result);4701 } else if (resIndex === 0) {4702 iterate = throwError;4703 callback(null, result);4704 } else if (sync) {4705 nextTick(function() {4706 iterate(result);4707 });4708 } else {4709 sync = true;4710 iterate(result);4711 }4712 sync = false;4713 }4714 }4715 /**4716 * @private4717 * @param {Function} arrayEach4718 * @param {Function} baseEach4719 * @param {Function} symbolEach4720 */4721 function createTransform(arrayEach, baseEach, symbolEach) {4722 return function transform(collection, accumulator, iterator, callback) {4723 if (arguments.length === 3) {4724 callback = iterator;4725 iterator = accumulator;4726 accumulator = undefined;4727 }4728 callback = callback || noop;4729 var size, keys, result;4730 var completed = 0;4731 if (isArray(collection)) {4732 size = collection.length;4733 result = accumulator !== undefined ? accumulator : [];4734 arrayEach(collection, result, iterator, done);4735 } else if (!collection) {4736 } else if (iteratorSymbol && collection[iteratorSymbol]) {4737 result = accumulator !== undefined ? accumulator : {};4738 size = symbolEach(collection, result, iterator, done);4739 size && size === completed && callback(null, result);4740 } else if (typeof collection === obj) {4741 keys = nativeKeys(collection);4742 size = keys.length;4743 result = accumulator !== undefined ? accumulator : {};4744 baseEach(collection, result, iterator, done, keys);4745 }4746 if (!size) {4747 callback(null, accumulator !== undefined ? accumulator : result || {});4748 }4749 function done(err, bool) {4750 if (err) {4751 callback = once(callback);4752 callback(err, isArray(result) ? createArray(result) : objectClone(result));4753 } else if (++completed === size) {4754 callback(null, result);4755 } else if (bool === false) {4756 callback = once(callback);4757 callback(null, isArray(result) ? createArray(result) : objectClone(result));4758 }4759 }4760 };4761 }4762 /**4763 * @memberof async4764 * @namespace transformSeries4765 * @param {Array|Object} collection4766 * @param {Array|Object|Function} [accumulator]4767 * @param {Function} [iterator]4768 * @param {Function} [callback]4769 * @example4770 *4771 * // array4772 * var order = [];4773 * var collection = [1, 3, 2, 4];4774 * var iterator = function(result, num, done) {4775 * setTimeout(function() {4776 * order.push(num);4777 * result.push(num)4778 * done();4779 * }, num * 10);4780 * };4781 * async.transformSeries(collection, iterator, function(err, res) {4782 * console.log(res); // [1, 3, 2, 4]4783 * console.log(order); // [1, 3, 2, 4]4784 * });4785 *4786 * @example4787 *4788 * // array with index and accumulator4789 * var order = [];4790 * var collection = [1, 3, 2, 4];4791 * var iterator = function(result, num, index, done) {4792 * setTimeout(function() {4793 * order.push([num, index]);4794 * result[index] = num;4795 * done();4796 * }, num * 10);4797 * };4798 * async.transformSeries(collection, {}, iterator, function(err, res) {4799 * console.log(res); // { '0': 1, '1': 3, '2': 2, '3': 4 }4800 * console.log(order); // [[1, 0], [3, 1], [2, 2], [4, 3]]4801 * });4802 *4803 * @example4804 *4805 * // object with accumulator4806 * var order = [];4807 * var object = { a: 1, b: 3, c: 2, d: 4 };4808 * var iterator = function(result, num, done) {4809 * setTimeout(function() {4810 * order.push(num);4811 * result.push(num);4812 * done();4813 * }, num * 10);4814 * };4815 * async.transformSeries(collection, [], iterator, function(err, res) {4816 * console.log(res); // [1, 3, 2, 4]4817 * console.log(order); // [1, 3, 2, 4]4818 * });4819 *4820 * @example4821 *4822 * // object with key4823 * var order = [];4824 * var object = { a: 1, b: 3, c: 2, d: 4 };4825 * var iterator = function(result, num, key, done) {4826 * setTimeout(function() {4827 * order.push([num, key]);4828 * result[key] = num;4829 * done();4830 * }, num * 10);4831 * };4832 * async.transformSeries(collection, iterator, function(err, res) {4833 * console.log(res); // { a: 1, b: 3, c: 2, d: 4 }4834 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'b'], [4, 'd']]4835 * });4836 *4837 */4838 function transformSeries(collection, accumulator, iterator, callback) {4839 if (arguments.length === 3) {4840 callback = iterator;4841 iterator = accumulator;4842 accumulator = undefined;4843 }4844 callback = onlyOnce(callback || noop);4845 var size, key, keys, iter, item, iterate, result;4846 var sync = false;4847 var completed = 0;4848 if (isArray(collection)) {4849 size = collection.length;4850 result = accumulator !== undefined ? accumulator : [];4851 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;4852 } else if (!collection) {4853 } else if (iteratorSymbol && collection[iteratorSymbol]) {4854 size = Infinity;4855 iter = collection[iteratorSymbol]();4856 result = accumulator !== undefined ? accumulator : {};4857 iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;4858 } else if (typeof collection === obj) {4859 keys = nativeKeys(collection);4860 size = keys.length;4861 result = accumulator !== undefined ? accumulator : {};4862 iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;4863 }4864 if (!size) {4865 return callback(null, accumulator !== undefined ? accumulator : result || {});4866 }4867 iterate();4868 function arrayIterator() {4869 iterator(result, collection[completed], done);4870 }4871 function arrayIteratorWithIndex() {4872 iterator(result, collection[completed], completed, done);4873 }4874 function symbolIterator() {4875 item = iter.next();4876 item.done ? callback(null, result) : iterator(result, item.value, done);4877 }4878 function symbolIteratorWithKey() {4879 item = iter.next();4880 item.done ? callback(null, result) : iterator(result, item.value, completed, done);4881 }4882 function objectIterator() {4883 iterator(result, collection[keys[completed]], done);4884 }4885 function objectIteratorWithKey() {4886 key = keys[completed];4887 iterator(result, collection[key], key, done);4888 }4889 function done(err, bool) {4890 if (err) {4891 callback(err, result);4892 } else if (++completed === size || bool === false) {4893 iterate = throwError;4894 callback(null, result);4895 } else if (sync) {4896 nextTick(iterate);4897 } else {4898 sync = true;4899 iterate();4900 }4901 sync = false;4902 }4903 }4904 /**4905 * @memberof async4906 * @namespace transformLimit4907 * @param {Array|Object} collection4908 * @param {number} limit - limit >= 14909 * @param {Array|Object|Function} [accumulator]4910 * @param {Function} [iterator]4911 * @param {Function} [callback]4912 * @example4913 *4914 * // array4915 * var order = [];4916 * var array = [1, 5, 3, 4, 2];4917 * var iterator = function(result, num, done) {4918 * setTimeout(function() {4919 * order.push(num);4920 * result.push(num);4921 * done();4922 * }, num * 10);4923 * };4924 * async.transformLimit(array, 2, iterator, function(err, res) {4925 * console.log(res); // [1, 3, 5, 2, 4]4926 * console.log(order); // [1, 3, 5, 2, 4]4927 * });4928 *4929 * @example4930 *4931 * // array with index and accumulator4932 * var order = [];4933 * var array = [1, 5, 3, 4, 2];4934 * var iterator = function(result, num, index, done) {4935 * setTimeout(function() {4936 * order.push([num, index]);4937 * result[index] = key;4938 * done();4939 * }, num * 10);4940 * };4941 * async.transformLimit(array, 2, {}, iterator, function(err, res) {4942 * console.log(res); // { '0': 1, '1': 5, '2': 3, '3': 4, '4': 2 }4943 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]4944 * });4945 *4946 * @example4947 *4948 * // object with accumulator4949 * var order = [];4950 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };4951 * var iterator = function(result, num, done) {4952 * setTimeout(function() {4953 * order.push(num);4954 * result.push(num);4955 * done();4956 * }, num * 10);4957 * };4958 * async.transformLimit(object, 2, [], iterator, function(err, res) {4959 * console.log(res); // [1, 3, 5, 2, 4]4960 * console.log(order); // [1, 3, 5, 2, 4]4961 * });4962 *4963 * @example4964 *4965 * // object with key4966 * var order = [];4967 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };4968 * var iterator = function(result, num, key, done) {4969 * setTimeout(function() {4970 * order.push([num, key]);4971 * result[key] = num;4972 * done();4973 * }, num * 10);4974 * };4975 * async.transformLimit(object, 2, iterator, function(err, res) {4976 * console.log(res); // { a: 1, b: 5, c: 3, d: 4, e: 2 };4977 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]4978 * });4979 *4980 */4981 function transformLimit(collection, limit, accumulator, iterator, callback) {4982 if (arguments.length === 4) {4983 callback = iterator;4984 iterator = accumulator;4985 accumulator = undefined;4986 }4987 callback = callback || noop;4988 var size, index, key, keys, iter, item, iterate, result;4989 var sync = false;4990 var started = 0;4991 var completed = 0;4992 if (isArray(collection)) {4993 size = collection.length;4994 result = accumulator !== undefined ? accumulator : [];4995 iterate = iterator.length === 4 ? arrayIteratorWithIndex : arrayIterator;4996 } else if (!collection) {4997 } else if (iteratorSymbol && collection[iteratorSymbol]) {4998 size = Infinity;4999 iter = collection[iteratorSymbol]();5000 result = accumulator !== undefined ? accumulator : {};5001 iterate = iterator.length === 4 ? symbolIteratorWithKey : symbolIterator;5002 } else if (typeof collection === obj) {5003 keys = nativeKeys(collection);5004 size = keys.length;5005 result = accumulator !== undefined ? accumulator : {};5006 iterate = iterator.length === 4 ? objectIteratorWithKey : objectIterator;5007 }5008 if (!size || isNaN(limit) || limit < 1) {5009 return callback(null, accumulator !== undefined ? accumulator : result || {});5010 }5011 timesSync(limit > size ? size : limit, iterate);5012 function arrayIterator() {5013 index = started++;5014 if (index < size) {5015 iterator(result, collection[index], onlyOnce(done));5016 }5017 }5018 function arrayIteratorWithIndex() {5019 index = started++;5020 if (index < size) {5021 iterator(result, collection[index], index, onlyOnce(done));5022 }5023 }5024 function symbolIterator() {5025 item = iter.next();5026 if (item.done === false) {5027 started++;5028 iterator(result, item.value, onlyOnce(done));5029 } else if (completed === started && iterator !== noop) {5030 iterator = noop;5031 callback(null, result);5032 }5033 }5034 function symbolIteratorWithKey() {5035 item = iter.next();5036 if (item.done === false) {5037 iterator(result, item.value, started++, onlyOnce(done));5038 } else if (completed === started && iterator !== noop) {5039 iterator = noop;5040 callback(null, result);5041 }5042 }5043 function objectIterator() {5044 index = started++;5045 if (index < size) {5046 iterator(result, collection[keys[index]], onlyOnce(done));5047 }5048 }5049 function objectIteratorWithKey() {5050 index = started++;5051 if (index < size) {5052 key = keys[index];5053 iterator(result, collection[key], key, onlyOnce(done));5054 }5055 }5056 function done(err, bool) {5057 if (err || bool === false) {5058 iterate = noop;5059 callback(err || null, isArray(result) ? createArray(result) : objectClone(result));5060 callback = noop;5061 } else if (++completed === size) {5062 iterator = noop;5063 callback(null, result);5064 } else if (sync) {5065 nextTick(iterate);5066 } else {5067 sync = true;5068 iterate();5069 }5070 sync = false;5071 }5072 }5073 /**5074 * @private5075 * @param {function} arrayEach5076 * @param {function} baseEach5077 * @param {function} symbolEach5078 */5079 function createSortBy(arrayEach, baseEach, symbolEach) {5080 return function sortBy(collection, iterator, callback) {5081 callback = callback || noop;5082 var size, array, criteria;5083 var completed = 0;5084 if (isArray(collection)) {5085 size = collection.length;5086 array = Array(size);5087 criteria = Array(size);5088 arrayEach(collection, iterator, createCallback);5089 } else if (!collection) {5090 } else if (iteratorSymbol && collection[iteratorSymbol]) {5091 array = [];5092 criteria = [];5093 size = symbolEach(collection, iterator, createCallback);5094 size && size === completed && callback(null, sortByCriteria(array, criteria));5095 } else if (typeof collection === obj) {5096 var keys = nativeKeys(collection);5097 size = keys.length;5098 array = Array(size);5099 criteria = Array(size);5100 baseEach(collection, iterator, createCallback, keys);5101 }5102 if (!size) {5103 callback(null, []);5104 }5105 function createCallback(index, value) {5106 var called = false;5107 array[index] = value;5108 return function done(err, criterion) {5109 if (called) {5110 throwError();5111 }5112 called = true;5113 criteria[index] = criterion;5114 if (err) {5115 callback = once(callback);5116 callback(err);5117 } else if (++completed === size) {5118 callback(null, sortByCriteria(array, criteria));5119 }5120 };5121 }5122 };5123 }5124 /**5125 * @memberof async5126 * @namespace sortBySeries5127 * @param {Array|Object} collection5128 * @param {Function} iterator5129 * @param {Function} callback5130 * @example5131 *5132 * // array5133 * var order = [];5134 * var array = [1, 3, 2];5135 * var iterator = function(num, done) {5136 * setTimeout(function() {5137 * order.push(num);5138 * done(null, num);5139 * }, num * 10);5140 * };5141 * async.sortBySeries(array, iterator, function(err, res) {5142 * console.log(res); // [1, 2, 3];5143 * console.log(order); // [1, 3, 2]5144 * });5145 *5146 * @example5147 *5148 * // array with index5149 * var order = [];5150 * var array = [1, 3, 2];5151 * var iterator = function(num, index, done) {5152 * setTimeout(function() {5153 * order.push([num, index]);5154 * done(null, num);5155 * }, num * 10);5156 * };5157 * async.sortBySeries(array, iterator, function(err, res) {5158 * console.log(res); // [1, 2, 3]5159 * console.log(order); // [[1, 0], [3, 1], [2, 2]]5160 * });5161 *5162 * @example5163 *5164 * // object5165 * var order = [];5166 * var object = { a: 1, b: 3, c: 2 };5167 * var iterator = function(num, done) {5168 * setTimeout(function() {5169 * order.push(num);5170 * done(null, num);5171 * }, num * 10);5172 * };5173 * async.sortBySeries(object, iterator, function(err, res) {5174 * console.log(res); // [1, 2, 3]5175 * console.log(order); // [1, 3, 2]5176 * });5177 *5178 * @example5179 *5180 * // object with key5181 * var order = [];5182 * var object = { a: 1, b: 3, c: 2 };5183 * var iterator = function(num, key, done) {5184 * setTimeout(function() {5185 * order.push([num, key]);5186 * done(null, num);5187 * }, num * 10);5188 * };5189 * async.sortBySeries(object, iterator, function(err, res) {5190 * console.log(res); // [1, 2, 3]5191 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]5192 * });5193 *5194 */5195 function sortBySeries(collection, iterator, callback) {5196 callback = onlyOnce(callback || noop);5197 var size, key, value, keys, iter, item, array, criteria, iterate;5198 var sync = false;5199 var completed = 0;5200 if (isArray(collection)) {5201 size = collection.length;5202 array = collection;5203 criteria = Array(size);5204 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;5205 } else if (!collection) {5206 } else if (iteratorSymbol && collection[iteratorSymbol]) {5207 size = Infinity;5208 array = [];5209 criteria = [];5210 iter = collection[iteratorSymbol]();5211 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;5212 } else if (typeof collection === obj) {5213 keys = nativeKeys(collection);5214 size = keys.length;5215 array = Array(size);5216 criteria = Array(size);5217 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;5218 }5219 if (!size) {5220 return callback(null, []);5221 }5222 iterate();5223 function arrayIterator() {5224 value = collection[completed];5225 iterator(value, done);5226 }5227 function arrayIteratorWithIndex() {5228 value = collection[completed];5229 iterator(value, completed, done);5230 }5231 function symbolIterator() {5232 item = iter.next();5233 if (item.done) {5234 return callback(null, sortByCriteria(array, criteria));5235 }5236 value = item.value;5237 array[completed] = value;5238 iterator(value, done);5239 }5240 function symbolIteratorWithKey() {5241 item = iter.next();5242 if (item.done) {5243 return callback(null, sortByCriteria(array, criteria));5244 }5245 value = item.value;5246 array[completed] = value;5247 iterator(value, completed, done);5248 }5249 function objectIterator() {5250 value = collection[keys[completed]];5251 array[completed] = value;5252 iterator(value, done);5253 }5254 function objectIteratorWithKey() {5255 key = keys[completed];5256 value = collection[key];5257 array[completed] = value;5258 iterator(value, key, done);5259 }5260 function done(err, criterion) {5261 criteria[completed] = criterion;5262 if (err) {5263 callback(err);5264 } else if (++completed === size) {5265 iterate = throwError;5266 callback(null, sortByCriteria(array, criteria));5267 } else if (sync) {5268 nextTick(iterate);5269 } else {5270 sync = true;5271 iterate();5272 }5273 sync = false;5274 }5275 }5276 /**5277 * @memberof async5278 * @namespace sortByLimit5279 * @param {Array|Object} collection5280 * @param {number} limit - limit >= 15281 * @param {Function} iterator5282 * @param {Function} callback5283 * @example5284 *5285 * // array5286 * var order = [];5287 * var array = [1, 5, 3, 4, 2];5288 * var iterator = function(num, done) {5289 * setTimeout(function() {5290 * order.push(num);5291 * done(null, num);5292 * }, num * 10);5293 * };5294 * async.sortByLimit(array, 2, iterator, function(err, res) {5295 * console.log(res); // [1, 2, 3, 4, 5]5296 * console.log(order); // [1, 3, 5, 2, 4]5297 * });5298 *5299 * @example5300 *5301 * // array with index5302 * var order = [];5303 * var array = [1, 5, 3, 4, 2];5304 * var iterator = function(num, index, done) {5305 * setTimeout(function() {5306 * order.push([num, index]);5307 * done(null, num);5308 * }, num * 10);5309 * };5310 * async.sortByLimit(array, 2, iterator, function(err, res) {5311 * console.log(res); // [1, 2, 3, 4, 5]5312 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]5313 * });5314 *5315 * @example5316 *5317 * // object5318 * var order = [];5319 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };5320 * var iterator = function(num, done) {5321 * setTimeout(function() {5322 * order.push(num);5323 * done(null, num);5324 * }, num * 10);5325 * };5326 * async.sortByLimit(object, 2, iterator, function(err, res) {5327 * console.log(res); // [1, 2, 3, 4, 5]5328 * console.log(order); // [1, 3, 5, 2, 4]5329 * });5330 *5331 * @example5332 *5333 * // object with key5334 * var order = [];5335 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };5336 * var iterator = function(num, key, done) {5337 * setTimeout(function() {5338 * order.push([num, key]);5339 * done(null, num);5340 * }, num * 10);5341 * };5342 * async.sortByLimit(object, 2, iterator, function(err, res) {5343 * console.log(res); // [1, 2, 3, 4, 5]5344 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]5345 * });5346 *5347 */5348 function sortByLimit(collection, limit, iterator, callback) {5349 callback = callback || noop;5350 var size, index, key, value, array, keys, iter, item, criteria, iterate;5351 var sync = false;5352 var started = 0;5353 var completed = 0;5354 if (isArray(collection)) {5355 size = collection.length;5356 array = collection;5357 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;5358 } else if (!collection) {5359 } else if (iteratorSymbol && collection[iteratorSymbol]) {5360 size = Infinity;5361 iter = collection[iteratorSymbol]();5362 array = [];5363 criteria = [];5364 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;5365 } else if (typeof collection === obj) {5366 keys = nativeKeys(collection);5367 size = keys.length;5368 array = Array(size);5369 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;5370 }5371 if (!size || isNaN(limit) || limit < 1) {5372 return callback(null, []);5373 }5374 criteria = criteria || Array(size);5375 timesSync(limit > size ? size : limit, iterate);5376 function arrayIterator() {5377 if (started < size) {5378 value = collection[started];5379 iterator(value, createCallback(value, started++));5380 }5381 }5382 function arrayIteratorWithIndex() {5383 index = started++;5384 if (index < size) {5385 value = collection[index];5386 iterator(value, index, createCallback(value, index));5387 }5388 }5389 function symbolIterator() {5390 item = iter.next();5391 if (item.done === false) {5392 value = item.value;5393 array[started] = value;5394 iterator(value, createCallback(value, started++));5395 } else if (completed === started && iterator !== noop) {5396 iterator = noop;5397 callback(null, sortByCriteria(array, criteria));5398 }5399 }5400 function symbolIteratorWithKey() {5401 item = iter.next();5402 if (item.done === false) {5403 value = item.value;5404 array[started] = value;5405 iterator(value, started, createCallback(value, started++));5406 } else if (completed === started && iterator !== noop) {5407 iterator = noop;5408 callback(null, sortByCriteria(array, criteria));5409 }5410 }5411 function objectIterator() {5412 if (started < size) {5413 value = collection[keys[started]];5414 array[started] = value;5415 iterator(value, createCallback(value, started++));5416 }5417 }5418 function objectIteratorWithKey() {5419 if (started < size) {5420 key = keys[started];5421 value = collection[key];5422 array[started] = value;5423 iterator(value, key, createCallback(value, started++));5424 }5425 }5426 function createCallback(value, index) {5427 var called = false;5428 return function(err, criterion) {5429 if (called) {5430 throwError();5431 }5432 called = true;5433 criteria[index] = criterion;5434 if (err) {5435 iterate = noop;5436 callback(err);5437 callback = noop;5438 } else if (++completed === size) {5439 callback(null, sortByCriteria(array, criteria));5440 } else if (sync) {5441 nextTick(iterate);5442 } else {5443 sync = true;5444 iterate();5445 }5446 sync = false;5447 };5448 }5449 }5450 /**5451 * @memberof async5452 * @namespace some5453 * @param {Array|Object} collection5454 * @param {Function} iterator5455 * @param {Function} callback5456 * @example5457 *5458 * // array5459 * var order = [];5460 * var array = [1, 3, 2];5461 * var iterator = function(num, done) {5462 * setTimeout(function() {5463 * order.push(num);5464 * done(null, num % 2);5465 * }, num * 10);5466 * };5467 * async.some(array, iterator, function(err, res) {5468 * console.log(res); // true5469 * console.log(order); // [1]5470 * });5471 *5472 * @example5473 *5474 * // array with index5475 * var order = [];5476 * var array = [1, 3, 2];5477 * var iterator = function(num, index, done) {5478 * setTimeout(function() {5479 * order.push([num, index]);5480 * done(null, num % 2);5481 * }, num * 10);5482 * };5483 * async.some(array, iterator, function(err, res) {5484 * console.log(res); // true5485 * console.log(order); // [[1, 0]]5486 * });5487 *5488 * @example5489 *5490 * // object5491 * var order = [];5492 * var object = { a: 1, b: 3, c: 2 };5493 * var iterator = function(num, done) {5494 * setTimeout(function() {5495 * order.push(num);5496 * done(null, num % 2);5497 * }, num * 10);5498 * };5499 * async.some(object, iterator, function(err, res) {5500 * console.log(res); // true5501 * console.log(order); // [1]5502 * });5503 *5504 * @example5505 *5506 * // object with key5507 * var order = [];5508 * var object = { a: 1, b: 3, c: 2 };5509 * var iterator = function(num, key, done) {5510 * setTimeout(function() {5511 * order.push([num, key]);5512 * done(null, num % 2);5513 * }, num * 10);5514 * };5515 * async.some(object, iterator, function(err, res) {5516 * console.log(res); // true5517 * console.log(order); // [[1, 'a']]5518 * });5519 *5520 */5521 function some(collection, iterator, callback) {5522 callback = callback || noop;5523 detect(collection, iterator, done);5524 function done(err, res) {5525 if (err) {5526 return callback(err);5527 }5528 callback(null, !!res);5529 }5530 }5531 /**5532 * @memberof async5533 * @namespace someSeries5534 * @param {Array|Object} collection5535 * @param {Function} iterator5536 * @param {Function} callback5537 * @example5538 *5539 * // array5540 * var order = [];5541 * var array = [1, 3, 2];5542 * var iterator = function(num, done) {5543 * setTimeout(function() {5544 * order.push(num);5545 * done(null, num % 2);5546 * }, num * 10);5547 * };5548 * async.someSeries(array, iterator, function(err, res) {5549 * console.log(res); // true5550 * console.log(order); // [1]5551 * });5552 *5553 * @example5554 *5555 * // array with index5556 * var order = [];5557 * var array = [1, 3, 2];5558 * var iterator = function(num, index, done) {5559 * setTimeout(function() {5560 * order.push([num, index]);5561 * done(null, num % 2);5562 * }, num * 10);5563 * };5564 * async.someSeries(array, iterator, function(err, res) {5565 * console.log(res); // true5566 * console.log(order); // [[1, 0]]5567 * });5568 *5569 * @example5570 *5571 * // object5572 * var order = [];5573 * var object = { a: 1, b: 3, c: 2 };5574 * var iterator = function(num, done) {5575 * setTimeout(function() {5576 * order.push(num);5577 * done(null, num % 2);5578 * }, num * 10);5579 * };5580 * async.someSeries(object, iterator, function(err, res) {5581 * console.log(res); // true5582 * console.log(order); // [1]5583 * });5584 *5585 * @example5586 *5587 * // object with key5588 * var order = [];5589 * var object = { a: 1, b: 3, c: 2 };5590 * var iterator = function(num, key, done) {5591 * setTimeout(function() {5592 * order.push([num, key]);5593 * done(null, num % 2);5594 * }, num * 10);5595 * };5596 * async.someSeries(object, iterator, function(err, res) {5597 * console.log(res); // true5598 * console.log(order); // [[1, 'a']]5599 * });5600 *5601 */5602 function someSeries(collection, iterator, callback) {5603 callback = callback || noop;5604 detectSeries(collection, iterator, done);5605 function done(err, res) {5606 if (err) {5607 return callback(err);5608 }5609 callback(null, !!res);5610 }5611 }5612 /**5613 * @memberof async5614 * @namespace someLimit5615 * @param {Array|Object} collection5616 * @param {number} limit - limit >= 15617 * @param {Function} iterator5618 * @param {Function} callback5619 * @example5620 *5621 * // array5622 * var order = [];5623 * var array = [1, 5, 3, 4, 2];5624 * var iterator = function(num, done) {5625 * setTimeout(function() {5626 * order.push(num);5627 * done(null, num % 2);5628 * }, num * 10);5629 * };5630 * async.someLimit(array, 2, iterator, function(err, res) {5631 * console.log(res); // true5632 * console.log(order); // [1]5633 * });5634 *5635 * @example5636 *5637 * // array with index5638 * var order = [];5639 * var array = [1, 5, 3, 4, 2];5640 * var iterator = function(num, index, done) {5641 * setTimeout(function() {5642 * order.push([num, index]);5643 * done(null, num % 2);5644 * }, num * 10);5645 * };5646 * async.someLimit(array, 2, iterator, function(err, res) {5647 * console.log(res); // true5648 * console.log(order); // [[1, 0]]5649 * });5650 *5651 * @example5652 *5653 * // object5654 * var order = [];5655 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };5656 * var iterator = function(num, done) {5657 * setTimeout(function() {5658 * order.push(num);5659 * done(null, num % 2);5660 * }, num * 10);5661 * };5662 * async.someLimit(object, 2, iterator, function(err, res) {5663 * console.log(res); // true5664 * console.log(order); // [1]5665 * });5666 *5667 * @example5668 *5669 * // object with key5670 * var order = [];5671 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };5672 * var iterator = function(num, key, done) {5673 * setTimeout(function() {5674 * order.push([num, key]);5675 * done(null, num % 2);5676 * }, num * 10);5677 * };5678 * async.someLimit(object, 2, iterator, function(err, res) {5679 * console.log(res); // true5680 * console.log(order); // [[1, 'a']]5681 * });5682 *5683 */5684 function someLimit(collection, limit, iterator, callback) {5685 callback = callback || noop;5686 detectLimit(collection, limit, iterator, done);5687 function done(err, res) {5688 if (err) {5689 return callback(err);5690 }5691 callback(null, !!res);5692 }5693 }5694 /**5695 * @private5696 * @param {Function} arrayEach5697 * @param {Function} baseEach5698 * @param {Function} symbolEach5699 */5700 function createEvery(arrayEach, baseEach, symbolEach) {5701 var deny = createDetect(arrayEach, baseEach, symbolEach, false);5702 return function every(collection, iterator, callback) {5703 callback = callback || noop;5704 deny(collection, iterator, done);5705 function done(err, res) {5706 if (err) {5707 return callback(err);5708 }5709 callback(null, !res);5710 }5711 };5712 }5713 /**5714 * @private5715 */5716 function createEverySeries() {5717 var denySeries = createDetectSeries(false);5718 return function everySeries(collection, iterator, callback) {5719 callback = callback || noop;5720 denySeries(collection, iterator, done);5721 function done(err, res) {5722 if (err) {5723 return callback(err);5724 }5725 callback(null, !res);5726 }5727 };5728 }5729 /**5730 * @private5731 */5732 function createEveryLimit() {5733 var denyLimit = createDetectLimit(false);5734 return function everyLimit(collection, limit, iterator, callback) {5735 callback = callback || noop;5736 denyLimit(collection, limit, iterator, done);5737 function done(err, res) {5738 if (err) {5739 return callback(err);5740 }5741 callback(null, !res);5742 }5743 };5744 }5745 /**5746 * @private5747 * @param {Function} arrayEach5748 * @param {Function} baseEach5749 * @param {Function} symbolEach5750 */5751 function createConcat(arrayEach, baseEach, symbolEach) {5752 return function concat(collection, iterator, callback) {5753 callback = callback || noop;5754 var size, result;5755 var completed = 0;5756 if (isArray(collection)) {5757 size = collection.length;5758 result = Array(size);5759 arrayEach(collection, iterator, createCallback);5760 } else if (!collection) {5761 } else if (iteratorSymbol && collection[iteratorSymbol]) {5762 result = [];5763 size = symbolEach(collection, iterator, createCallback);5764 size && size === completed && callback(null, result);5765 } else if (typeof collection === obj) {5766 var keys = nativeKeys(collection);5767 size = keys.length;5768 result = Array(size);5769 baseEach(collection, iterator, createCallback, keys);5770 }5771 if (!size) {5772 callback(null, []);5773 }5774 function createCallback(index) {5775 return function done(err, res) {5776 if (index === null) {5777 throwError();5778 }5779 if (err) {5780 index = null;5781 callback = once(callback);5782 arrayEachSync(result, function(array, index) {5783 if (array === undefined) {5784 result[index] = noop;5785 }5786 });5787 callback(err, makeConcatResult(result));5788 return;5789 }5790 switch (arguments.length) {5791 case 0:5792 case 1:5793 result[index] = noop;5794 break;5795 case 2:5796 result[index] = res;5797 break;5798 default:5799 result[index] = slice(arguments, 1);5800 break;5801 }5802 index = null;5803 if (++completed === size) {5804 callback(null, makeConcatResult(result));5805 }5806 };5807 }5808 };5809 }5810 /**5811 * @memberof async5812 * @namespace concatSeries5813 * @param {Array|Object} collection5814 * @param {Function} iterator5815 * @param {Function} callback5816 * @example5817 *5818 * // array5819 * var order = [];5820 * var array = [1, 3, 2];5821 * var iterator = function(num, done) {5822 * setTimeout(function() {5823 * order.push(num);5824 * done(null, [num]);5825 * }, num * 10);5826 * };5827 * async.concatSeries(array, iterator, function(err, res) {5828 * console.log(res); // [1, 3, 2];5829 * console.log(order); // [1, 3, 2]5830 * });5831 *5832 * @example5833 *5834 * // array with index5835 * var order = [];5836 * var array = [1, 3, 2];5837 * var iterator = function(num, index, done) {5838 * setTimeout(function() {5839 * order.push([num, index]);5840 * done(null, [num]);5841 * }, num * 10);5842 * };5843 * async.concatSeries(array, iterator, function(err, res) {5844 * console.log(res); // [1, 3, 2]5845 * console.log(order); // [[1, 0], [3, 1], [2, 2]]5846 * });5847 *5848 * @example5849 *5850 * // object5851 * var order = [];5852 * var object = { a: 1, b: 3, c: 2 };5853 * var iterator = function(num, done) {5854 * setTimeout(function() {5855 * order.push(num);5856 * done(null, [num]);5857 * }, num * 10);5858 * };5859 * async.concatSeries(object, iterator, function(err, res) {5860 * console.log(res); // [1, 3, 2]5861 * console.log(order); // [1, 3, 2]5862 * });5863 *5864 * @example5865 *5866 * // object with key5867 * var order = [];5868 * var object = { a: 1, b: 3, c: 2 };5869 * var iterator = function(num, key, done) {5870 * setTimeout(function() {5871 * order.push([num, key]);5872 * done(null, [num]);5873 * }, num * 10);5874 * };5875 * async.concatSeries(object, iterator, function(err, res) {5876 * console.log(res); // [1, 3, 2]5877 * console.log(order); // [[1, 'a'], [3, 'b'], [2, 'c']]5878 * });5879 *5880 */5881 function concatSeries(collection, iterator, callback) {5882 callback = onlyOnce(callback || noop);5883 var size, key, keys, iter, item, iterate;5884 var sync = false;5885 var result = [];5886 var completed = 0;5887 if (isArray(collection)) {5888 size = collection.length;5889 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;5890 } else if (!collection) {5891 } else if (iteratorSymbol && collection[iteratorSymbol]) {5892 size = Infinity;5893 iter = collection[iteratorSymbol]();5894 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;5895 } else if (typeof collection === obj) {5896 keys = nativeKeys(collection);5897 size = keys.length;5898 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;5899 }5900 if (!size) {5901 return callback(null, result);5902 }5903 iterate();5904 function arrayIterator() {5905 iterator(collection[completed], done);5906 }5907 function arrayIteratorWithIndex() {5908 iterator(collection[completed], completed, done);5909 }5910 function symbolIterator() {5911 item = iter.next();5912 item.done ? callback(null, result) : iterator(item.value, done);5913 }5914 function symbolIteratorWithKey() {5915 item = iter.next();5916 item.done ? callback(null, result) : iterator(item.value, completed, done);5917 }5918 function objectIterator() {5919 iterator(collection[keys[completed]], done);5920 }5921 function objectIteratorWithKey() {5922 key = keys[completed];5923 iterator(collection[key], key, done);5924 }5925 function done(err, array) {5926 if (isArray(array)) {5927 nativePush.apply(result, array);5928 } else if (arguments.length >= 2) {5929 nativePush.apply(result, slice(arguments, 1));5930 }5931 if (err) {5932 callback(err, result);5933 } else if (++completed === size) {5934 iterate = throwError;5935 callback(null, result);5936 } else if (sync) {5937 nextTick(iterate);5938 } else {5939 sync = true;5940 iterate();5941 }5942 sync = false;5943 }5944 }5945 /**5946 * @memberof async5947 * @namespace concatLimit5948 * @param {Array|Object} collection5949 * @param {number} limit - limit >= 15950 * @param {Function} iterator5951 * @param {Function} callback5952 * @example5953 *5954 * // array5955 * var order = [];5956 * var array = [1, 5, 3, 4, 2];5957 * var iterator = function(num, done) {5958 * setTimeout(function() {5959 * order.push(num);5960 * done(null, [num]);5961 * }, num * 10);5962 * };5963 * async.concatLimit(array, 2, iterator, function(err, res) {5964 * console.log(res); // [1, 3, 5, 2, 4]5965 * console.log(order); // [1, 3, 5, 2, 4]5966 * });5967 *5968 * @example5969 *5970 * // array with index5971 * var order = [];5972 * var array = [1, 5, 3, 4, 2];5973 * var iterator = function(num, index, done) {5974 * setTimeout(function() {5975 * order.push([num, index]);5976 * done(null, [num]);5977 * }, num * 10);5978 * };5979 * async.cocnatLimit(array, 2, iterator, function(err, res) {5980 * console.log(res); // [1, 3, 5, 2, 4]5981 * console.log(order); // [[1, 0], [3, 2], [5, 1], [2, 4], [4, 3]]5982 * });5983 *5984 * @example5985 *5986 * // object5987 * var order = [];5988 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };5989 * var iterator = function(num, done) {5990 * setTimeout(function() {5991 * order.push(num);5992 * done(null, [num]);5993 * }, num * 10);5994 * };5995 * async.concatLimit(object, 2, iterator, function(err, res) {5996 * console.log(res); // [1, 3, 5, 2, 4]5997 * console.log(order); // [1, 3, 5, 2, 4]5998 * });5999 *6000 * @example6001 *6002 * // object with key6003 * var order = [];6004 * var object = { a: 1, b: 5, c: 3, d: 4, e: 2 };6005 * var iterator = function(num, key, done) {6006 * setTimeout(function() {6007 * order.push([num, key]);6008 * done(null, num);6009 * }, num * 10);6010 * };6011 * async.cocnatLimit(object, 2, iterator, function(err, res) {6012 * console.log(res); // [1, 3, 5, 2, 4]6013 * console.log(order); // [[1, 'a'], [3, 'c'], [5, 'b'], [2, 'e'], [4, 'd']]6014 * });6015 *6016 */6017 function concatLimit(collection, limit, iterator, callback) {6018 callback = callback || noop;6019 var size, key, iter, item, iterate, result;6020 var sync = false;6021 var started = 0;6022 var completed = 0;6023 if (isArray(collection)) {6024 size = collection.length;6025 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;6026 } else if (!collection) {6027 } else if (iteratorSymbol && collection[iteratorSymbol]) {6028 size = Infinity;6029 result = [];6030 iter = collection[iteratorSymbol]();6031 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;6032 } else if (typeof collection === obj) {6033 var keys = nativeKeys(collection);6034 size = keys.length;6035 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;6036 }6037 if (!size || isNaN(limit) || limit < 1) {6038 return callback(null, []);6039 }6040 result = result || Array(size);6041 timesSync(limit > size ? size : limit, iterate);6042 function arrayIterator() {6043 if (started < size) {6044 iterator(collection[started], createCallback(started++));6045 }6046 }6047 function arrayIteratorWithIndex() {6048 if (started < size) {6049 iterator(collection[started], started, createCallback(started++));6050 }6051 }6052 function symbolIterator() {6053 item = iter.next();6054 if (item.done === false) {6055 iterator(item.value, createCallback(started++));6056 } else if (completed === started && iterator !== noop) {6057 iterator = noop;6058 callback(null, makeConcatResult(result));6059 }6060 }6061 function symbolIteratorWithKey() {6062 item = iter.next();6063 if (item.done === false) {6064 iterator(item.value, started, createCallback(started++));6065 } else if (completed === started && iterator !== noop) {6066 iterator = noop;6067 callback(null, makeConcatResult(result));6068 }6069 }6070 function objectIterator() {6071 if (started < size) {6072 iterator(collection[keys[started]], createCallback(started++));6073 }6074 }6075 function objectIteratorWithKey() {6076 if (started < size) {6077 key = keys[started];6078 iterator(collection[key], key, createCallback(started++));6079 }6080 }6081 function createCallback(index) {6082 return function(err, res) {6083 if (index === null) {6084 throwError();6085 }6086 if (err) {6087 index = null;6088 iterate = noop;6089 callback = once(callback);6090 arrayEachSync(result, function(array, index) {6091 if (array === undefined) {6092 result[index] = noop;6093 }6094 });6095 callback(err, makeConcatResult(result));6096 return;6097 }6098 switch (arguments.length) {6099 case 0:6100 case 1:6101 result[index] = noop;6102 break;6103 case 2:6104 result[index] = res;6105 break;6106 default:6107 result[index] = slice(arguments, 1);6108 break;6109 }6110 index = null;6111 if (++completed === size) {6112 iterate = throwError;6113 callback(null, makeConcatResult(result));6114 callback = throwError;6115 } else if (sync) {6116 nextTick(iterate);6117 } else {6118 sync = true;6119 iterate();6120 }6121 sync = false;6122 };6123 }6124 }6125 /**6126 * @private6127 * @param {Function} arrayEach6128 * @param {Function} baseEach6129 * @param {Function} symbolEach6130 */6131 function createGroupBy(arrayEach, baseEach, symbolEach) {6132 return function groupBy(collection, iterator, callback) {6133 callback = callback || noop;6134 var size;6135 var completed = 0;6136 var result = {};6137 if (isArray(collection)) {6138 size = collection.length;6139 arrayEach(collection, iterator, createCallback);6140 } else if (!collection) {6141 } else if (iteratorSymbol && collection[iteratorSymbol]) {6142 size = symbolEach(collection, iterator, createCallback);6143 size && size === completed && callback(null, result);6144 } else if (typeof collection === obj) {6145 var keys = nativeKeys(collection);6146 size = keys.length;6147 baseEach(collection, iterator, createCallback, keys);6148 }6149 if (!size) {6150 callback(null, {});6151 }6152 function createCallback(value) {6153 var called = false;6154 return function done(err, key) {6155 if (called) {6156 throwError();6157 }6158 called = true;6159 if (err) {6160 callback = once(callback);6161 callback(err, objectClone(result));6162 return;6163 }6164 var array = result[key];6165 if (!array) {6166 result[key] = [value];6167 } else {6168 array.push(value);6169 }6170 if (++completed === size) {6171 callback(null, result);6172 }6173 };6174 }6175 };6176 }6177 /**6178 * @memberof async6179 * @namespace groupBySeries6180 * @param {Array|Object} collection6181 * @param {Function} iterator6182 * @param {Function} callback6183 * @example6184 *6185 * // array6186 * var order = [];6187 * var array = [4.2, 6.4, 6.1];6188 * var iterator = function(num, done) {6189 * setTimeout(function() {6190 * order.push(num);6191 * done(null, Math.floor(num));6192 * }, num * 10);6193 * };6194 * async.groupBySeries(array, iterator, function(err, res) {6195 * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }6196 * console.log(order); // [4.2, 6.4, 6.1]6197 * });6198 *6199 * @example6200 *6201 * // array with index6202 * var order = [];6203 * var array = [4.2, 6.4, 6.1];6204 * var iterator = function(num, index, done) {6205 * setTimeout(function() {6206 * order.push([num, index]);6207 * done(null, Math.floor(num));6208 * }, num * 10);6209 * };6210 * async.groupBySeries(array, iterator, function(err, res) {6211 * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }6212 * console.log(order); // [[4.2, 0], [6.4, 1], [6.1, 2]]6213 * });6214 *6215 * @example6216 *6217 * // object6218 * var order = [];6219 * var object = { a: 4.2, b: 6.4, c: 6.1 };6220 * var iterator = function(num, done) {6221 * setTimeout(function() {6222 * order.push(num);6223 * done(null, Math.floor(num));6224 * }, num * 10);6225 * };6226 * async.groupBySeries(object, iterator, function(err, res) {6227 * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }6228 * console.log(order); // [4.2, 6.4, 6.1]6229 * });6230 *6231 * @example6232 *6233 * // object with key6234 * var order = [];6235 * var object = { a: 4.2, b: 6.4, c: 6.1 };6236 * var iterator = function(num, key, done) {6237 * setTimeout(function() {6238 * order.push([num, key]);6239 * done(null, Math.floor(num));6240 * }, num * 10);6241 * };6242 * async.groupBySeries(object, iterator, function(err, res) {6243 * console.log(res); // { '4': [4.2], '6': [6.4, 6.1] }6244 * console.log(order); // [[4.2, 'a'], [6.4, 'b'], [6.1, 'c']]6245 * });6246 *6247 */6248 function groupBySeries(collection, iterator, callback) {6249 callback = onlyOnce(callback || noop);6250 var size, key, value, keys, iter, item, iterate;6251 var sync = false;6252 var completed = 0;6253 var result = {};6254 if (isArray(collection)) {6255 size = collection.length;6256 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;6257 } else if (!collection) {6258 } else if (iteratorSymbol && collection[iteratorSymbol]) {6259 size = Infinity;6260 iter = collection[iteratorSymbol]();6261 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;6262 } else if (typeof collection === obj) {6263 keys = nativeKeys(collection);6264 size = keys.length;6265 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;6266 }6267 if (!size) {6268 return callback(null, result);6269 }6270 iterate();6271 function arrayIterator() {6272 value = collection[completed];6273 iterator(value, done);6274 }6275 function arrayIteratorWithIndex() {6276 value = collection[completed];6277 iterator(value, completed, done);6278 }6279 function symbolIterator() {6280 item = iter.next();6281 value = item.value;6282 item.done ? callback(null, result) : iterator(value, done);6283 }6284 function symbolIteratorWithKey() {6285 item = iter.next();6286 value = item.value;6287 item.done ? callback(null, result) : iterator(value, completed, done);6288 }6289 function objectIterator() {6290 value = collection[keys[completed]];6291 iterator(value, done);6292 }6293 function objectIteratorWithKey() {6294 key = keys[completed];6295 value = collection[key];6296 iterator(value, key, done);6297 }6298 function done(err, key) {6299 if (err) {6300 iterate = throwError;6301 callback = onlyOnce(callback);6302 callback(err, objectClone(result));6303 return;6304 }6305 var array = result[key];6306 if (!array) {6307 result[key] = [value];6308 } else {6309 array.push(value);6310 }6311 if (++completed === size) {6312 iterate = throwError;6313 callback(null, result);6314 } else if (sync) {6315 nextTick(iterate);6316 } else {6317 sync = true;6318 iterate();6319 }6320 sync = false;6321 }6322 }6323 /**6324 * @memberof async6325 * @namespace groupByLimit6326 * @param {Array|Object} collection6327 * @param {Function} iterator6328 * @param {Function} callback6329 * @example6330 *6331 * // array6332 * var order = [];6333 * var array = [1.1, 5.9, 3.2, 3.9, 2.1];6334 * var iterator = function(num, done) {6335 * setTimeout(function() {6336 * order.push(num);6337 * done(null, Math.floor(num));6338 * }, num * 10);6339 * };6340 * async.groupByLimit(array, 2, iterator, function(err, res) {6341 * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }6342 * console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]6343 * });6344 *6345 * @example6346 *6347 * // array with index6348 * var order = [];6349 * var array = [1.1, 5.9, 3.2, 3.9, 2.1];6350 * var iterator = function(num, index, done) {6351 * setTimeout(function() {6352 * order.push([num, index]);6353 * done(null, Math.floor(num));6354 * }, num * 10);6355 * };6356 * async.groupByLimit(array, 2, iterator, function(err, res) {6357 * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }6358 * console.log(order); // [[1.1, 0], [3.2, 2], [5.9, 1], [2.1, 4], [3.9, 3]]6359 * });6360 *6361 * @example6362 *6363 * // object6364 * var order = [];6365 * var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }6366 * var iterator = function(num, done) {6367 * setTimeout(function() {6368 * order.push(num);6369 * done(null, Math.floor(num));6370 * }, num * 10);6371 * };6372 * async.groupByLimit(object, 2, iterator, function(err, res) {6373 * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }6374 * console.log(order); // [1.1, 3.2, 5.9, 2.1, 3.9]6375 * });6376 *6377 * @example6378 *6379 * // object with key6380 * var order = [];6381 * var object = { a: 1.1, b: 5.9, c: 3.2, d: 3.9, e: 2.1 }6382 * var iterator = function(num, key, done) {6383 * setTimeout(function() {6384 * order.push([num, key]);6385 * done(null, Math.floor(num));6386 * }, num * 10);6387 * };6388 * async.groupByLimit(object, 2, iterator, function(err, res) {6389 * console.log(res); // { '1': [1.1], '3': [3.2, 3.9], '5': [5.9], '2': [2.1] }6390 * console.log(order); // [[1.1, 'a'], [3.2, 'c'], [5.9, 'b'], [2.1, 'e'], [3.9, 'd']]6391 * });6392 *6393 */6394 function groupByLimit(collection, limit, iterator, callback) {6395 callback = callback || noop;6396 var size, index, key, value, keys, iter, item, iterate;6397 var sync = false;6398 var started = 0;6399 var completed = 0;6400 var result = {};6401 if (isArray(collection)) {6402 size = collection.length;6403 iterate = iterator.length === 3 ? arrayIteratorWithIndex : arrayIterator;6404 } else if (!collection) {6405 } else if (iteratorSymbol && collection[iteratorSymbol]) {6406 size = Infinity;6407 iter = collection[iteratorSymbol]();6408 iterate = iterator.length === 3 ? symbolIteratorWithKey : symbolIterator;6409 } else if (typeof collection === obj) {6410 keys = nativeKeys(collection);6411 size = keys.length;6412 iterate = iterator.length === 3 ? objectIteratorWithKey : objectIterator;6413 }6414 if (!size || isNaN(limit) || limit < 1) {6415 return callback(null, result);6416 }6417 timesSync(limit > size ? size : limit, iterate);6418 function arrayIterator() {6419 if (started < size) {6420 value = collection[started++];6421 iterator(value, createCallback(value));6422 }6423 }6424 function arrayIteratorWithIndex() {6425 index = started++;6426 if (index < size) {6427 value = collection[index];6428 iterator(value, index, createCallback(value));6429 }6430 }6431 function symbolIterator() {6432 item = iter.next();6433 if (item.done === false) {6434 started++;6435 value = item.value;6436 iterator(value, createCallback(value));6437 } else if (completed === started && iterator !== noop) {6438 iterator = noop;6439 callback(null, result);6440 }6441 }6442 function symbolIteratorWithKey() {6443 item = iter.next();6444 if (item.done === false) {6445 value = item.value;6446 iterator(value, started++, createCallback(value));6447 } else if (completed === started && iterator !== noop) {6448 iterator = noop;6449 callback(null, result);6450 }6451 }6452 function objectIterator() {6453 if (started < size) {6454 value = collection[keys[started++]];6455 iterator(value, createCallback(value));6456 }6457 }6458 function objectIteratorWithKey() {6459 if (started < size) {6460 key = keys[started++];6461 value = collection[key];6462 iterator(value, key, createCallback(value));6463 }6464 }6465 function createCallback(value) {6466 var called = false;6467 return function(err, key) {6468 if (called) {6469 throwError();6470 }6471 called = true;6472 if (err) {6473 iterate = noop;6474 callback = once(callback);6475 callback(err, objectClone(result));6476 return;6477 }6478 var array = result[key];6479 if (!array) {6480 result[key] = [value];6481 } else {6482 array.push(value);6483 }6484 if (++completed === size) {6485 callback(null, result);6486 } else if (sync) {6487 nextTick(iterate);6488 } else {6489 sync = true;6490 iterate();6491 }6492 sync = false;6493 };6494 }6495 }6496 /**6497 * @private6498 * @param {Function} arrayEach6499 * @param {Function} baseEach6500 */6501 function createParallel(arrayEach, baseEach) {6502 return function parallel(tasks, callback) {6503 callback = callback || noop;6504 var size, keys, result;6505 var completed = 0;6506 if (isArray(tasks)) {6507 size = tasks.length;6508 result = Array(size);6509 arrayEach(tasks, createCallback);6510 } else if (tasks && typeof tasks === obj) {6511 keys = nativeKeys(tasks);6512 size = keys.length;6513 result = {};6514 baseEach(tasks, createCallback, keys);6515 }6516 if (!size) {6517 callback(null, result);6518 }6519 function createCallback(key) {6520 return function(err, res) {6521 if (key === null) {6522 throwError();6523 }6524 if (err) {6525 key = null;6526 callback = once(callback);6527 callback(err, result);6528 return;6529 }6530 result[key] = arguments.length <= 2 ? res : slice(arguments, 1);6531 key = null;6532 if (++completed === size) {6533 callback(null, result);6534 }6535 };6536 }6537 };6538 }6539 /**6540 * @memberof async6541 * @namespace series6542 * @param {Array|Object} tasks - functions6543 * @param {Function} callback6544 * @example6545 *6546 * var order = [];6547 * var tasks = [6548 * function(done) {6549 * setTimeout(function() {6550 * order.push(1);6551 * done(null, 1);6552 * }, 10);6553 * },6554 * function(done) {6555 * setTimeout(function() {6556 * order.push(2);6557 * done(null, 2);6558 * }, 30);6559 * },6560 * function(done) {6561 * setTimeout(function() {6562 * order.push(3);6563 * done(null, 3);6564 * }, 40);6565 * },6566 * function(done) {6567 * setTimeout(function() {6568 * order.push(4);6569 * done(null, 4);6570 * }, 20);6571 * }6572 * ];6573 * async.series(tasks, function(err, res) {6574 * console.log(res); // [1, 2, 3, 4];6575 * console.log(order); // [1, 2, 3, 4]6576 * });6577 *6578 * @example6579 *6580 * var order = [];6581 * var tasks = {6582 * 'a': function(done) {6583 * setTimeout(function() {6584 * order.push(1);6585 * done(null, 1);6586 * }, 10);6587 * },6588 * 'b': function(done) {6589 * setTimeout(function() {6590 * order.push(2);6591 * done(null, 2);6592 * }, 30);6593 * },6594 * 'c': function(done) {6595 * setTimeout(function() {6596 * order.push(3);6597 * done(null, 3);6598 * }, 40);6599 * },6600 * 'd': function(done) {6601 * setTimeout(function() {6602 * order.push(4);6603 * done(null, 4);6604 * }, 20);6605 * }6606 * };6607 * async.series(tasks, function(err, res) {6608 * console.log(res); // { a: 1, b: 2, c: 3, d:4 }6609 * console.log(order); // [1, 4, 2, 3]6610 * });6611 *6612 */6613 function series(tasks, callback) {6614 callback = callback || noop;6615 var size, key, keys, result, iterate;6616 var sync = false;6617 var completed = 0;6618 if (isArray(tasks)) {6619 size = tasks.length;6620 result = Array(size);6621 iterate = arrayIterator;6622 } else if (tasks && typeof tasks === obj) {6623 keys = nativeKeys(tasks);6624 size = keys.length;6625 result = {};6626 iterate = objectIterator;6627 } else {6628 return callback(null);6629 }6630 if (!size) {6631 return callback(null, result);6632 }6633 iterate();6634 function arrayIterator() {6635 key = completed;6636 tasks[completed](done);6637 }6638 function objectIterator() {6639 key = keys[completed];6640 tasks[key](done);6641 }6642 function done(err, res) {6643 if (err) {6644 iterate = throwError;6645 callback = onlyOnce(callback);6646 callback(err, result);6647 return;6648 }6649 result[key] = arguments.length <= 2 ? res : slice(arguments, 1);6650 if (++completed === size) {6651 iterate = throwError;6652 callback(null, result);6653 } else if (sync) {6654 nextTick(iterate);6655 } else {6656 sync = true;6657 iterate();6658 }6659 sync = false;6660 }6661 }6662 /**6663 * @memberof async6664 * @namespace parallelLimit6665 * @param {Array|Object} tasks - functions6666 * @param {number} limit - limit >= 16667 * @param {Function} callback6668 * @example6669 *6670 * var order = [];6671 * var tasks = [6672 * function(done) {6673 * setTimeout(function() {6674 * order.push(1);6675 * done(null, 1);6676 * }, 10);6677 * },6678 * function(done) {6679 * setTimeout(function() {6680 * order.push(2);6681 * done(null, 2);6682 * }, 50);6683 * },6684 * function(done) {6685 * setTimeout(function() {6686 * order.push(3);6687 * done(null, 3);6688 * }, 30);6689 * },6690 * function(done) {6691 * setTimeout(function() {6692 * order.push(4);6693 * done(null, 4);6694 * }, 40);6695 * }6696 * ];6697 * async.parallelLimit(tasks, 2, function(err, res) {6698 * console.log(res); // [1, 2, 3, 4];6699 * console.log(order); // [1, 3, 2, 4]6700 * });6701 *6702 * @example6703 *6704 * var order = [];6705 * var tasks = {6706 * 'a': function(done) {6707 * setTimeout(function() {6708 * order.push(1);6709 * done(null, 1);6710 * }, 10);6711 * },6712 * 'b': function(done) {6713 * setTimeout(function() {6714 * order.push(2);6715 * done(null, 2);6716 * }, 50);6717 * },6718 * 'c': function(done) {6719 * setTimeout(function() {6720 * order.push(3);6721 * done(null, 3);6722 * }, 20);6723 * },6724 * 'd': function(done) {6725 * setTimeout(function() {6726 * order.push(4);6727 * done(null, 4);6728 * }, 40);6729 * }6730 * };6731 * async.parallelLimit(tasks, 2, function(err, res) {6732 * console.log(res); // { a: 1, b: 2, c: 3, d:4 }6733 * console.log(order); // [1, 3, 2, 4]6734 * });6735 *6736 */6737 function parallelLimit(tasks, limit, callback) {6738 callback = callback || noop;6739 var size, index, key, keys, result, iterate;6740 var sync = false;6741 var started = 0;6742 var completed = 0;6743 if (isArray(tasks)) {6744 size = tasks.length;6745 result = Array(size);6746 iterate = arrayIterator;6747 } else if (tasks && typeof tasks === obj) {6748 keys = nativeKeys(tasks);6749 size = keys.length;6750 result = {};6751 iterate = objectIterator;6752 }6753 if (!size || isNaN(limit) || limit < 1) {6754 return callback(null, result);6755 }6756 timesSync(limit > size ? size : limit, iterate);6757 function arrayIterator() {6758 index = started++;6759 if (index < size) {6760 tasks[index](createCallback(index));6761 }6762 }6763 function objectIterator() {6764 if (started < size) {6765 key = keys[started++];6766 tasks[key](createCallback(key));6767 }6768 }6769 function createCallback(key) {6770 return function(err, res) {6771 if (key === null) {6772 throwError();6773 }6774 if (err) {6775 key = null;6776 iterate = noop;6777 callback = once(callback);6778 callback(err, result);6779 return;6780 }6781 result[key] = arguments.length <= 2 ? res : slice(arguments, 1);6782 key = null;6783 if (++completed === size) {6784 callback(null, result);6785 } else if (sync) {6786 nextTick(iterate);6787 } else {6788 sync = true;6789 iterate();6790 }6791 sync = false;6792 };6793 }6794 }6795 /**6796 * @memberof async6797 * @namespace tryEach6798 * @param {Array|Object} tasks - functions6799 * @param {Function} callback6800 * @example6801 *6802 * var tasks = [6803 * function(done) {6804 * setTimeout(function() {6805 * done(new Error('error'));6806 * }, 10);6807 * },6808 * function(done) {6809 * setTimeout(function() {6810 * done(null, 2);6811 * }, 10);6812 * }6813 * ];6814 * async.tryEach(tasks, function(err, res) {6815 * console.log(res); // 26816 * });6817 *6818 * @example6819 *6820 * var tasks = [6821 * function(done) {6822 * setTimeout(function() {6823 * done(new Error('error1'));6824 * }, 10);6825 * },6826 * function(done) {6827 * setTimeout(function() {6828 * done(new Error('error2');6829 * }, 10);6830 * }6831 * ];6832 * async.tryEach(tasks, function(err, res) {6833 * console.log(err); // error26834 * console.log(res); // undefined6835 * });6836 *6837 */6838 function tryEach(tasks, callback) {6839 callback = callback || noop;6840 var size, keys, iterate;6841 var sync = false;6842 var completed = 0;6843 if (isArray(tasks)) {6844 size = tasks.length;6845 iterate = arrayIterator;6846 } else if (tasks && typeof tasks === obj) {6847 keys = nativeKeys(tasks);6848 size = keys.length;6849 iterate = objectIterator;6850 }6851 if (!size) {6852 return callback(null);6853 }6854 iterate();6855 function arrayIterator() {6856 tasks[completed](done);6857 }6858 function objectIterator() {6859 tasks[keys[completed]](done);6860 }6861 function done(err, res) {6862 if (!err) {6863 if (arguments.length <= 2) {6864 callback(null, res);6865 } else {6866 callback(null, slice(arguments, 1));6867 }6868 } else if (++completed === size) {6869 callback(err);6870 } else {6871 sync = true;6872 iterate();6873 }6874 sync = false;6875 }6876 }6877 /**6878 * check for waterfall tasks6879 * @private6880 * @param {Array} tasks6881 * @param {Function} callback6882 * @return {boolean}6883 */6884 function checkWaterfallTasks(tasks, callback) {6885 if (!isArray(tasks)) {6886 callback(new Error('First argument to waterfall must be an array of functions'));6887 return false;6888 }6889 if (tasks.length === 0) {6890 callback(null);6891 return false;6892 }6893 return true;6894 }6895 /**6896 * check for waterfall tasks6897 * @private6898 * @param {function} func6899 * @param {Array|Object} args - arguments6900 * @return {function} next6901 */6902 function waterfallIterator(func, args, next) {6903 switch (args.length) {6904 case 0:6905 case 1:6906 return func(next);6907 case 2:6908 return func(args[1], next);6909 case 3:6910 return func(args[1], args[2], next);6911 case 4:6912 return func(args[1], args[2], args[3], next);6913 case 5:6914 return func(args[1], args[2], args[3], args[4], next);6915 case 6:6916 return func(args[1], args[2], args[3], args[4], args[5], next);6917 default:6918 args = slice(args, 1);6919 args.push(next);6920 return func.apply(null, args);6921 }6922 }6923 /**6924 * @memberof async6925 * @namespace waterfall6926 * @param {Array} tasks - functions6927 * @param {Function} callback6928 * @example6929 *6930 * var order = [];6931 * var tasks = [6932 * function(next) {6933 * setTimeout(function() {6934 * order.push(1);6935 * next(null, 1);6936 * }, 10);6937 * },6938 * function(arg1, next) {6939 * setTimeout(function() {6940 * order.push(2);6941 * next(null, 1, 2);6942 * }, 30);6943 * },6944 * function(arg1, arg2, next) {6945 * setTimeout(function() {6946 * order.push(3);6947 * next(null, 3);6948 * }, 20);6949 * },6950 * function(arg1, next) {6951 * setTimeout(function() {6952 * order.push(4);6953 * next(null, 1, 2, 3, 4);6954 * }, 40);6955 * }6956 * ];6957 * async.waterfall(tasks, function(err, arg1, arg2, arg3, arg4) {6958 * console.log(arg1, arg2, arg3, arg4); // 1 2 3 46959 * });6960 *6961 */6962 function waterfall(tasks, callback) {6963 callback = callback || noop;6964 if (!checkWaterfallTasks(tasks, callback)) {6965 return;6966 }6967 var func, args, done, sync;6968 var completed = 0;6969 var size = tasks.length;6970 waterfallIterator(tasks[0], [], createCallback(0));6971 function iterate() {6972 waterfallIterator(func, args, createCallback(func));6973 }6974 function createCallback(index) {6975 return function next(err, res) {6976 if (index === undefined) {6977 callback = noop;6978 throwError();6979 }6980 index = undefined;6981 if (err) {6982 done = callback;6983 callback = throwError;6984 done(err);6985 return;6986 }6987 if (++completed === size) {6988 done = callback;6989 callback = throwError;6990 if (arguments.length <= 2) {6991 done(err, res);6992 } else {6993 done.apply(null, createArray(arguments));6994 }6995 return;6996 }6997 if (sync) {6998 args = arguments;6999 func = tasks[completed] || throwError;7000 nextTick(iterate);7001 } else {7002 sync = true;7003 waterfallIterator(tasks[completed] || throwError, arguments, createCallback(completed));7004 }7005 sync = false;7006 };7007 }7008 }7009 /**7010 * `angelFall` is like `waterfall` and inject callback to last argument of next task.7011 *7012 * @memberof async7013 * @namespace angelFall7014 * @param {Array} tasks - functions7015 * @param {Function} callback7016 * @example7017 *7018 * var order = [];7019 * var tasks = [7020 * function(next) {7021 * setTimeout(function() {7022 * order.push(1);7023 * next(null, 1);7024 * }, 10);7025 * },7026 * function(arg1, empty, next) {7027 * setTimeout(function() {7028 * order.push(2);7029 * next(null, 1, 2);7030 * }, 30);7031 * },7032 * function(next) {7033 * setTimeout(function() {7034 * order.push(3);7035 * next(null, 3);7036 * }, 20);7037 * },7038 * function(arg1, empty1, empty2, empty3, next) {7039 * setTimeout(function() {7040 * order.push(4);7041 * next(null, 1, 2, 3, 4);7042 * }, 40);7043 * }7044 * ];7045 * async.angelFall(tasks, function(err, arg1, arg2, arg3, arg4) {7046 * console.log(arg1, arg2, arg3, arg4); // 1 2 3 47047 * });7048 *7049 */7050 function angelFall(tasks, callback) {7051 callback = callback || noop;7052 if (!checkWaterfallTasks(tasks, callback)) {7053 return;7054 }7055 var completed = 0;7056 var sync = false;7057 var size = tasks.length;7058 var func = tasks[completed];7059 var args = [];7060 var iterate = function() {7061 switch (func.length) {7062 case 0:7063 try {7064 next(null, func());7065 } catch (e) {7066 next(e);7067 }7068 return;7069 case 1:7070 return func(next);7071 case 2:7072 return func(args[1], next);7073 case 3:7074 return func(args[1], args[2], next);7075 case 4:7076 return func(args[1], args[2], args[3], next);7077 case 5:7078 return func(args[1], args[2], args[3], args[4], next);7079 default:7080 args = slice(args, 1);7081 args[func.length - 1] = next;7082 return func.apply(null, args);7083 }7084 };7085 iterate();7086 function next(err, res) {7087 if (err) {7088 iterate = throwError;7089 callback = onlyOnce(callback);7090 callback(err);7091 return;7092 }7093 if (++completed === size) {7094 iterate = throwError;7095 var done = callback;7096 callback = throwError;7097 if (arguments.length === 2) {7098 done(err, res);7099 } else {7100 done.apply(null, createArray(arguments));7101 }7102 return;7103 }7104 func = tasks[completed];7105 args = arguments;7106 if (sync) {7107 nextTick(iterate);7108 } else {7109 sync = true;7110 iterate();7111 }7112 sync = false;7113 }7114 }7115 /**7116 * @memberof async7117 * @namespace whilst7118 * @param {Function} test7119 * @param {Function} iterator7120 * @param {Function} callback7121 */7122 function whilst(test, iterator, callback) {7123 callback = callback || noop;7124 var sync = false;7125 if (test()) {7126 iterate();7127 } else {7128 callback(null);7129 }7130 function iterate() {7131 if (sync) {7132 nextTick(next);7133 } else {7134 sync = true;7135 iterator(done);7136 }7137 sync = false;7138 }7139 function next() {7140 iterator(done);7141 }7142 function done(err, arg) {7143 if (err) {7144 return callback(err);7145 }7146 if (arguments.length <= 2) {7147 if (test(arg)) {7148 iterate();7149 } else {7150 callback(null, arg);7151 }7152 return;7153 }7154 arg = slice(arguments, 1);7155 if (test.apply(null, arg)) {7156 iterate();7157 } else {7158 callback.apply(null, [null].concat(arg));7159 }7160 }7161 }7162 /**7163 * @memberof async7164 * @namespace doWhilst7165 * @param {Function} iterator7166 * @param {Function} test7167 * @param {Function} callback7168 */7169 function doWhilst(iterator, test, callback) {7170 callback = callback || noop;7171 var sync = false;7172 next();7173 function iterate() {7174 if (sync) {7175 nextTick(next);7176 } else {7177 sync = true;7178 iterator(done);7179 }7180 sync = false;7181 }7182 function next() {7183 iterator(done);7184 }7185 function done(err, arg) {7186 if (err) {7187 return callback(err);7188 }7189 if (arguments.length <= 2) {7190 if (test(arg)) {7191 iterate();7192 } else {7193 callback(null, arg);7194 }7195 return;7196 }7197 arg = slice(arguments, 1);7198 if (test.apply(null, arg)) {7199 iterate();7200 } else {7201 callback.apply(null, [null].concat(arg));7202 }7203 }7204 }7205 /**7206 * @memberof async7207 * @namespace until7208 * @param {Function} test7209 * @param {Function} iterator7210 * @param {Function} callback7211 */7212 function until(test, iterator, callback) {7213 callback = callback || noop;7214 var sync = false;7215 if (!test()) {7216 iterate();7217 } else {7218 callback(null);7219 }7220 function iterate() {7221 if (sync) {7222 nextTick(next);7223 } else {7224 sync = true;7225 iterator(done);7226 }7227 sync = false;7228 }7229 function next() {7230 iterator(done);7231 }7232 function done(err, arg) {7233 if (err) {7234 return callback(err);7235 }7236 if (arguments.length <= 2) {7237 if (!test(arg)) {7238 iterate();7239 } else {7240 callback(null, arg);7241 }7242 return;7243 }7244 arg = slice(arguments, 1);7245 if (!test.apply(null, arg)) {7246 iterate();7247 } else {7248 callback.apply(null, [null].concat(arg));7249 }7250 }7251 }7252 /**7253 * @memberof async7254 * @namespace doUntil7255 * @param {Function} iterator7256 * @param {Function} test7257 * @param {Function} callback7258 */7259 function doUntil(iterator, test, callback) {7260 callback = callback || noop;7261 var sync = false;7262 next();7263 function iterate() {7264 if (sync) {7265 nextTick(next);7266 } else {7267 sync = true;7268 iterator(done);7269 }7270 sync = false;7271 }7272 function next() {7273 iterator(done);7274 }7275 function done(err, arg) {7276 if (err) {7277 return callback(err);7278 }7279 if (arguments.length <= 2) {7280 if (!test(arg)) {7281 iterate();7282 } else {7283 callback(null, arg);7284 }7285 return;7286 }7287 arg = slice(arguments, 1);7288 if (!test.apply(null, arg)) {7289 iterate();7290 } else {7291 callback.apply(null, [null].concat(arg));7292 }7293 }7294 }7295 /**7296 * @memberof async7297 * @namespace during7298 * @param {Function} test7299 * @param {Function} iterator7300 * @param {Function} callback7301 */7302 function during(test, iterator, callback) {7303 callback = callback || noop;7304 _test();7305 function _test() {7306 test(iterate);7307 }7308 function iterate(err, truth) {7309 if (err) {7310 return callback(err);7311 }7312 if (truth) {7313 iterator(done);7314 } else {7315 callback(null);7316 }7317 }7318 function done(err) {7319 if (err) {7320 return callback(err);7321 }7322 _test();7323 }7324 }7325 /**7326 * @memberof async7327 * @namespace doDuring7328 * @param {Function} test7329 * @param {Function} iterator7330 * @param {Function} callback7331 */7332 function doDuring(iterator, test, callback) {7333 callback = callback || noop;7334 iterate(null, true);7335 function iterate(err, truth) {7336 if (err) {7337 return callback(err);7338 }7339 if (truth) {7340 iterator(done);7341 } else {7342 callback(null);7343 }7344 }7345 function done(err, res) {7346 if (err) {7347 return callback(err);7348 }7349 switch (arguments.length) {7350 case 0:7351 case 1:7352 test(iterate);7353 break;7354 case 2:7355 test(res, iterate);7356 break;7357 default:7358 var args = slice(arguments, 1);7359 args.push(iterate);7360 test.apply(null, args);7361 break;7362 }7363 }7364 }7365 /**7366 * @memberof async7367 * @namespace forever7368 */7369 function forever(iterator, callback) {7370 var sync = false;7371 iterate();7372 function iterate() {7373 iterator(next);7374 }7375 function next(err) {7376 if (err) {7377 if (callback) {7378 return callback(err);7379 }7380 throw err;7381 }7382 if (sync) {7383 nextTick(iterate);7384 } else {7385 sync = true;7386 iterate();7387 }7388 sync = false;7389 }7390 }7391 /**7392 * @memberof async7393 * @namespace compose7394 */7395 function compose() {7396 return seq.apply(null, reverse(arguments));7397 }7398 /**7399 * @memberof async7400 * @namespace seq7401 */7402 function seq(/* functions... */) {7403 var fns = createArray(arguments);7404 return function() {7405 var self = this;7406 var args = createArray(arguments);7407 var callback = args[args.length - 1];7408 if (typeof callback === func) {7409 args.pop();7410 } else {7411 callback = noop;7412 }7413 reduce(fns, args, iterator, done);7414 function iterator(newargs, fn, callback) {7415 var func = function(err) {7416 var nextargs = slice(arguments, 1);7417 callback(err, nextargs);7418 };7419 newargs.push(func);7420 fn.apply(self, newargs);7421 }7422 function done(err, res) {7423 res = isArray(res) ? res : [res];7424 res.unshift(err);7425 callback.apply(self, res);7426 }7427 };7428 }7429 function createApplyEach(func) {7430 return function applyEach(fns /* arguments */) {7431 var go = function() {7432 var self = this;7433 var args = createArray(arguments);7434 var callback = args.pop() || noop;7435 return func(fns, iterator, callback);7436 function iterator(fn, done) {7437 fn.apply(self, args.concat([done]));7438 }7439 };7440 if (arguments.length > 1) {7441 var args = slice(arguments, 1);7442 return go.apply(this, args);7443 } else {7444 return go;7445 }7446 };7447 }7448 /**7449 * @see https://github.com/caolan/async/blob/master/lib/internal/DoublyLinkedList.js7450 */7451 function DLL() {7452 this.head = null;7453 this.tail = null;7454 this.length = 0;7455 }7456 DLL.prototype._removeLink = function(node) {7457 var prev = node.prev;7458 var next = node.next;7459 if (prev) {7460 prev.next = next;7461 } else {7462 this.head = next;7463 }7464 if (next) {7465 next.prev = prev;7466 } else {7467 this.tail = prev;7468 }7469 node.prev = null;7470 node.next = null;7471 this.length--;7472 return node;7473 };7474 DLL.prototype.empty = DLL;7475 DLL.prototype._setInitial = function(node) {7476 this.length = 1;7477 this.head = this.tail = node;7478 };7479 DLL.prototype.insertBefore = function(node, newNode) {7480 newNode.prev = node.prev;7481 newNode.next = node;7482 if (node.prev) {7483 node.prev.next = newNode;7484 } else {7485 this.head = newNode;7486 }7487 node.prev = newNode;7488 this.length++;7489 };7490 DLL.prototype.unshift = function(node) {7491 if (this.head) {7492 this.insertBefore(this.head, node);7493 } else {7494 this._setInitial(node);7495 }7496 };7497 DLL.prototype.push = function(node) {7498 var tail = this.tail;7499 if (tail) {7500 node.prev = tail;7501 node.next = tail.next;7502 this.tail = node;7503 tail.next = node;7504 this.length++;7505 } else {7506 this._setInitial(node);7507 }7508 };7509 DLL.prototype.shift = function() {7510 return this.head && this._removeLink(this.head);7511 };7512 DLL.prototype.splice = function(end) {7513 var task;7514 var tasks = [];7515 while (end-- && (task = this.shift())) {7516 tasks.push(task);7517 }7518 return tasks;7519 };7520 DLL.prototype.remove = function(test) {7521 var node = this.head;7522 while (node) {7523 if (test(node)) {7524 this._removeLink(node);7525 }7526 node = node.next;7527 }7528 return this;7529 };7530 /**7531 * @private7532 */7533 function baseQueue(isQueue, worker, concurrency, payload) {7534 if (concurrency === undefined) {7535 concurrency = 1;7536 } else if (isNaN(concurrency) || concurrency < 1) {7537 throw new Error('Concurrency must not be zero');7538 }7539 var workers = 0;7540 var workersList = [];7541 var _callback, _unshift;7542 var q = {7543 _tasks: new DLL(),7544 concurrency: concurrency,7545 payload: payload,7546 saturated: noop,7547 unsaturated: noop,7548 buffer: concurrency / 4,7549 empty: noop,7550 drain: noop,7551 error: noop,7552 started: false,7553 paused: false,7554 push: push,7555 kill: kill,7556 unshift: unshift,7557 remove: remove,7558 process: isQueue ? runQueue : runCargo,7559 length: getLength,7560 running: running,7561 workersList: getWorkersList,7562 idle: idle,7563 pause: pause,7564 resume: resume,7565 _worker: worker7566 };7567 return q;7568 function push(tasks, callback) {7569 _insert(tasks, callback);7570 }7571 function unshift(tasks, callback) {7572 _insert(tasks, callback, true);7573 }7574 function _exec(task) {7575 var item = {7576 data: task,7577 callback: _callback7578 };7579 if (_unshift) {7580 q._tasks.unshift(item);7581 } else {7582 q._tasks.push(item);7583 }7584 nextTick(q.process);7585 }7586 function _insert(tasks, callback, unshift) {7587 if (callback == null) {7588 callback = noop;7589 } else if (typeof callback !== 'function') {7590 throw new Error('task callback must be a function');7591 }7592 q.started = true;7593 var _tasks = isArray(tasks) ? tasks : [tasks];7594 if (tasks === undefined || !_tasks.length) {7595 if (q.idle()) {7596 nextTick(q.drain);7597 }7598 return;7599 }7600 _unshift = unshift;7601 _callback = callback;7602 arrayEachSync(_tasks, _exec);7603 // Avoid leaking the callback7604 _callback = undefined;7605 }7606 function kill() {7607 q.drain = noop;7608 q._tasks.empty();7609 }7610 function _next(q, tasks) {7611 var called = false;7612 return function done(err, res) {7613 if (called) {7614 throwError();7615 }7616 called = true;7617 workers--;7618 var task;7619 var index = -1;7620 var size = workersList.length;7621 var taskIndex = -1;7622 var taskSize = tasks.length;7623 var useApply = arguments.length > 2;7624 var args = useApply && createArray(arguments);7625 while (++taskIndex < taskSize) {7626 task = tasks[taskIndex];7627 while (++index < size) {7628 if (workersList[index] === task) {7629 if (index === 0) {7630 workersList.shift();7631 } else {7632 workersList.splice(index, 1);7633 }7634 index = size;7635 size--;7636 }7637 }7638 index = -1;7639 if (useApply) {7640 task.callback.apply(task, args);7641 } else {7642 task.callback(err, res);7643 }7644 if (err) {7645 q.error(err, task.data);7646 }7647 }7648 if (workers <= q.concurrency - q.buffer) {7649 q.unsaturated();7650 }7651 if (q._tasks.length + workers === 0) {7652 q.drain();7653 }7654 q.process();7655 };7656 }7657 function runQueue() {7658 while (!q.paused && workers < q.concurrency && q._tasks.length) {7659 var task = q._tasks.shift();7660 workers++;7661 workersList.push(task);7662 if (q._tasks.length === 0) {7663 q.empty();7664 }7665 if (workers === q.concurrency) {7666 q.saturated();7667 }7668 var done = _next(q, [task]);7669 worker(task.data, done);7670 }7671 }7672 function runCargo() {7673 while (!q.paused && workers < q.concurrency && q._tasks.length) {7674 var tasks = q._tasks.splice(q.payload || q._tasks.length);7675 var index = -1;7676 var size = tasks.length;7677 var data = Array(size);7678 while (++index < size) {7679 data[index] = tasks[index].data;7680 }7681 workers++;7682 nativePush.apply(workersList, tasks);7683 if (q._tasks.length === 0) {7684 q.empty();7685 }7686 if (workers === q.concurrency) {7687 q.saturated();7688 }7689 var done = _next(q, tasks);7690 worker(data, done);7691 }7692 }7693 function getLength() {7694 return q._tasks.length;7695 }7696 function running() {7697 return workers;7698 }7699 function getWorkersList() {7700 return workersList;7701 }7702 function idle() {7703 return q.length() + workers === 0;7704 }7705 function pause() {7706 q.paused = true;7707 }7708 function _resume() {7709 nextTick(q.process);7710 }7711 function resume() {7712 if (q.paused === false) {7713 return;7714 }7715 q.paused = false;7716 var count = q.concurrency < q._tasks.length ? q.concurrency : q._tasks.length;7717 timesSync(count, _resume);7718 }7719 /**7720 * @param {Function} test7721 */7722 function remove(test) {7723 q._tasks.remove(test);7724 }7725 }7726 /**7727 * @memberof async7728 * @namespace queue7729 */7730 function queue(worker, concurrency) {7731 return baseQueue(true, worker, concurrency);7732 }7733 /**7734 * @memberof async7735 * @namespace priorityQueue7736 */7737 function priorityQueue(worker, concurrency) {7738 var q = baseQueue(true, worker, concurrency);7739 q.push = push;7740 delete q.unshift;7741 return q;7742 function push(tasks, priority, callback) {7743 q.started = true;7744 priority = priority || 0;7745 var _tasks = isArray(tasks) ? tasks : [tasks];7746 var taskSize = _tasks.length;7747 if (tasks === undefined || taskSize === 0) {7748 if (q.idle()) {7749 nextTick(q.drain);7750 }7751 return;7752 }7753 callback = typeof callback === func ? callback : noop;7754 var nextNode = q._tasks.head;7755 while (nextNode && priority >= nextNode.priority) {7756 nextNode = nextNode.next;7757 }7758 while (taskSize--) {7759 var item = {7760 data: _tasks[taskSize],7761 priority: priority,7762 callback: callback7763 };7764 if (nextNode) {7765 q._tasks.insertBefore(nextNode, item);7766 } else {7767 q._tasks.push(item);7768 }7769 nextTick(q.process);7770 }7771 }7772 }7773 /**7774 * @memberof async7775 * @namespace cargo7776 */7777 function cargo(worker, payload) {7778 return baseQueue(false, worker, 1, payload);7779 }7780 /**7781 * @memberof async7782 * @namespace auto7783 * @param {Object} tasks7784 * @param {number} [concurrency]7785 * @param {Function} [callback]7786 */7787 function auto(tasks, concurrency, callback) {7788 if (typeof concurrency === func) {7789 callback = concurrency;7790 concurrency = null;7791 }7792 var keys = nativeKeys(tasks);7793 var rest = keys.length;7794 var results = {};7795 if (rest === 0) {7796 return callback(null, results);7797 }7798 var runningTasks = 0;7799 var readyTasks = new DLL();7800 var listeners = Object.create(null);7801 callback = onlyOnce(callback || noop);7802 concurrency = concurrency || rest;7803 baseEachSync(tasks, iterator, keys);7804 proceedQueue();7805 function iterator(task, key) {7806 // no dependencies7807 var _task, _taskSize;7808 if (!isArray(task)) {7809 _task = task;7810 _taskSize = 0;7811 readyTasks.push([_task, _taskSize, done]);7812 return;7813 }7814 var dependencySize = task.length - 1;7815 _task = task[dependencySize];7816 _taskSize = dependencySize;7817 if (dependencySize === 0) {7818 readyTasks.push([_task, _taskSize, done]);7819 return;7820 }7821 // dependencies7822 var index = -1;7823 while (++index < dependencySize) {7824 var dependencyName = task[index];7825 if (notInclude(keys, dependencyName)) {7826 var msg =7827 'async.auto task `' +7828 key +7829 '` has non-existent dependency `' +7830 dependencyName +7831 '` in ' +7832 task.join(', ');7833 throw new Error(msg);7834 }7835 var taskListeners = listeners[dependencyName];7836 if (!taskListeners) {7837 taskListeners = listeners[dependencyName] = [];7838 }7839 taskListeners.push(taskListener);7840 }7841 function done(err, arg) {7842 if (key === null) {7843 throwError();7844 }7845 arg = arguments.length <= 2 ? arg : slice(arguments, 1);7846 if (err) {7847 rest = 0;7848 runningTasks = 0;7849 readyTasks.length = 0;7850 var safeResults = objectClone(results);7851 safeResults[key] = arg;7852 key = null;7853 var _callback = callback;7854 callback = noop;7855 _callback(err, safeResults);7856 return;7857 }7858 runningTasks--;7859 rest--;7860 results[key] = arg;7861 taskComplete(key);7862 key = null;7863 }7864 function taskListener() {7865 if (--dependencySize === 0) {7866 readyTasks.push([_task, _taskSize, done]);7867 }7868 }7869 }7870 function proceedQueue() {7871 if (readyTasks.length === 0 && runningTasks === 0) {7872 if (rest !== 0) {7873 throw new Error('async.auto task has cyclic dependencies');7874 }7875 return callback(null, results);7876 }7877 while (readyTasks.length && runningTasks < concurrency && callback !== noop) {7878 runningTasks++;7879 var array = readyTasks.shift();7880 if (array[1] === 0) {7881 array[0](array[2]);7882 } else {7883 array[0](results, array[2]);7884 }7885 }7886 }7887 function taskComplete(key) {7888 var taskListeners = listeners[key] || [];7889 arrayEachSync(taskListeners, function(task) {7890 task();7891 });7892 proceedQueue();7893 }7894 }7895 var FN_ARGS = /^(function)?\s*[^\(]*\(\s*([^\)]*)\)/m;7896 var FN_ARG_SPLIT = /,/;7897 var FN_ARG = /(=.+)?(\s*)$/;7898 var STRIP_COMMENTS = /((\/\/.*$)|(\/\*[\s\S]*?\*\/))/gm;7899 /**7900 * parse function arguments for `autoInject`7901 *7902 * @private7903 */7904 function parseParams(func) {7905 func = func.toString().replace(STRIP_COMMENTS, '');7906 func = func.match(FN_ARGS)[2].replace(' ', '');7907 func = func ? func.split(FN_ARG_SPLIT) : [];7908 func = func.map(function(arg) {7909 return arg.replace(FN_ARG, '').trim();7910 });7911 return func;7912 }7913 /**7914 * @memberof async7915 * @namespace autoInject7916 * @param {Object} tasks7917 * @param {number} [concurrency]7918 * @param {Function} [callback]7919 */7920 function autoInject(tasks, concurrency, callback) {7921 var newTasks = {};7922 baseEachSync(tasks, iterator, nativeKeys(tasks));7923 auto(newTasks, concurrency, callback);7924 function iterator(task, key) {7925 var params;7926 var taskLength = task.length;7927 if (isArray(task)) {7928 if (taskLength === 0) {7929 throw new Error('autoInject task functions require explicit parameters.');7930 }7931 params = createArray(task);7932 taskLength = params.length - 1;7933 task = params[taskLength];7934 if (taskLength === 0) {7935 newTasks[key] = task;7936 return;7937 }7938 } else if (taskLength === 1) {7939 newTasks[key] = task;7940 return;7941 } else {7942 params = parseParams(task);7943 if (taskLength === 0 && params.length === 0) {7944 throw new Error('autoInject task functions require explicit parameters.');7945 }7946 taskLength = params.length - 1;7947 }7948 params[taskLength] = newTask;7949 newTasks[key] = params;7950 function newTask(results, done) {7951 switch (taskLength) {7952 case 1:7953 task(results[params[0]], done);7954 break;7955 case 2:7956 task(results[params[0]], results[params[1]], done);7957 break;7958 case 3:7959 task(results[params[0]], results[params[1]], results[params[2]], done);7960 break;7961 default:7962 var i = -1;7963 while (++i < taskLength) {7964 params[i] = results[params[i]];7965 }7966 params[i] = done;7967 task.apply(null, params);7968 break;7969 }7970 }7971 }7972 }7973 /**7974 * @memberof async7975 * @namespace retry7976 * @param {integer|Object|Function} opts7977 * @param {Function} [task]7978 * @param {Function} [callback]7979 */7980 function retry(opts, task, callback) {7981 var times, intervalFunc, errorFilter;7982 var count = 0;7983 if (arguments.length < 3 && typeof opts === func) {7984 callback = task || noop;7985 task = opts;7986 opts = null;7987 times = DEFAULT_TIMES;7988 } else {7989 callback = callback || noop;7990 switch (typeof opts) {7991 case 'object':7992 if (typeof opts.errorFilter === func) {7993 errorFilter = opts.errorFilter;7994 }7995 var interval = opts.interval;7996 switch (typeof interval) {7997 case func:7998 intervalFunc = interval;7999 break;8000 case 'string':8001 case 'number':8002 interval = +interval;8003 intervalFunc = interval8004 ? function() {8005 return interval;8006 }8007 : function() {8008 return DEFAULT_INTERVAL;8009 };8010 break;8011 }8012 times = +opts.times || DEFAULT_TIMES;8013 break;8014 case 'number':8015 times = opts || DEFAULT_TIMES;8016 break;8017 case 'string':8018 times = +opts || DEFAULT_TIMES;8019 break;8020 default:8021 throw new Error('Invalid arguments for async.retry');8022 }8023 }8024 if (typeof task !== 'function') {8025 throw new Error('Invalid arguments for async.retry');8026 }8027 if (intervalFunc) {8028 task(intervalCallback);8029 } else {8030 task(simpleCallback);8031 }8032 function simpleIterator() {8033 task(simpleCallback);8034 }8035 function simpleCallback(err, res) {8036 if (++count === times || !err || (errorFilter && !errorFilter(err))) {8037 if (arguments.length <= 2) {8038 return callback(err, res);8039 }8040 var args = createArray(arguments);8041 return callback.apply(null, args);8042 }8043 simpleIterator();8044 }8045 function intervalIterator() {8046 task(intervalCallback);8047 }8048 function intervalCallback(err, res) {8049 if (++count === times || !err || (errorFilter && !errorFilter(err))) {8050 if (arguments.length <= 2) {8051 return callback(err, res);8052 }8053 var args = createArray(arguments);8054 return callback.apply(null, args);8055 }8056 setTimeout(intervalIterator, intervalFunc(count));8057 }8058 }8059 function retryable(opts, task) {8060 if (!task) {8061 task = opts;8062 opts = null;8063 }8064 return done;8065 function done() {8066 var taskFn;8067 var args = createArray(arguments);8068 var lastIndex = args.length - 1;8069 var callback = args[lastIndex];8070 switch (task.length) {8071 case 1:8072 taskFn = task1;8073 break;8074 case 2:8075 taskFn = task2;8076 break;8077 case 3:8078 taskFn = task3;8079 break;8080 default:8081 taskFn = task4;8082 }8083 if (opts) {8084 retry(opts, taskFn, callback);8085 } else {8086 retry(taskFn, callback);8087 }8088 function task1(done) {8089 task(done);8090 }8091 function task2(done) {8092 task(args[0], done);8093 }8094 function task3(done) {8095 task(args[0], args[1], done);8096 }8097 function task4(callback) {8098 args[lastIndex] = callback;8099 task.apply(null, args);8100 }8101 }8102 }8103 /**8104 * @memberof async8105 * @namespace iterator8106 */8107 function iterator(tasks) {8108 var size = 0;8109 var keys = [];8110 if (isArray(tasks)) {8111 size = tasks.length;8112 } else {8113 keys = nativeKeys(tasks);8114 size = keys.length;8115 }8116 return makeCallback(0);8117 function makeCallback(index) {8118 var fn = function() {8119 if (size) {8120 var key = keys[index] || index;8121 tasks[key].apply(null, createArray(arguments));8122 }8123 return fn.next();8124 };8125 fn.next = function() {8126 return index < size - 1 ? makeCallback(index + 1) : null;8127 };8128 return fn;8129 }8130 }8131 /**8132 * @memberof async8133 * @namespace apply8134 */8135 function apply(func) {8136 switch (arguments.length) {8137 case 0:8138 case 1:8139 return func;8140 case 2:8141 return func.bind(null, arguments[1]);8142 case 3:8143 return func.bind(null, arguments[1], arguments[2]);8144 case 4:8145 return func.bind(null, arguments[1], arguments[2], arguments[3]);8146 case 5:8147 return func.bind(null, arguments[1], arguments[2], arguments[3], arguments[4]);8148 default:8149 var size = arguments.length;8150 var index = 0;8151 var args = Array(size);8152 args[index] = null;8153 while (++index < size) {8154 args[index] = arguments[index];8155 }8156 return func.bind.apply(func, args);8157 }8158 }8159 /**8160 * @memberof async8161 * @namespace timeout8162 * @param {Function} func8163 * @param {number} millisec8164 * @param {*} info8165 */8166 function timeout(func, millisec, info) {8167 var callback, timer;8168 return wrappedFunc;8169 function wrappedFunc() {8170 timer = setTimeout(timeoutCallback, millisec);8171 var args = createArray(arguments);8172 var lastIndex = args.length - 1;8173 callback = args[lastIndex];8174 args[lastIndex] = injectedCallback;8175 simpleApply(func, args);8176 }8177 function timeoutCallback() {8178 var name = func.name || 'anonymous';8179 var err = new Error('Callback function "' + name + '" timed out.');8180 err.code = 'ETIMEDOUT';8181 if (info) {8182 err.info = info;8183 }8184 timer = null;8185 callback(err);8186 }8187 function injectedCallback() {8188 if (timer !== null) {8189 simpleApply(callback, createArray(arguments));8190 clearTimeout(timer);8191 }8192 }8193 function simpleApply(func, args) {8194 switch (args.length) {8195 case 0:8196 func();8197 break;8198 case 1:8199 func(args[0]);8200 break;8201 case 2:8202 func(args[0], args[1]);8203 break;8204 default:8205 func.apply(null, args);8206 break;8207 }8208 }8209 }8210 /**8211 * @memberof async8212 * @namespace times8213 * @param {number} n - n >= 18214 * @param {Function} iterator8215 * @param {Function} callback8216 * @example8217 *8218 * var iterator = function(n, done) {8219 * done(null, n);8220 * };8221 * async.times(4, iterator, function(err, res) {8222 * console.log(res); // [0, 1, 2, 3];8223 * });8224 *8225 */8226 function times(n, iterator, callback) {8227 callback = callback || noop;8228 n = +n;8229 if (isNaN(n) || n < 1) {8230 return callback(null, []);8231 }8232 var result = Array(n);8233 timesSync(n, iterate);8234 function iterate(num) {8235 iterator(num, createCallback(num));8236 }8237 function createCallback(index) {8238 return function(err, res) {8239 if (index === null) {8240 throwError();8241 }8242 result[index] = res;8243 index = null;8244 if (err) {8245 callback(err);8246 callback = noop;8247 } else if (--n === 0) {8248 callback(null, result);8249 }8250 };8251 }8252 }8253 /**8254 * @memberof async8255 * @namespace timesSeries8256 * @param {number} n - n >= 18257 * @param {Function} iterator8258 * @param {Function} callback8259 * @example8260 *8261 * var iterator = function(n, done) {8262 * done(null, n);8263 * };8264 * async.timesSeries(4, iterator, function(err, res) {8265 * console.log(res); // [0, 1, 2, 3];8266 * });8267 *8268 */8269 function timesSeries(n, iterator, callback) {8270 callback = callback || noop;8271 n = +n;8272 if (isNaN(n) || n < 1) {8273 return callback(null, []);8274 }8275 var result = Array(n);8276 var sync = false;8277 var completed = 0;8278 iterate();8279 function iterate() {8280 iterator(completed, done);8281 }8282 function done(err, res) {8283 result[completed] = res;8284 if (err) {8285 callback(err);8286 callback = throwError;8287 } else if (++completed >= n) {8288 callback(null, result);8289 callback = throwError;8290 } else if (sync) {8291 nextTick(iterate);8292 } else {8293 sync = true;8294 iterate();8295 }8296 sync = false;8297 }8298 }8299 /**8300 * @memberof async8301 * @namespace timesLimit8302 * @param {number} n - n >= 18303 * @param {number} limit - n >= 18304 * @param {Function} iterator8305 * @param {Function} callback8306 * @example8307 *8308 * var iterator = function(n, done) {8309 * done(null, n);8310 * };8311 * async.timesLimit(4, 2, iterator, function(err, res) {8312 * console.log(res); // [0, 1, 2, 3];8313 * });8314 *8315 */8316 function timesLimit(n, limit, iterator, callback) {8317 callback = callback || noop;8318 n = +n;8319 if (isNaN(n) || n < 1 || isNaN(limit) || limit < 1) {8320 return callback(null, []);8321 }8322 var result = Array(n);8323 var sync = false;8324 var started = 0;8325 var completed = 0;8326 timesSync(limit > n ? n : limit, iterate);8327 function iterate() {8328 var index = started++;8329 if (index < n) {8330 iterator(index, createCallback(index));8331 }8332 }8333 function createCallback(index) {8334 return function(err, res) {8335 if (index === null) {8336 throwError();8337 }8338 result[index] = res;8339 index = null;8340 if (err) {8341 callback(err);8342 callback = noop;8343 } else if (++completed >= n) {8344 callback(null, result);...

array-iterator.js

Source:array-iterator.js

1// Copyright 2013 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4var $arrayValues;5(function(global, utils) {6"use strict";7%CheckIsBootstrapping();8var GlobalArray = global.Array;9macro TYPED_ARRAYS(FUNCTION)10 FUNCTION(Uint8Array)11 FUNCTION(Int8Array)12 FUNCTION(Uint16Array)13 FUNCTION(Int16Array)14 FUNCTION(Uint32Array)15 FUNCTION(Int32Array)16 FUNCTION(Float32Array)17 FUNCTION(Float64Array)18 FUNCTION(Uint8ClampedArray)19endmacro20macro COPY_FROM_GLOBAL(NAME)21 var GlobalNAME = global.NAME;22endmacro23TYPED_ARRAYS(COPY_FROM_GLOBAL)24var arrayIteratorObjectSymbol = GLOBAL_PRIVATE("ArrayIterator#object");25var arrayIteratorNextIndexSymbol = GLOBAL_PRIVATE("ArrayIterator#next");26var arrayIterationKindSymbol = GLOBAL_PRIVATE("ArrayIterator#kind");27function ArrayIterator() {}28// TODO(wingo): Update section numbers when ES6 has stabilized. The29// section numbers below are already out of date as of the May 201430// draft.31// 15.4.5.1 CreateArrayIterator Abstract Operation32function CreateArrayIterator(array, kind) {33 var object = $toObject(array);34 var iterator = new ArrayIterator;35 SET_PRIVATE(iterator, arrayIteratorObjectSymbol, object);36 SET_PRIVATE(iterator, arrayIteratorNextIndexSymbol, 0);37 SET_PRIVATE(iterator, arrayIterationKindSymbol, kind);38 return iterator;39}40// 15.19.4.3.4 CreateItrResultObject41function CreateIteratorResultObject(value, done) {42 return {value: value, done: done};43}44// 22.1.5.2.2 %ArrayIteratorPrototype%[@@iterator]45function ArrayIteratorIterator() {46 return this;47}48// 15.4.5.2.2 ArrayIterator.prototype.next( )49function ArrayIteratorNext() {50 var iterator = $toObject(this);51 if (!HAS_DEFINED_PRIVATE(iterator, arrayIteratorNextIndexSymbol)) {52 throw MakeTypeError(kIncompatibleMethodReceiver,53 'Array Iterator.prototype.next', this);54 }55 var array = GET_PRIVATE(iterator, arrayIteratorObjectSymbol);56 if (IS_UNDEFINED(array)) {57 return CreateIteratorResultObject(UNDEFINED, true);58 }59 var index = GET_PRIVATE(iterator, arrayIteratorNextIndexSymbol);60 var itemKind = GET_PRIVATE(iterator, arrayIterationKindSymbol);61 var length = TO_UINT32(array.length);62 // "sparse" is never used.63 if (index >= length) {64 SET_PRIVATE(iterator, arrayIteratorObjectSymbol, UNDEFINED);65 return CreateIteratorResultObject(UNDEFINED, true);66 }67 SET_PRIVATE(iterator, arrayIteratorNextIndexSymbol, index + 1);68 if (itemKind == ITERATOR_KIND_VALUES) {69 return CreateIteratorResultObject(array[index], false);70 }71 if (itemKind == ITERATOR_KIND_ENTRIES) {72 return CreateIteratorResultObject([index, array[index]], false);73 }74 return CreateIteratorResultObject(index, false);75}76function ArrayEntries() {77 return CreateArrayIterator(this, ITERATOR_KIND_ENTRIES);78}79function ArrayValues() {80 return CreateArrayIterator(this, ITERATOR_KIND_VALUES);81}82function ArrayKeys() {83 return CreateArrayIterator(this, ITERATOR_KIND_KEYS);84}85%FunctionSetPrototype(ArrayIterator, {__proto__: $iteratorPrototype});86%FunctionSetInstanceClassName(ArrayIterator, 'Array Iterator');87utils.InstallFunctions(ArrayIterator.prototype, DONT_ENUM, [88 'next', ArrayIteratorNext89]);90utils.SetFunctionName(ArrayIteratorIterator, symbolIterator);91%AddNamedProperty(ArrayIterator.prototype, symbolIterator,92 ArrayIteratorIterator, DONT_ENUM);93%AddNamedProperty(ArrayIterator.prototype, symbolToStringTag,94 "Array Iterator", READ_ONLY | DONT_ENUM);95utils.InstallFunctions(GlobalArray.prototype, DONT_ENUM, [96 // No 'values' since it breaks webcompat: http://crbug.com/40985897 'entries', ArrayEntries,98 'keys', ArrayKeys99]);100%AddNamedProperty(GlobalArray.prototype, symbolIterator, ArrayValues,101 DONT_ENUM);102macro EXTEND_TYPED_ARRAY(NAME)103 %AddNamedProperty(GlobalNAME.prototype, 'entries', ArrayEntries, DONT_ENUM);104 %AddNamedProperty(GlobalNAME.prototype, 'values', ArrayValues, DONT_ENUM);105 %AddNamedProperty(GlobalNAME.prototype, 'keys', ArrayKeys, DONT_ENUM);106 %AddNamedProperty(GlobalNAME.prototype, symbolIterator, ArrayValues,107 DONT_ENUM);108endmacro109TYPED_ARRAYS(EXTEND_TYPED_ARRAY)110// -------------------------------------------------------------------111// Exports112utils.Export(function(to) {113 to.ArrayIteratorCreateResultObject = CreateIteratorResultObject;114});115$arrayValues = ArrayValues;...

collection-iterator.js

Source:collection-iterator.js

1// Copyright 2014 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4var $mapEntries;5var $mapIteratorNext;6var $setIteratorNext;7var $setValues;8(function(global, utils) {9"use strict";10%CheckIsBootstrapping();11var GlobalMap = global.Map;12var GlobalSet = global.Set;13// -------------------------------------------------------------------14function SetIteratorConstructor(set, kind) {15 %SetIteratorInitialize(this, set, kind);16}17function SetIteratorNextJS() {18 if (!IS_SET_ITERATOR(this)) {19 throw MakeTypeError(kIncompatibleMethodReceiver,20 'Set Iterator.prototype.next', this);21 }22 var value_array = [UNDEFINED, UNDEFINED];23 var entry = {value: value_array, done: false};24 switch (%SetIteratorNext(this, value_array)) {25 case 0:26 entry.value = UNDEFINED;27 entry.done = true;28 break;29 case ITERATOR_KIND_VALUES:30 entry.value = value_array[0];31 break;32 case ITERATOR_KIND_ENTRIES:33 value_array[1] = value_array[0];34 break;35 }36 return entry;37}38function SetEntries() {39 if (!IS_SET(this)) {40 throw MakeTypeError(kIncompatibleMethodReceiver,41 'Set.prototype.entries', this);42 }43 return new SetIterator(this, ITERATOR_KIND_ENTRIES);44}45function SetValues() {46 if (!IS_SET(this)) {47 throw MakeTypeError(kIncompatibleMethodReceiver,48 'Set.prototype.values', this);49 }50 return new SetIterator(this, ITERATOR_KIND_VALUES);51}52// -------------------------------------------------------------------53%SetCode(SetIterator, SetIteratorConstructor);54%FunctionSetPrototype(SetIterator, {__proto__: $iteratorPrototype});55%FunctionSetInstanceClassName(SetIterator, 'Set Iterator');56utils.InstallFunctions(SetIterator.prototype, DONT_ENUM, [57 'next', SetIteratorNextJS58]);59%AddNamedProperty(SetIterator.prototype, symbolToStringTag,60 "Set Iterator", READ_ONLY | DONT_ENUM);61utils.InstallFunctions(GlobalSet.prototype, DONT_ENUM, [62 'entries', SetEntries,63 'keys', SetValues,64 'values', SetValues65]);66%AddNamedProperty(GlobalSet.prototype, symbolIterator, SetValues, DONT_ENUM);67$setIteratorNext = SetIteratorNextJS;68$setValues = SetValues;69// -------------------------------------------------------------------70function MapIteratorConstructor(map, kind) {71 %MapIteratorInitialize(this, map, kind);72}73function MapIteratorNextJS() {74 if (!IS_MAP_ITERATOR(this)) {75 throw MakeTypeError(kIncompatibleMethodReceiver,76 'Map Iterator.prototype.next', this);77 }78 var value_array = [UNDEFINED, UNDEFINED];79 var entry = {value: value_array, done: false};80 switch (%MapIteratorNext(this, value_array)) {81 case 0:82 entry.value = UNDEFINED;83 entry.done = true;84 break;85 case ITERATOR_KIND_KEYS:86 entry.value = value_array[0];87 break;88 case ITERATOR_KIND_VALUES:89 entry.value = value_array[1];90 break;91 // ITERATOR_KIND_ENTRIES does not need any processing.92 }93 return entry;94}95function MapEntries() {96 if (!IS_MAP(this)) {97 throw MakeTypeError(kIncompatibleMethodReceiver,98 'Map.prototype.entries', this);99 }100 return new MapIterator(this, ITERATOR_KIND_ENTRIES);101}102function MapKeys() {103 if (!IS_MAP(this)) {104 throw MakeTypeError(kIncompatibleMethodReceiver,105 'Map.prototype.keys', this);106 }107 return new MapIterator(this, ITERATOR_KIND_KEYS);108}109function MapValues() {110 if (!IS_MAP(this)) {111 throw MakeTypeError(kIncompatibleMethodReceiver,112 'Map.prototype.values', this);113 }114 return new MapIterator(this, ITERATOR_KIND_VALUES);115}116// -------------------------------------------------------------------117%SetCode(MapIterator, MapIteratorConstructor);118%FunctionSetPrototype(MapIterator, {__proto__: $iteratorPrototype});119%FunctionSetInstanceClassName(MapIterator, 'Map Iterator');120utils.InstallFunctions(MapIterator.prototype, DONT_ENUM, [121 'next', MapIteratorNextJS122]);123%AddNamedProperty(MapIterator.prototype, symbolToStringTag,124 "Map Iterator", READ_ONLY | DONT_ENUM);125utils.InstallFunctions(GlobalMap.prototype, DONT_ENUM, [126 'entries', MapEntries,127 'keys', MapKeys,128 'values', MapValues129]);130%AddNamedProperty(GlobalMap.prototype, symbolIterator, MapEntries, DONT_ENUM);131$mapEntries = MapEntries;132$mapIteratorNext = MapIteratorNextJS;...

string-iterator.js

Source:string-iterator.js

1// Copyright 2014 the V8 project authors. All rights reserved.2// Use of this source code is governed by a BSD-style license that can be3// found in the LICENSE file.4(function(global, utils) {5"use strict";6%CheckIsBootstrapping();7// -------------------------------------------------------------------8// Imports9var GlobalString = global.String;10var ArrayIteratorCreateResultObject;11utils.Import(function(from) {12 ArrayIteratorCreateResultObject = from.ArrayIteratorCreateResultObject;13});14// -------------------------------------------------------------------15var stringIteratorIteratedStringSymbol =16 GLOBAL_PRIVATE("StringIterator#iteratedString");17var stringIteratorNextIndexSymbol = GLOBAL_PRIVATE("StringIterator#next");18function StringIterator() {}19// 21.1.5.1 CreateStringIterator Abstract Operation20function CreateStringIterator(string) {21 var s = TO_STRING_INLINE(string);22 var iterator = new StringIterator;23 SET_PRIVATE(iterator, stringIteratorIteratedStringSymbol, s);24 SET_PRIVATE(iterator, stringIteratorNextIndexSymbol, 0);25 return iterator;26}27// 21.1.5.2.1 %StringIteratorPrototype%.next( )28function StringIteratorNext() {29 var iterator = $toObject(this);30 if (!HAS_DEFINED_PRIVATE(iterator, stringIteratorNextIndexSymbol)) {31 throw MakeTypeError(kIncompatibleMethodReceiver,32 'String Iterator.prototype.next');33 }34 var s = GET_PRIVATE(iterator, stringIteratorIteratedStringSymbol);35 if (IS_UNDEFINED(s)) {36 return ArrayIteratorCreateResultObject(UNDEFINED, true);37 }38 var position = GET_PRIVATE(iterator, stringIteratorNextIndexSymbol);39 var length = TO_UINT32(s.length);40 if (position >= length) {41 SET_PRIVATE(iterator, stringIteratorIteratedStringSymbol,42 UNDEFINED);43 return ArrayIteratorCreateResultObject(UNDEFINED, true);44 }45 var first = %_StringCharCodeAt(s, position);46 var resultString = %_StringCharFromCode(first);47 position++;48 if (first >= 0xD800 && first <= 0xDBFF && position < length) {49 var second = %_StringCharCodeAt(s, position);50 if (second >= 0xDC00 && second <= 0xDFFF) {51 resultString += %_StringCharFromCode(second);52 position++;53 }54 }55 SET_PRIVATE(iterator, stringIteratorNextIndexSymbol, position);56 return ArrayIteratorCreateResultObject(resultString, false);57}58// 21.1.3.27 String.prototype [ @@iterator ]( )59function StringPrototypeIterator() {60 return CreateStringIterator(this);61}62//-------------------------------------------------------------------63%FunctionSetPrototype(StringIterator, {__proto__: $iteratorPrototype});64%FunctionSetInstanceClassName(StringIterator, 'String Iterator');65utils.InstallFunctions(StringIterator.prototype, DONT_ENUM, [66 'next', StringIteratorNext67]);68%AddNamedProperty(StringIterator.prototype, symbolToStringTag,69 "String Iterator", READ_ONLY | DONT_ENUM);70utils.SetFunctionName(StringPrototypeIterator, symbolIterator);71%AddNamedProperty(GlobalString.prototype, symbolIterator,72 StringPrototypeIterator, DONT_ENUM);...

Using AI Code Generation

1var BestSellerList = require('./BestSellerList');2var list = new BestSellerList();3list.add('The Hobbit');4list.add('The Lord of the Rings');5list.add('Harry Potter');6var iterator = list.iterator();7while (iterator.hasNext()) {8 console.log(iterator.next());9}10var BestSellerList = function () {11 this.books = [];12};13BestSellerList.prototype.add = function (book) {14 this.books.push(book);15};16BestSellerList.prototype.iterator = function () {17 var i = 0;18 var books = this.books;19 return {20 hasNext: function () {21 return i < books.length;22 },23 next: function () {24 return books[i++];25 }26 };27};28module.exports = BestSellerList;

Using AI Code Generation

1var BestInShow = require('./BestInShow.js');2var dogbreed = new BestInShow("German Shepherd");3dogbreed.addDog("Max");4dogbreed.addDog("Buddy");5dogbreed.addDog("Bailey");6for (var dog of dogbreed) {7 console.log(dog);8}9[Symbol.iterator]() {10 var i = 0;11 var dogs = this.dogs;12 return {13 next: function () {14 var done = (i >= dogs.length);15 var value = !done ? dogs[i++] : undefined;16 return {17 };18 }19 };20 }

Using AI Code Generation

1var BestBuy = require('./BestBuy.js');2var bb = new BestBuy();3var iter = bb.createIterator();4iter.first();5while(iter.hasNext()){6 console.log(iter.next());7}

Using AI Code Generation

1var Bestelling = require('./Bestelling');2var bestelling = new Bestelling();3bestelling.add('brood');4bestelling.add('kaas');5bestelling.add('ham');6var iterator = bestelling.getIterator();7while (iterator.hasNext()) {8 console.log(iterator.next());9}10var Iterator = require('./Iterator');11function Bestelling() {12 var items = [];13 this.add = function (item) {14 items.push(item);15 };16 this.getIterator = function () {17 return new Iterator(items);18 };19}20module.exports = Bestelling;21function Iterator(items) {22 var index = 0;23 this.hasNext = function () {24 return index < items.length;25 };26 this.next = function () {27 return items[index++];28 };29}30module.exports = Iterator;31var array = [1, 2, 3];32var iterator = array.iterator();33while (iterator.hasNext()) {34 console.log(iterator.next());35}

Automation Testing Tutorials

Learn to execute automation testing from scratch with LambdaTest Learning Hub. Right from setting up the prerequisites to run your first automation test, to following best practices and diving deeper into advanced test scenarios. LambdaTest Learning Hubs compile a list of step-by-step guides to help you be proficient with different test automation frameworks i.e. Selenium, Cypress, TestNG etc.

LambdaTest Learning Hubs:

• JUnit Tutorial
• TestNG Tutorial
• Webdriver Tutorial
• WebDriverIO Tutorial
• Protractor Tutorial
• Selenium 4 Tutorial
• Jenkins Tutorial
• NUnit Tutorial
• Jest Tutorial
• Playwright Tutorial
• Cypress Tutorial
• PyTest Tutorial

YouTube

You could also refer to video tutorials over LambdaTest YouTube channel to get step by step demonstration from industry experts.

Run Best automation tests on LambdaTest cloud grid

Perform automation testing on 3000+ real desktop and mobile devices online.

View sample repo View DocumentationSign up Free

›

_