CtrlK
BlogDocsLog inGet started
Tessl Logo

tessl/npm-async-each

Ultra-simple, 35-lines-of-code async parallel forEach function for JavaScript

—

Pending

Quality

Pending

Does it follow best practices?

Impact

Pending

No eval scenarios have been run

SecuritybySnyk

Pending

The risk profile of this skill

Overview
Eval results
Files

Async Each

Async Each is an ultra-simple, lightweight JavaScript library that provides asynchronous parallel iteration over arrays. It offers a no-bullshit, 35-lines-of-code solution for processing arrays concurrently with error handling and result transformation, without the overhead of larger async libraries.

Package Information

  • Package Name: async-each
  • Package Type: npm
  • Language: JavaScript
  • Installation: npm install async-each

Core Imports

const each = require('async-each');

For AMD (RequireJS):

define(['async-each'], function(each) {
  // use each
});

For browser (global):

// Available as window.asyncEach
asyncEach(array, iterator, callback);

Basic Usage

const each = require('async-each');
const fs = require('fs');

// Process files in parallel
each(['file1.txt', 'file2.txt', 'file3.txt'], fs.readFile, function(error, contents) {
  if (error) {
    console.error('Error reading files:', error);
    return;
  }
  console.log('File contents:', contents);
});

// Transform data in parallel
each([1, 2, 3, 4, 5], function(item, done) {
  // Simulate async operation
  setTimeout(() => {
    done(null, item * 2);
  }, 100);
}, function(error, results) {
  if (error) {
    console.error('Error:', error);
    return;
  }
  console.log('Results:', results); // [2, 4, 6, 8, 10]
});

Capabilities

Parallel Array Processing

Processes array items asynchronously in parallel, maintaining original array order in results.

/**
 * Asynchronous parallel forEach function for arrays
 * @param items - Array of items to process
 * @param next - Iterator function called for each item
 * @param callback - Optional completion callback
 */
function each(items, next, callback);

Parameters:

  • items (Array, required): Array of items to process. Must be an array, throws TypeError if not.
  • next (Function, required): Iterator function called for each item. Signature: next(item, done)
    • item: Current array item being processed
    • done: Callback function with signature done(error, transformedItem)
      • error: Error value (any truthy value treated as error)
      • transformedItem: Optional transformed result for this item
  • callback (Function, optional): Completion callback. Signature: callback(error, results)
    • error: Error object if any iteration failed, undefined on success
    • results: Array of transformed items in original order
    • Defaults to no-op function if not provided

Behavior:

  • Processes all array items concurrently (parallel execution)
  • Maintains original array order in results
  • Stops execution on first error and calls callback with error
  • Returns undefined (no return value)
  • Creates results array with same length as input array

Error Handling:

  • Throws TypeError if items is not an array
  • Throws TypeError if next is not a function
  • Calls callback with Error object if any iterator returns an error
  • Iterator errors are wrapped in new Error() constructor

Usage Examples:

const each = require('async-each');

// File processing example
each(['config.json', 'data.json'], require('fs').readFile, function(error, files) {
  if (error) return console.error(error);
  console.log('Loaded files:', files.map(f => f.toString()));
});

// Data transformation example
each(['hello', 'world'], function(item, done) {
  done(null, item.toUpperCase());
}, function(error, results) {
  console.log(results); // ['HELLO', 'WORLD']
});

// Error handling example
each([1, 2, 3], function(item, done) {
  if (item === 2) {
    done('Error processing item 2');
  } else {
    done(null, item * 10);
  }
}, function(error, results) {
  if (error) {
    console.error('Processing failed:', error); // "Error processing item 2"
  }
});

// Without callback (fire and forget)
each([1, 2, 3], function(item, done) {
  console.log('Processing:', item);
  done(null, item);
});

Types

For TypeScript users, the effective type definitions are:

type IteratorFunction<T, R> = (
  item: T, 
  done: (error?: any, result?: R) => void
) => void;

type CompletionCallback<R> = (
  error?: Error, 
  results?: R[]
) => void;

function each<T, R>(
  items: T[], 
  next: IteratorFunction<T, R>, 
  callback?: CompletionCallback<R>
): void;

Environment Compatibility

  • Node.js: Full support via CommonJS export (module.exports)
  • Browser: Global export as window.asyncEach
  • AMD/RequireJS: AMD module support
  • ES Modules: Supported via CommonJS interop (e.g., import each from 'async-each')

Error Patterns

Common error scenarios and handling:

const each = require('async-each');

// Invalid arguments
try {
  each('not-an-array', function() {}, function() {});
} catch (error) {
  console.error(error.message); // "each() expects array as first argument"
}

try {
  each([], 'not-a-function', function() {});
} catch (error) {
  console.error(error.message); // "each() expects function as second argument"
}

// Iterator error handling
each([1, 2, 3], function(item, done) {
  if (item === 2) {
    done('Custom error message');
  } else {
    done(null, item);
  }
}, function(error, results) {
  if (error) {
    console.error('Error occurred:', error.message); // "Custom error message"
  }
});
Workspace
tessl
Visibility
Public
Created
Last updated
Describes
npmpkg:npm/async-each@0.1.x
Publish Source
CLI
Badge
tessl/npm-async-each badge