#api functions

There are many libaries and functions to find asynchronous resources. But there are times when you just want to quickly get a bunch of pieces of data without going through the trouble of investigating and using multiple libraries. It is also useful to know how to easily get async resouces without libraries, since it shows the core idea of what libraries will do (though they should be much more optimized though). For the simplest strategy, the key is to apply recursion:

// Simulate an API call function getCar(carName, callback) { const cars = { miata: { hp: 155, weight: 2400 }, elise: { hp: 217, weight: 2000 }, '4C': { hp: 237, weight: 2465 } }; setTimeout(function() { callback(cars[carName]); }, 500); }; function findAllCars(carNames, callback, index, cars) { index = index || 0; cars = cars || []; getCar(carNames[index], function(car) { cars.push(car); if (cars.length < carNames.length) { findAllCars(carNames, callback, index + 1, cars); } else { callback(cars); } }); }; const carNames = ['4C', 'miata', 'elise']; findAllCars(carNames, function(cars) { console.log(cars); // [ { hp: 237, weight: 2465 }, // { hp: 155, weight: 2400 }, // { hp: 217, weight: 2000 } ] });

The idea is that the item set (carNames) is iterated through by incrementing the index with the cars variable accumulating the results. Arguably, the length of cars could be used instead of index, but that makes the codes intention less clear and so less easy to adapt. This pattern can be used to extract any form of objects asynchronously easily and supports many variants with only tiny alterations. For example, in this case there are no dependencies between calls, so all the calls could be done at once. This is simple if order does not matter:

function findAllCarsOptimized(carNames, callback) { let index = 0, cars = []; carNames.forEach(function(carName) { getCar(carName, function(car) { cars.push(car); if (cars.length === carNames.length) { callback(cars); } }); }); };

In other words, just iterate through each car and send a request. Recursion does not need to be done, so the callback condition is only needed. The rest of the structure remains the same. Which makes this a great strategy for prototyping anything asynchronous or doing code when Promises or libraries are not available/practical.

Nodes exec exposes the outside operating systems functions by sending commands to a shell in a separate OS process. When the command completes, the callback is called with the output or error. For these examples, I will just focus on UNIX (OS X, Linux etc) applicable commands since Windows commands are very different. By default exec on UNIX uses SH (/bin/sh specifically).

const exec = require('child_process').exec; // From https://stackoverflow.com/a/13322549 const cmd = "ifconfig | grep -Eo 'inet (addr:)?([0-9]*\\.){3}[0-9]*' | grep -Eo '([0-9]*\\.){3}[0-9]*' | grep -v '127.0.0.1'"; exec(cmd, function(err, output, errorOuput) { if (err) { console.log(errorOuput); throw(new Error(err)); } console.info('IP Address:', output); // IP Address: Your computers (or virtual machines) IP address });

Although the command looks complicated, it is much harder to do in Node.js: https://stackoverflow.com/questions/3653065/get-local-ip-address-in-node-js, at least without a library. Basically, almost any command that can be run in your command line can run unmodified in exec. exec also has an options argument which supports concepts like environment variables. For example to check the installed Node.js versions via NVM:

exec('. "$NVM_DIR/nvm.sh" && nvm ls', { // $HOME is a default environment variable that will point to the current users Home directory NVM_DIR: '$HOME/.nvm' }, function(err, output, errorOuput) { if (err) { console.log(errorOuput); throw(new Error(err)); } console.info('Installed Node.js versions:\n', output); // Installed Node.js versions: // (Your Node.js versions installed with NVM) });

More info on execs details can be found here.

exec is great for short running scripts and simple commands, but can be bad for long processes since it only outputs all the results at the end. Additionally, exec does no checks, so all external input needs to be sanitized to ensure it does not contain descructive commands which makes complex script executions cumbersome.