JavaScript

Question 1

What is JavaScript?

Answer 1

JavaScript is a single-threaded, multi-paradigmed (OOP and FP), interpreted, programming language

Question 2

What is the difference between let, const, and var?

Answer 2

let and const are blocked scoped. var is function scoped no matter how deeply it may be nested inside that function.

Question 3

What is the difference between a first-class and higher-order function?

Answer 3

A first-class function is a function that can be used just like any other variable. For example, a first-class function can be assigned to a variable, passed as an argument to another function, and even even be returned by a function. A higher-order function is a subset of a first-class function; it can only be passed to and returned by other functions

Question 4

What is JS’s most popular execution environment?

Answer 4

The browser

Question 5

What are the 7 primitive types and what are their associated bits?

Answer 5

1. number (64 bit double)
2. bigInt (arbitrary bit integer)
3. boolean
4. string (16 bit unicode)
5. null
6. undefined

Question 6

What is the result of the following code:

NaN === NaN

Answer 6

The result is false. This is because NaN is not equal to any other value, including itself. Use Number.isNaN(x) instead

Question 7

What is the behavior of === for primitives and reference types?

Answer 7

Primitives:

• Test to see if 2 values are the same

Reference Types:

• Test to see if 2 reference variables point to the same object in the heap

Question 8

Are strings iterable?

Answer 8

Yes

Question 9

What are the 2 ways to access a character of a string at a given index?

Answer 9

1. str.charAt(index);
2. str[index];

Question 10

Code an example of a template literal

Answer 10

let name = "Gianmarco";
Console.log(`Hello, ${name}!`)

Question 11

Which 5 values evaluate to false and which values evaluate to true?

Answer 11

Evaulate to false:
* null
* undefined
* NaN
* 0
* “”

Evaluates to true:
* Everything else

Question 12

What is the global object for all JS code inside a browser?

Answer 12

Window

Question 13

What is the default value for uninitialized variables?

Answer 13

undefined

Question 14

Code an example of a destructuring assignment

Answer 14

let [x, y] = [1, 2]; // variable names do not have to match

console.log(x, y); // 1 2

let {x, y} = {x: 0, y:0} // variable names must match, else undefined

console.log(x, y) // 0 0

Question 15

Code an example of the 2 different ways to access an object’s property

Answer 15

let obj = {x:0, y:0};

console.log(obj["x"]); // 0
console.log(obj.x); // 0

Question 16

What is the behavior of optional chaining?

a?.b;

Answer 16

If a is not null or undefined, access b. Else, return undefined

Question 17

All objects are instances of which class?

Answer 17

Object

Question 18

What do the following expressions return?

1 && 2;

0 && 1;

1 && 0;

Answer 18

1 && 1 returns 2. This is because if both values are true, the right operand is returned

0 && 1 returns 0. This is because if the first value is false, the expressions short circuits and returns it

1 && 0 returns 0. This is because 1 is true so the operator returns the right operand

Question 19

Code a function using a default parameter value

Answer 19

function f(x = 0) {...}

Question 20

What is the behavior of the nullish coalescing operator?

a ?? b;

Answer 20

If a is null or undefined, return b. Else, return a

Question 21

What does the following code return?

let result = "x" in {x: 0};
console.log(result);

Answer 21

function

Question 22

What is the behavior of the following code?

let obj = {x:0, y:0};
delete obj.x;
console.log(obj);

Answer 22

Deletes the x property of obj

{y:0}

Question 23

What is the behavior of the following code?

let arr = [1,2,3];
delete arr[0];
console.log(arr.length);
console.log(typeof arr[0]);

Answer 23

Deletes the first element of arr causing it to become a sparsed array. It’s length will remain at 3 but its first element will be undefined

Question 24

Code 2 examples using the in operator. 1 for an array, and the other for an object

Answer 24

let arr = ["a","b"];
console.log(0 in arr); // true

let obj = {x:0, y:0};
console.log("x" in obj); //true

Question 25

What is the difference between the for/of and for/in loop?

Answer 25

The for/of loop iterates over the elements of an iterable and therefore, cannot be used on non-iterable objects. The for/in loop iterates over the properties of both iterables and non-iterable objects

Question 26

Are ES6 modules automatically strict code?

Answer 26

Yes

Question 27

# What is the behavior of the following code? ``` "use strict"; function f() {console.log(this);} f(); ```

Answer 27

`f()` prints `undefined`. That is because in strict mode, `f()` is invoked as a regular function and not a method

Question 28

Summarize the behavior of a hoisted function

Answer 28

A hoisted function is a function that can be called before its definition. This is because function definitions are parsed before function calls

Question 29

What are the 2 types that are allowed to be object properties?

Answer 29

1. Strings 2. Symbols

Question 30

# What is the behavior of the following code? ``` let obj = {x: 0, x:1}; console.log(obj); ```

Answer 30

The code will pring `{x:1}` because later properties with the same name will override earlier ones

Question 31

What are the 3 different property attributes available?

Answer 31

1. writable: can be set 2. enumerable: can be iterated 3. configurable: can be deleted or changed

Question 32

Code an example of instantiating an object with the following prototype object: `{x: 1, y:2}`

Answer 32

``` let obj = Object.create({x: 1, y:2}); console.log(obj.x, obj.y); ```

Question 33

What is the utility method to serialize a JS object into a JSON object and what is the method to deserialize a JSON object into a JS object?

Answer 33

1. `JSON.stringify()` 2. `JSON.parse()`

Question 34

# What is the behavior of the spread operator? ``` [..."ab"]; [...{x:1, y:2}]; {...{x:1, y:2}}; ```

Answer 34

`[..."abc"]` returns `["a", "b"]` since `"ab"` is an iterable `[...{x:1, y:2}]` returns an error since objects are not iterables `{...{x:1, y:2}}` returns `{x:1, y:2}` since using the spread operator on an object only works if it's used inside another object

Question 35

# What is the behavior of the following code? ``` const arr = new Array(); arr.push(1); arr.push(2); arr.push(3); const squares = Array.from(arr, (e) => e*e); console.log(squares); ```

Answer 35

`Array.from()` copies the elements from `arr` after transforming them

Question 36

Code an example of removing the `2` in the `[1,2,3]` array without causing it to become sparse

Answer 36

``` const arr = [1,2,3]; arr.splice(1,1); console.log(arr); ```

Question 37

# Does the following code return the same or new array? ``` let arr = [1,2,3]; arr.map(e => e*e); ```

Answer 37

`arr.map()` returns a new array

Question 38

What is the behavior of `arr.filter()`?

Answer 38

The function defined inside `filter` should return `true` or `false`. If `true`, the value is added to a new array. Else, the value is ignored

Question 39

# What is the behavior of the following code? ``` const obj = { f() { const g = () => console.log(this); g(); } } obj.f(); ```

Answer 39

When `obj.f()` is called, the lambda will inherit the `this` value of its enclosing scope `f()` which evaluates to `obj`. Therefore, the lambda inside `f()` will print `obj`

Question 40

# Is the following code valid? ``` const rectangle = (width, height=width*2) => ({width, height}); ```

Answer 40

Yes. In JS, method parameters can use the values of previous method parameters

Question 41

What is a set in JS?

Answer 41

A set is an ordered collection of unique elements. Elements are considered equal if they refer to the same object (`===`)

Question 42

What is a Map?

Answer 42

A Map is an ordered collection of key-value pairs. Each key is unique

Question 43

What is JS's top error class?

Answer 43

`Error`

Question 44

Code an example of a callback function

Answer 44

``` setTimeout(() => console.log("Hello, world!"), 3000); ```

Question 45

What is a promise?

Answer 45

A promise is an object that represents the future result of an asynchronous operation

Question 46

# What is the behavior of the following code? ``` asyncFunction() .then((result1) => return value/promise) .then((result2) => console.log(result)) .catch((error) => console.log(error)); ```

Answer 46

`asyncFunction` immediately returns a promise. If the promise is fulfilled, `then()` is invoked. `then()` invokes the callback function passing in the result of the fulfilled promise as an argument. If any errors come up in either `asyncFunction` or the callback function of `then()`, `catch()` is invoked. `catch()` invokes its callback function passing in the error as an argument

Question 47

What are the 5 different possible states of a promise?

Answer 47

* Fulfilled * Rejected * Pending (neither fulfilled nor rejected, operation still in process) * Settled (fulfilled or rejected) * Resolved (callback value or promise is returned to match the state of another promise)

Question 48

# What is the behavior of the following code? ``` asyncFunction() .then(() => throw new Error();) .catch(e => console.log(e)) ```

Answer 48

When the callback function in `then()` throws an error, the promise is rejected and `catch()` will be invoked

Question 49

# Is the following code valid? ``` startAsyncOperation() .then(doStageTwo) .catch(recoverFromStageTwoError) .then(doStageThree) .then(doStageFour) .catch(logStageThreeAndFourErrors); ```

Answer 49

Yes. Multiple `catch()` methods can be used

Question 50

What is the purpose of `promise.all([promise1, promise2])`?

Answer 50

To take in an array of promises and returns a promise. The returned promise will be rejected if any of the input promises are rejected. Otherwise, it will be fulfilled with an array of the fulfillment values of each of the input promises

Question 51

# Study the following code: ``` // We start with an array of URLs const urls = [ /* zero or more URLs here */ ]; // And convert it to an array of Promise objects promises = urls.map(url => fetch(url).then(r => r.text())); // Now get a Promise to run all those Promises in parallel Promise.all(promises) .then(bodies => { /* do something with the array of strings */ }) .catch(e => console.error(e)); ```

Question 52

What is the difference between `promise.all()` and `promise.allSettled()`?

Question 53

# Does the following code block the execution of subsequent code? ``` let response = await fetch("/api/user/profile"); // subsequent code... ```

Answer 53

No. `await` is used to imply that fetch is an asynchronous operation but it does not block subsequent code.

Question 54

Where is the `await` keyword aloud to be used?

Answer 54

Inside `async` functions. For example: ``` async function() { let res = await fetch(...); return res; } ```

Question 55

Does an `async` function return a promise?

Answer 55

Yes

Question 56

Why is it important to write asynchronous front-end applications?

Question 57

Since JS is single threaded, how is it possible for it to write asynchronous programs?

Question 58

What is a callback function?

Answer 58

A callback function is a function that is passed to another function with the expectation that the callback function will be called at a later time. Callback functions used to be the primary way of implementing asynchronous programs in JS. However, in modern days, JS now uses promises

Question 60

Is it possible to add new methods to instances of classes at runtime?

Answer 60

Yes. For example: ``` Complex.prototype.conj = function() { return new Complex(this.r, -this.i); }; ```

Question 61

At a high level, how is inheritance implemented in JS?

Answer 61

Inheritance is implemented through prototype objects. Two objects that inherit the properties of the same prototype object are considered instances of the same class

Question 62

What is the difference between first-class and higher-order functions?

Answer 62

First-class functions are functions that can be used just like any other variable. Higher-order functions are functions that can be passed other functions. All first-class functions are higher-order functions but not all higher-order functions are first-class functions

Question 63

All objects have a prototype but not all objects have a prototype property. What kind of objects have a prototype property?

Answer 63

Functions. This is why all objects created by the same constructor function inherit from the same prototype object and are considered instances of the same class