Lodash is a very useful utility library that lets us work with objects and arrays easily.

However, now that the JavaScript standard library is catching up to libraries such as Lodash, we can implement many of the functions in simple ways.

In this article, we’ll look at how to implement array methods for excluding items and unzipping arrays.

`unzip`

`unzip`

accepts an array of grouped elements and creates an array by regrouping the elements into their configuration before zipping them.

All we have to do to implement `unzip`

is to loop through each of the arrays and rearrange them as follows:

```
const unzip = (zipped) => {
let unzipped = zipped[0].map(z => []);
for (let j = 0; j < unzipped.length; j++) {
for (let i = 0; i < zipped.length; i++) {
unzipped[j].push(zipped[i][j])
}
}
return unzipped;
}
```

In the code above, we created a function that takes `zipped`

arrays and inside the function, we mapped the first entry of `zipped`

to a new array of arrays.

This is because the unzipped array should have arrays that are of the same size as each array entry in the zipped array.

Then we push the zipped entry in the given position into the unzipped array’s array entry.

For instance, if we call `unzip`

with the following zipped array:

```
const result = unzip([
['a', 1, true],
['b', 2, false]
]);
```

Then `unzip`

first maps the first zipped entry into a new array and set it to the `unzipped`

variable.

Then the nested loop takes `'a'`

and then puts it into the first entry of the unzipped array. Then it pushes `'b'`

as the 2nd entry of the same array.

In the next iteration, it pushes 1 into the next unzipped array entry. Then it pushes 2.

The same process is done for the next iteration. Therefore, the unzipped array should be:

```
[
[
"a",
"b"
],
[
1,
2
],
[
true,
false
]
]
```

`unzipWith`

`unzipWith`

is like `unzip`

, but we can pass in an `iteratee`

function to choose how to regroup our array. The `iteratee`

function takes 2 arguments and returns the one that’s the combination of the 2.

For instance, we can implement `unzipWith`

as follows:

```
const unzipWith = (zipped, iteratee) => {
let unzipped = zipped[0].map(z => []);
for (let j = 0; j < unzipped.length; j++) {
for (let i = 0; i < zipped.length; i++) {
unzipped[j].push(zipped[i][j])
}
}
return unzipped.map(arr => {
return arr.reduce(iteratee);
});
}
```

It’s almost the same as `unzip`

except that we called `reduce`

to combine the values with `iteratee`

via the `map`

method before returning the unzipped array.

Then when we call it as follows:

```
const result = unzipWith([
[1, 10, 100],
[2, 20, 200]
], (a, b) => a + b);
```

We get:

```
[
3,
30,
300
]
```

for `result`

.

`without`

The Lodash`without`

method returns an array that excludes all the given values using the SameValueZero algorithm for comparison.

We can easily exclude items with our own `without`

function as follows:

```
const without = (arr, values) => arr.filter(a => !values.includes(a))
```

In the code above, we called `filter`

on `arr`

and the leave the ones that aren’t in `values`

by calling `includes`

to check if it’s in `values`

.

Then when we call it as follows:

```
const result = without([1, 2, 3, 4, 5], [4]);
```

We get that `result`

is:

```
[
1,
2,
3,
5
]
```

`xor`

The `xor`

function returns an array of unique values that aren’t included in all arrays. This is also known as the symmetric difference.

The order of the result is determined by when they occur in the array.

To implement it, we can just check whether they occur in all arrays and then exclude them if they do:

```
const xor = (...arrs) => {
const symDiff = [];
for (const arr of arrs) {
for (const a of arr) {
const inAllArrays = arrs.every(arr => arr.includes(a));
if (!inAllArrays) {
symDiff.push(a);
}
}
}
return symDiff;
}
```

In the code above, we looped through each array in `arrs`

then inside, we loop through each array entry in each entry of `arrs`

and check whether an element is in every array in `arrs`

by using the `every`

method on `arrs`

.

The callback uses `includes`

to check whether each element is in each array in `arrs`

.

If it’s not, then we push it to the `symDiff`

array, and in the end, we return that array.

Then when we call it as follows:

```
const result = xor([2, 1], [2, 3])
```

We get that `result`

is:

```
[
1,
3
]
```

since 1 and 3 are not in all the arrays.

### Conclusion

unzipping arrays means that we’re rearranging the entries so that each entry in the nested array is now in their own array position.

We can also return a new array with some entries excluded with the `without`

function, which we can implement with `filter`

and `includes`

.

Finally, we can find the symmetric difference by checking if the elements are included in each array in the nested array and exclude those.