JavaScript

Question 1

Array.prototype.at(index)

Answer 1

Takes an integer value. Allowing for positive and negative integers.
Returns the item at that index or undefined if index can’t be found.
Negative integers count back from the last item in the array. (Similar to array[0] or array[array.length-1] but can use .at(-1))

Example: 
const array1 = [1, 2, 3];
let index = 2;
array1.at(index); //expected output: 3
index = -2;
array1.at(index); //expected output: 2

Question 2

Array.prototype.length

Answer 2

Property of an object which is an instance of type Array sets or returns the number of elements in the array.

Example:
const array1 = [1,2,3];
array1.length; //e.o: 3

Question 3

Array.prototype.concat(array2)

Answer 3

Merges two or more arrays. Doesn’t change the existing arrays. Returns a NEW array.

Question 4

Objects

Answer 4

Datatype. Stores various keyed collections and more complex entities.

Question 5

Array.prototype.every(callback(element, index, array))

Answer 5

Tests whether all elements in the array pass the test implemented by the provided function. It returns a Boolean value. If the callback returns truthy for every element, every returns true. Otherwise returns false if just element fails.

*Calling this method on an empty array will return true for any condition!

Example:
[12, 5, 8, 130, 44].every(x => x >= 10); // false
[12, 54, 18, 130, 44].every(x => x >= 10); // true

https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array/every

Question 6

Array.prototype.filter(callback(element, index, array))

Answer 6

Creates a new array with all elements that pass the test implemented by the provided function. So if the test returns true, great, but if it returns false, the new array doesn’t include that element that failed the test.

Example:
const result = words.filter(word => word.length > 6);

Question 7

Array.prototype.forEach(callback(element, index, array))

Answer 7

Returns nothing (undefined). Executes a provided function once for each array element it loops through.

*There is no way to stop or break a forEach() loop other than by throwing an exception. If you need such behavior, the forEach() method is the wrong tool.

Early termination may be accomplished with:

A simple for loop
A for...of / for...in loops
Array.prototype.every()
Array.prototype.some()
Array.prototype.find()
Array.prototype.findIndex()

Array methods: every(), some(), find(), and findIndex() test the array elements with a predicate returning a truthy value to determine if further iteration is required.

*forEach expects a synchronous function.

forEach does not wait for promises. Make sure you are aware of the implications while using promises (or async functions) as forEach callback.

Question 8

Array.prototype.includes(searchElement, fromIndex)

Answer 8

Returns true/false. Loops through each element and checks if the value passed matches the element.

Example:
[1, 2, 3].includes(2)         // true
[1, 2, 3].includes(4)         // false
[1, 2, 3].includes(3, 3)      // false
[1, 2, 3].includes(3, -1)     // true

Question 9

Array.prototype.shift()

Answer 9

Removes the first element from an array and returns that removed element, or undefined if the array is empty. This method changes the length of the array.

Example: 
const firstElement = array1.shift();

Question 10

What is a closure?

Answer 10

Combination of a function bundled together (enclosed) with references to its surrounding state (the lexical environment). In other words, a closure gives you access to an outer function’s scope from an inner function. In JavaScript, closures are created every time a function is created, at function creation time.

Every closure has three scopes:

Local Scope (Own scope)
Outer Functions Scope
Global Scope

Question 11

What is scope?

Answer 11

Scope in JavaScript refers to the current context of code, which determines the accessibility of variables to JavaScript. The two types of scope are local and global:

1. Global variables are those declared outside of a block (var, let outside of functions)
2. Local variables are those declared inside of a block

Local scope can be function-scoped (var) or block-scoped (let, const) within (also) functions, if, for, while loop.

Question 12

What does null mean in JS?

Answer 12

A keyword in JavaScript that signifies ‘no value’ or nonexistence of any value. Assign a variable to null to shed off it’s assigned value. ‘Null’ is an object with a valid value, no properties, is non-mutable, and only a single instance of the same exists in the system at all time.

Question 13

What is undefined?

Answer 13

A global variable that JavaScript creates at run time. This global variable is assigned to an object in one of the following cases:
1. Declared but not defined – JavaScript assigns ‘undefined’ to any object that has been declared but not initialized or defined. In other words, in a case where no value has been explicitly assigned to the variable, JavaScript calls it ‘undefined’.

2. Array index or object property that does not exist.
3. A function parameter that has not been supplied.
4. The return value of functions that have to but don’t return a value.

Question 14

Hoisting

Answer 14

A behavior of JavaScript in which variable and function declarations are moved to the top of their scope before execution of the script. Only the actual declaration (var x) is hoisted, not the initialization (x=10).

https://www.digitalocean.com/community/tutorials/understanding-variables-scope-hoisting-in-javascript