// Some code
/*******************************************************************************
Write a function `myForEach` that accepts an array and a callback as arguments.
The function should call the callback on each element of the array, passing in the
element, index, and array itself. The function does not need to return any value.
Do not use the built in Array#forEach.
Examples:
myForEach(['a', 'b', 'c'], function (el, i) {
console.log(el + ' is at index ' + i);
}); // prints
// a is at index 0
// b is at index 1
// c is at index 2
let test = [];
myForEach(['laika', 'belka'], function (el) {
test.push(el.toUpperCase());
});
console.log(test); // ['LAIKA', 'BELKA']
*******************************************************************************/
function myForEach(array, cb) {
for (let i = 0; i < array.length; i++) {
let el = array[i];
cb(el, i, array);
}
}
module.exports = myForEach;
Map
// Some code
/*******************************************************************************
Write a function `myMap` that accepts an array and a callback as arguments.
The function return an array of new elements obtained by calling the callback on
each element of the array, passing in the element.
Do not use the built in Array#map
// Examples
let result1 = myMap([100, 25, 81, 64], Math.sqrt);
console.log(result1); // [ 10, 5, 9, 8 ]
let result2 = myMap(['run', 'Forrest'], function (el) {
return el.toUpperCase() + '!';
});
console.log(result2); // [ 'RUN!', 'FORREST!' ]
*******************************************************************************/
function myMap(array, cb) {
let mapped = [];
for (let i = 0; i < array.length; i++) {
let ele = array[i];
mapped.push(cb(ele));
}
return mapped;
}
Reduce
/*******************************************************************************
Write a function `mySimpleReduce` that accepts an array and a callback as arguments.
The function should mimic the behavior of the built in Array#reduce, utilizing the
first element of the array as the default accumulator.
In other words, the function should begin with the first element of the array as
the accumulator and call the callback for each of the remaining elements in the array,
passing in the current accumulator and current element into the callback. Upon calling the callback,
the accumulator should be set to the result of the callback.
Examples:
let result1 = mySimpleReduce([5, 3, 2, 4], function(sum, el) {
return sum + el;
});
console.log(result1); // 14
let result2 = mySimpleReduce([4, 6, 2], function(product, el) {
return product * el;
});
console.log(result2); // 48
let result3 = mySimpleReduce([4, 6, 2, 8, 3], function(max, el) {
if (el > max) {
return el;
} else {
return max;
}
});
console.log(result3); // 8
*******************************************************************************/
function mySimpleReduce(array, cb) {
let accumulator = array[0];
array.slice(1).forEach(function (el) {
accumulator = cb(accumulator, el);
});
return accumulator;
}
Array Callback Methods Implemented With For Loops
How to implement array callback methods in JavaScript
Array Callback Methods Implemented With For Loops
How to implement array callback methods in JavaScript
Functions are called “First Class Objects” in JavaScript because:
A function is an instance of the Object type
A function can have properties and has a link back to its constructor method
You can store the function in a variable
You can pass the function as a parameter to another function
You can return the function from a function
What do you think will be printed in the following:
Anonymous callback, a named callback
function foo(callback) {
console.log("grape");
callback();
}
function bar() {
console.log("banana");
}
const fruitBasket = function () {
console.log("apple");
bar();
foo(bar);
foo(function () {
console.log("orange");
});
console.log("pear");
};
fruitBasket();
Function that takes in a value and two callbacks. The function should return the result of the callback who’s invocation results in a larger value.
function greaterValue(value, cb1, cb2) {
// compare cb1 invoked with value to cb2 invoked with value
// return the greater result
let res1 = cb1(value);
let res2 = cb2(value);
if (res1 > res2) {
// if this is false, we move out of if statement
return res1;
}
return res2;
}
let negate = function (num) {
return num * -1;
};
let addOne = function (num) {
return num + 1;
};
console.log(greaterValue(3, negate, addOne));
console.log(greaterValue(-2, negate, addOne));
Note: we do not invokenegateoraddOne(by using()to call them), we are passing the function itself.
Write a function, myMap, that takes in an array and a callback as arguments. The function should mimic the behavior of Array.prototype.map.
function myMap(arr, callback) {
// iterate through the array, perform the cb on each element
// return a new array with those new values
let mapped = [];
for (let i = 0; i < arr.length; i++) {
// remember that map passes three args with each element.
let val = callback(arr[i], i, arr);
mapped.push(val);
}
return mapped;
}
let double = function (num) {
return num * 2;
};
console.log(myMap([1, 2, 3], double));
Write a function, myFilter, that takes in an array and a callback as arguments. The function should mimic the behavior of Array.prototype.filter.
function myFilter(arr, callback) {
let filtered = [];
for (let i = 0; i < arr.length; i++) {
let element = arr[i];
if (callback(element, i, arr)) {
filtered.push(element);
}
}
return filtered;
}
Write a function, myEvery, that takes in an array and a callback as arguments. The function should mimic the behavior of Array.prototype.every.
function myEvery(arr, callback) {
for (let i = 0; i < arr.length; i++) {
let element = arr[i];
if (callback(element, i, arr) === false) {
return false;
}
}
return true;
}
Further Examples of the above concepts
const createMeowValue = () => {
console.log(this.name);
let meow = function () {
console.log(this);
console.log(this.name + " meows");
};
meow = meow.bind(this);
return meow;
};
const name = "Fluffy";
const cat = {
name: name,
age: 12,
createMeow: function () {
console.log(this.name);
let meow = () => {
const hello = "hello";
console.log(this.name + " meows");
};
let world = "";
if (true) {
world = "world";
}
console.log(world);
// meow = meow.bind(this);
return meow;
},
};
cat.newKey = function () {
const outermostContext = this;
const innerFunc = () => {
secondContext = this;
console.log(secondContext === outermostContext);
return function () {
innermostContext = this;
};
};
return innerFunc.bind(outermostContext);
};
const meow = cat.createMeow(); // method-style invocation
meow(); // function-style invocation
console.log("-------");
const createMeow = cat.createMeow;
const globalMeow = createMeow(); // function-style
globalMeow(); // function-style
function createSmoothie(ingredient) {
const ingredients = [ingredient];
return ingredients;
}
// console.log(createSmoothie('banana'));
// console.log(createSmoothie('apple'));
// one parameter only
// first argument is a string
// return an array
// DO NOT USE forEach