Skip to main content

# Question 31 - 40

### Q. 31. What is the event.target when clicking the button?​

- A: Outer `div`
- B: Inner `div`
- C: `button`
- D: An array of all nested elements.

💡 Answer

Answer: C

The deepest nested element that caused the event is the target of the event. You can stop bubbling by `event.stopPropagation`

### Q. 32. When you click the paragraph, what's the logged output?​

- A: `p` `div`
- B: `div` `p`
- C: `p`
- D: `div`

💡 Answer

Answer: A

If we click `p`, we see two logs: `p` and `div`. During event propagation, there are 3 phases: capturing, target, and bubbling. By default, event handlers are executed in the bubbling phase (unless you set `useCapture` to `true`). It goes from the deepest nested element outwards.

### Q. 33. What's the output?​

- A: `undefined is 21` `Lydia is 21`
- B: `function` `function`
- C: `Lydia is 21` `Lydia is 21`
- D: `Lydia is 21` `function`

💡 Answer

Answer: D

With both, we can pass the object to which we want the `this` keyword to refer to. However, `.call` is also executed immediately!

`.bind.` returns a copy of the function, but with a bound context! It is not executed immediately.

### Q. 34. What's the output?​

- A: "object"
- B: "number"
- C: "function"
- D: "undefined"

💡 Answer

Answer: B

The `sayHi` function returns the returned value of the immediately invoked function expression (IIFE). This function returned `0`, which is type `"number"`.

FYI: there are only 7 built-in types: `null`, `undefined`, `boolean`, `number`, `string`, `object`, and `symbol`. `"function"` is not a type, since functions are objects, it's of type `"object"`.

### Q. 35. Which of these values are falsy?​

- A: 0, '', undefined
- B: 0, new Number(0), '', new Boolean(false), undefined
- C: 0, '', new Boolean(false), undefined
- D: All of them are falsy

💡 Answer

Answer: A

There are 8 falsy values:

- `undefined`
- `null`
- `NaN`
- `false`
- `''` (empty string)
- `0`
- `-0`
- `0n` (BigInt(0))

Function constructors, like `new Number` and `new Boolean` are truthy.

### Q. 36. What's the output?​

- A: "number"
- B: "string"
- C: "object"
- D: "undefined"

💡 Answer

Answer: B

`typeof 1` returns `"number"`.

`typeof "number"` returns `"string"`

### Q. 37. What's the output?​

- A: [1, 2, 3, null x 7, 11]
- B: [1, 2, 3, 11]
- C: [1, 2, 3, empty x 7, 11]
- D: SyntaxError

💡 Answer

Answer: C

When you set a value to an element in an array that exceeds the length of the array, JavaScript creates something called "empty slots". These actually have the value of `undefined`, but you will see something like:

`[1, 2, 3, empty x 7, 11]`

depending on where you run it (it's different for every browser, node, etc.)

### Q. 38. What's the output?​

- A: 1 undefined 2
- B: undefined undefined undefined
- C: 1 1 2
- D: 1 undefined undefined

💡 Answer

Answer: A

The `catch` block receives the argument `x`. This is not the same `x` as the variable when we pass arguments. This variable `x` is block-scoped.

Later, we set this block-scoped variable equal to `1`, and set the value of the variable `y`. Now, we log the block-scoped variable `x`, which is equal to `1`.

Outside of the `catch` block, `x` is still `undefined`, and `y` is `2`. When we want to `console.log(x)` outside of the `catch` block, it returns `undefined`, and `y` returns `2`.

### Q. 39. Everything in JavaScript is either a...​

- A: primitive or object
- B: function or object
- C: trick question! only objects
- D: number or object

💡 Answer

Answer: A

JavaScript only has primitive types and objects.

Primitive types are `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, and `symbol`.

What differentiates a primitive from an object is that primitives do not have any properties or methods; however, you'll note that `'foo'.toUpperCase()` evaluates to `'FOO'` and does not result in a `TypeError`. This is because when you try to access a property or method on a primitive like a string, JavaScript will implicitly wrap the primitive type using one of the wrapper classes, i.e. `String`, and then immediately discard the wrapper after the expression evaluates. All primitives except for `null` and `undefined` exhibit this behaviour.

### Q. 40. What's the output?​

- A: [0, 1, 2, 3, 1, 2]
- B: [6, 1, 2]
- C: [1, 2, 0, 1, 2, 3]
- D: [1, 2, 6]

💡 Answer

Answer: C

`[1, 2]` is our initial value. This is the value we start with, and the value of the very first `acc`. During the first round, `acc` is `[1,2]`, and `cur` is `[0, 1]`. We concatenate them, which results in `[1, 2, 0, 1]`.

Then, `[1, 2, 0, 1]` is `acc` and `[2, 3]` is `cur`. We concatenate them, and get `[1, 2, 0, 1, 2, 3]`