// 1) What is the output of 10+20+"30" in JavaScript?

//Ans: 3030 because 10+20 will be 30. If there is numeric value before and after +, it treats as binary + (arithmetic operator).

// 2) What is the output of "10"+20+30 in JavaScript?

// Ans: 102030 because after a string all the + will be treated as string concatenation operator (not binary +).

// 3) Output?

// Syncronous

[1, 2, 3, 4].forEach((i) => {

console.log(i);

});

// Asynchronous

function asyncForEach(array, cb) {

array.forEach(() => {

setTimeout(cb, 0);

});

}

asyncForEach([1, 2, 3, 4], (i) => {

console.log(i);

});

// 4) Output? And explain (hint: Octal)

console.log(016);

console.log(017);

console.log(026);

console.log(027);

// 5) Output?

console.log([..."Hello"]);

// OUTPUT

function sum(a, b) {

a = 10;

return [a + b, arguments[0] + arguments[1]];

}

// in "use strict" => [12, 3]

// in normal mood => [12, 12]

console.log(sum(1, 2));

// Event Propagation

// event.currentTaget.tagName

// this.tagName

// sameValuZero algorithm

const sameValueZero = (a, b) => {

if (a === b || (Number.isNaN(a) && Number.isNaN(b))) {

return true;

}

return false;

};

// Output

// ==, ===, object.is, sameValuZero algorithm

const array = [NaN];

const result = array.includes(NaN);

console.log(result); // True: why? => array.includes follows sameValueZero algorithm

// Output

const p = Promise.resolve("Hello");

p.then((val) => {

console.log(val);

return `${val} world`;

}).then((newVal) => {

console.log("new ", newVal);

});

// Output => level => easy

function* counter() {

let index = 0;

while (true) {

yield index++;

}

}

const gen = counter();

console.log(gen.next().value);

console.log(gen.next().value);

console.log(gen.next().value);

// Output

var y = 1;

if (function f() {}) {

y += typeof f;

}

console.log(y);

// Output

var k = 1;

if (1) {

eval(function foo() {});

k += typeof foo;

}

console.log(k);

// Output

var k = 1;

if (1) {

function foo() {}

k += typeof foo;

}

console.log(k);

// Write a function that would allow you to do this 👉🏻 multiply(5)(6)

// Ans:

function multiply(a) {

return function (b) {

return a * b;

};

}

multiply(5)(6);

// Explain what is callback function is and provide a simple example

function modifyArray(arr, callback) {

arr.push(100);

callback();

}

let arr = [1, 2, 3, 4, 5];

modifyArray(arr, () => {

console.log("Array has been modified ", arr);

});

// Given a string, reverse each word in the sentence

const reverseBySeparator = (str, separator) =>

str.split(separator).reverse().join(separator);

const str = "Welcome to this Javascript Guide!";

const reverseEntireSentence = reverseBySeparator(str, "");

const reverseEachWord = reverseBySeparator(reverseEntireSentence, " ");

console.log(reverseEntireSentence, reverseEachWord);

// Output

function foo(func) {

return func.name;

}

console.log(foo(function myName() {}));

// Output

console.log((1 + 2, 3, 4));

console.log((2, 9 / 3, function () {}));

console.log((3, true ? 2 + 2 : 1 + 1));

// Output

function foo() {

return 1, 2, 3, 4;

}

foo();

// Event Loop output test

function main() {

console.log("A");

setTimeout(function exec() {

console.log("B");

}, 0);

runWhileLoopForNSeconds(3);

console.log("C");

}

main();

function runWhileLoopForNSeconds(sec) {

let start = Date.now(),

now = start;

while (now - start < sec * 1000) {

now = Date.now();

}

}

// Write a function where suppose you want to use a variable for counting something, and you want this counter to be available to all functions.

// Initiate counter

let counter = 0;

// Function to increment counter

function add() {

counter += 1;

}

// Call add() 3 times

add();

add();

add();

// The counter should now be 3

// Solve

const add = (function () {

let counter = 0;

return function () {

counter += 1;

return counter;

};

})();

add();

add();

add(); // the counter is now 3

// Explained

// The variable add is assigned to the return value of a self-invoking function.

// The self-invoking function only runs once. It sets the counter to zero (0), and returns a function expression.

// This way add becomes a function. The "wonderful" part is that it can access the counter in the parent scope.

// This is called a JavaScript closure. It makes it possible for a function to have "private" variables.

// The counter is protected by the scope of the anonymous function, and can only be changed using the add function.