#utility functions

[obscurejavascript]

Quick Unique Value Filter in JavaScript

Filtering for unique values is a useful operation when processing lists of data that can more information than needed. Dealing with simple values like integers or strings, the process is quite obvious:

function unique(array) { const newArray = []; // A map cannot be used since there may be less items in the new array array.forEach(function(element) { let isDuplicate = false; for (let index = 0; index < newArray.length && isDuplicate === false; index += 1) { isDuplicate = element === newArray[index]; } if (isDuplicate === false) { newArray.push(element); } }); return newArray; } console.log(uniq([1, 2, 2, 3, 3, 4, 5])); // [ 1, 2, 3, 4, 5 ] console.log(uniq([5, 4, 5, 3, 2, 4, 1])); // [ 5, 4, 3, 2, 1 ] console.log(uniq(['test1', 'test1', 'test2'])); // [ 'test1', 'test2' ]

That function maintains the ordering of the original array and always uses the first unique value. Which is similar to (_.uniq from Lodash)[https://lodash.com/docs/4.17.4#uniq].

A very important note; An object key comparison cannot be used to simplify the above. Object keys are always stored as strings with anything being sent into a key being transformed into a string. Meaning objects with different references, but the same contents would be incorrectly labeled as duplicates. The Github source at the bottom of this post gives an example of this.

This basic unique will not handle more complex cases like when deep objects need to be compared on a single property, which is why it needs to be extended to support callbacks that determine uniqueness. For example, data is retrieved from a database that lists all cars and all thier versions, but only the unique car names need to be determined:

const cars = [ { name: 'miata', hp: '115' }, { name: 'miata', hp: '133' }, { name: 'elise', hp: '217' }, { name: 'miata', hp: '155' }, { name: 'elise', hp: '189' }, ]; const uniqueCars = unique(cars, function(carA, carB) { return carB !== undefined && carA.name === carB.name; }); console.log(uniqueCars); // [ { name: 'miata', hp: '115' }, // { name: 'elise', hp: '217' } ] The only part that changed in the original function was a check for if there is a callback: function unique(array, callback) { const newArray = []; const hasCallback = typeof callback === 'function'; // A map cannot be used since there may be less items in the new array array.forEach(function(element, index) { let isDuplicate = false; for (let index = 0; index < newArray.length && isDuplicate === false; index += 1) { if (hasCallback === true) { isDuplicate = callback(element, newArray[index]) === true; } else { isDuplicate = element === newArray[index]; } } if (isDuplicate === false) { newArray.push(element); } }); return newArray; }

This is similar to (_.uniqWith from Lodash)[https://lodash.com/docs/4.17.4#uniqWith]

Github Location: https://github.com/Jacob-Friesen/obscurejs/blob/master/2017/unique.js

[obscurejavascript]

Find Index in JavaScript

Although it seems like a find function which finds the position of an occurance is always good enough for searching, a findIndex can sometimes be more useful. For example, if a user is inserting an array of information (batch insert), they should know which specific columns had errors:

function insertBatch(data, callback) { // Simulate an API call with some error returns setTimeout(function() { callback([ data[0], data[1], { error: 'Cannot insert with a negative quantity' }, { error: '"row-2" was already specified' }, data[4] ]); }, 500); } const formattedUserInput = [ { id: 'row-1', display: 'Test A' , quantity: 100 }, { id: 'row-2', display: 'Test B' , quantity: 50 }, { id: 'row-3', display: 'Test C' , quantity: -100 }, { id: 'row-2', display: 'Test D' , quantity: 100 }, { id: 'row-5', display: 'Test E' , quantity: 1 }, ]; insertBatch(formattedUserInput, function(data) { const errorIndex = findIndex(data, function(row) { return row.error !== undefined; }); if (errorIndex !== -1) { console.log('There was an error at row', (errorIndex + 1) + ':'); console.log(data[errorIndex].error); } else { console.log('All rows inserted successfully'); } }); // There was an error at row 3 // Cannot insert with a negative quantity

A findIndex function is present in many libraries like Lodash. Here is a simple implementation used above to give a better idea of what it does:

function findIndex(array, callback) { for (let index = 0; index < array.length; index += 1) { if (callback(array[index]) === true) { return index; } } return -1; }

Of course fixing 1 row at would be annoying for a user, so a findIndices function would be better. It just involves one small change:

function findIndices(array, callback) { const indices = []; for (let index = 0; index < array.length; index += 1) { if (callback(array[index]) === true) { indices.push(index); } } return indices; }

Unfortunately, I could not find any libraries with a findIndices function unlike findIndex, so a custom function does have to be used in real code. Here is the modified error printing which also only requires a slight change:

function findIndicesVersion() { console.log('\nFind Indices Version:'); insertBatch(formattedUserInput, function(data) { const errorIndices = findIndices(data, function(row) { return row.error !== undefined; }); if (errorIndices.length !== 0) { errorIndices.forEach(function(errorIndex) { console.log('There was an error at row', (errorIndex + 1) + ':'); console.log(data[errorIndex].error); }); } else { console.log('All rows inserted successfully.'); } }); } // There was an error at row 3: // Cannot insert with a negative quantity // There was an error at row 4: // "row-2" was already specified

Github Location: https://github.com/Jacob-Friesen/obscurejs/blob/master/2017/findIndex.js

[duncanscottwilson]

Sometimes the most rational choice is to take eL. eS. Dee. & eM. Dee. eM. Aye and cuddle and talk all night. It seems if you don’t love anyone then consequently you love everyone.

The most inconceivable part personally is the fact that these are just hints of the rich and intricate quaila state-spaces of our post-human progeny.

Much love errone.