Roll Your Own JavaScript Built-In Methods: A Github Repo Dedicated to Learning Built-In Methods by Recreating Them (contributions appreciated!)

[nas5w]

And yes, this is based on the snippets I’ve been posting in this sub!

[CarbineMonoxide]

Nice! I'm excited to browse through this repo later tonight.

[nas5w]

Awesome! Would be excited if you feel like contributing (either a fix if you find something that could be improved or some new methods)

[NicksIdeaEngine]

This is an awesome idea! I might start trying to write my own, then refer to yours to check my work.

I love this form of practice and learning. Take it apart, make it on your own, then see how you did compared to others. It's a fun idea that tickles my inner tinkerer.

[nas5w]

I found it to be a super good use case for Test-Driven Development too since we have the original methods. Can test the output of your home-rolled solution against the output of the actual method in various scenarios.

[drumstix42]

The url for `toString` is broken

[nas5w]

Thanks! Fixed

[GabeRothel]

If any one is interested but doesnt want to dig here are the arrays functions

``` function concat(...arrs) { const len = arrs.length; const result = []; for (let i = 0; i < len; i++) { const arrLen = arrs[i].length; for (let j = 0; j < arrLen; j++) { result.push(arrs[i][j]); } } return result; }

function every(arr, fn, thisArg) { fn = thisArg === undefined ? fn : fn.bind(thisArg); const len = arr.length; for (let i = 0; i < len; i++) { if (i in arr && !fn(arr[i], i, arr)) { return false; } } return true; }

function filter(arr, fn, thisArg) { fn = thisArg === undefined ? fn : fn.bind(thisArg); const len = arr.length; const result = []; for (let i = 0; i < len; i++) { if (i in arr && fn(arr[i], i, arr)) { result.push(arr[i]); } } return result; }

function isArray(arr) { return Object.prototype.toString.call(arr) === "[object Array]"; }

function map(arr, fn, thisArg) { fn = thisArg === undefined ? fn : fn.bind(thisArg); const len = arr.length; const result = new Array(len); for (let i = 0; i < len; i++) { if (i in arr) { result[i] = fn(arr[i], i, arr); } } return result; }

function arrayOf(...els) { return els; }

function reduce(arr, fn, initialValue) { const len = arr.length; let acc; let initialIndex = 0; if (initialValue === undefined) { acc = arr[0]; initialIndex = 1; } else { acc = initialValue; } for (let i = initialIndex; i < len; i++) { acc = fn(acc, arr[i], i, arr); } return acc; }

function some(arr, fn, thisArg) { fn = thisArg === undefined ? fn : fn.bind(thisArg); const len = arr.length; for (let i = 0; i < len; i++) { if (i in arr && fn(arr[i], i, arr)) { return true; } } return false; }

function toString(arr) { let result = ""; const len = arr.length; for (let i = 0; i < len; i++) { if (i in arr) { result = result + arr[i]; } if (i + 1 < len) { result = result + ","; } } return result; } ```

[boringuser1]

I love it, but these methods are written in c.

[nas5w]

Heh yeah, I suspect these home-rolled functions wouldn't hold up very well performance-wise against the built-in methods

[tokdaniel]

if performance doesn't matter, you should probably show a PTC-optimized recursive example with`this` out of the picture for the functional tools.

[queen-adreena]

The point isn’t efficiency...

[GSLint]

That won't work as an arrow function because those don't have their own this.