For the realization of the game, we have taken as a reference the following Github repository with many interesting questions about JavaScript
https://github.com/lydiahallie/javascript-questions
for (var i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 1);
}
for (let i = 0; i < 3; i++) {
setTimeout(() => console.log(i), 1);
}
- A:
0 1 2
and0 1 2
- B:
0 1 2
and3 3 3
- C:
3 3 3
and0 1 2
Answer
Because of the event queue in JavaScript, the setTimeout
callback function is called after the loop has been executed. Since the variable i
in the first loop was declared using the var
keyword, this value was global. During the loop, we incremented the value of i
by 1
each time, using the unary operator ++
. By the time the setTimeout
callback function was invoked, i
was equal to 3
in the first example.
In the second loop, the variable i
was declared using the let
keyword: variables declared with the let
(and const
) keyword are block-scoped (a block is anything between { }
). During each iteration, i
will have a new value, and each value is scoped inside the loop.
const bird = {
size: 'small',
};
const mouse = {
name: 'Mickey',
small: true,
};
- A:
mouse.bird.size
is not valid - B:
mouse[bird.size]
is not valid - C:
mouse[bird["size"]]
is not valid - D: All of them are valid
Answer
In JavaScript, all object keys are strings (unless it's a Symbol). Even though we might not type them as strings, they are always converted into strings under the hood.
JavaScript interprets (or unboxes) statements. When we use bracket notation, it sees the first opening bracket [
and keeps going until it finds the closing bracket ]
. Only then, it will evaluate the statement.
mouse[bird.size]
: First it evaluates bird.size
, which is "small"
. mouse["small"]
returns true
However, with dot notation, this doesn't happen. mouse
does not have a key called bird
, which means that mouse.bird
is undefined
. Then, we ask for the size
using dot notation: mouse.bird.size
. Since mouse.bird
is undefined
, we're actually asking undefined.size
. This isn't valid, and will throw an error similar to Cannot read property "size" of undefined
.
function sum(a, b) {
return a + b;
}
sum(1, '2');
- A:
NaN
- B:
TypeError
- C:
"12"
- D:
3
Answer
JavaScript is a dynamically typed language: we don't specify what types certain variables are. Values can automatically be converted into another type without you knowing, which is called implicit type coercion. Coercion is converting from one type into another.
In this example, JavaScript converts the number 1
into a string, in order for the function to make sense and return a value. During the addition of a numeric type (1
) and a string type ('2'
), the number is treated as a string. We can concatenate strings like "Hello" + "World"
, so what's happening here is "1" + "2"
which returns "12"
.
let number = 0;
console.log(number++);
console.log(++number);
console.log(number);
- A:
1
1
2
- B:
1
2
2
- C:
0
2
2
- D:
0
1
2
Answer
The postfix unary operator ++
:
- Returns the value (this returns
0
) - Increments the value (number is now
1
)
The prefix unary operator ++
:
- Increments the value (number is now
2
) - Returns the value (this returns
2
)
This returns 0 2 2
.
const obj = { 1: 'a', 2: 'b', 3: 'c' };
const set = new Set([1, 2, 3, 4, 5]);
obj.hasOwnProperty('1');
obj.hasOwnProperty(1);
set.has('1');
set.has(1);
- A:
false
true
false
true
- B:
false
true
true
true
- C:
true
true
false
true
- D:
true
true
true
true
Answer
All object keys (excluding Symbols) are strings under the hood, even if you don't type it yourself as a string. This is why obj.hasOwnProperty('1')
also returns true.
It doesn't work that way for a set. There is no '1'
in our set: set.has('1')
returns false
. It has the numeric type 1
, set.has(1)
returns true
.
[[0, 1], [2, 3]].reduce(
(acc, cur) => {
return acc.concat(cur);
},
[1, 2],
);
- A:
[0, 1, 2, 3, 1, 2]
- B:
[6, 1, 2]
- C:
[1, 2, 0, 1, 2, 3]
- D:
[1, 2, 6]
Answer
[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]
!!null;
!!'';
!!1;
- A:
false
true
false
- B:
false
false
true
- C:
false
true
true
- D:
true
true
false
Answer
null
is falsy. !null
returns true
. !true
returns false
.
""
is falsy. !""
returns true
. !true
returns false
.
1
is truthy. !1
returns false
. !false
returns true
.
const firstPromise = new Promise((res, rej) => {
setTimeout(res, 500, 'one');
});
const secondPromise = new Promise((res, rej) => {
setTimeout(res, 100, 'two');
});
Promise.race([firstPromise, secondPromise]).then(res => console.log(res));
- A:
"one"
- B:
"two"
- C:
"two" "one"
- D:
"one" "two"
Answer
When we pass multiple promises to the Promise.race
method, it resolves/rejects the first promise that resolves/rejects. To the setTimeout
method, we pass a timer: 500ms for the first promise (firstPromise
), and 100ms for the second promise (secondPromise
). This means that the secondPromise
resolves first with the value of 'two'
. res
now holds the value of 'two'
, which gets logged.
const set = new Set([1, 1, 2, 3, 4]);
console.log(set);
- A:
[1, 1, 2, 3, 4]
- B:
[1, 2, 3, 4]
- C:
{1, 1, 2, 3, 4}
- D:
{1, 2, 3, 4}
Answer
The Set
object is a collection of unique values: a value can only occur once in a set.
We passed the iterable [1, 1, 2, 3, 4]
with a duplicate value 1
. Since we cannot have two of the same values in a set, one of them is removed. This results in {1, 2, 3, 4}
.
const emojis = ['✨', '🥑', '😍'];
emojis.map(x => x + '✨');
emojis.filter(x => x !== '🥑');
emojis.find(x => x !== '🥑');
emojis.reduce((acc, cur) => acc + '✨');
emojis.slice(1, 2, '✨');
emojis.splice(1, 2, '✨');
- A:
All of them
- B:
map
reduce
slice
splice
- C:
map
slice
splice
- D:
splice
Answer
With splice
method, we modify the original array by deleting, replacing or adding elements. In this case, we removed 2 items from index 1 (we removed '🥑'
and '😍'
) and added the ✨ emoji instead.
map
, filter
and slice
return a new array, find
returns an element, and reduce
returns a reduced value.