Skip to main content

# Question 81 - 90

### 81. What is the output?​

- A: `Hi there,`
- B: `Hi there, undefined`
- C: `Hi there, null`
- D: `ReferenceError`

Đáp án

#### Answer: B​

By default, arguments have the value of `undefined`, unless a value has been passed to the function. In this case, we didn't pass a value for the `name` argument. `name` is equal to `undefined` which gets logged.

In ES6, we can overwrite this default `undefined` value with default parameters. For example:

`function sayHi(name = "Lydia") { ... }`

In this case, if we didn't pass a value or if we passed `undefined`, `name` would always be equal to the string `Lydia`

###### 82. What is the output?​

- A: `"🥑"` and `"😍"`
- B: `"🥑"` and `"😎"`
- C: `"😍"` and `"😎"`
- D: `"😎"` and `"😎"`

Đáp án

#### Answer: B​

The value of the `this` keyword is dependent on where you use it. In a method, like the `getStatus` method, the `this` keyword refers to the object that the method belongs to. The method belongs to the `data` object, so `this` refers to the `data` object. When we log `this.status`, the `status` property on the `data` object gets logged, which is `"🥑"`.

With the `call` method, we can change the object to which the `this` keyword refers. In functions, the `this` keyword refers to the the object that the function belongs to. We declared the `setTimeout` function on the global object, so within the `setTimeout` function, the `this` keyword refers to the global object. On the global object, there is a variable called status with the value of `"😎"`. When logging `this.status`, `"😎"` gets logged.

###### 83. What is the output?​

- A: `{ name: "Lydia", age: 21 }`
- B: `{ name: "Lydia", age: 21, city: "Amsterdam" }`
- C: `{ name: "Lydia", age: 21, city: undefined }`
- D: `"Amsterdam"`

Đáp án

#### Answer: A​

We set the variable `city` equal to the value of the property called `city` on the `person` object. There is no property on this object called `city`, so the variable `city` has the value of `undefined`.

Note that we are not referencing the `person` object itself! We simply set the variable `city` equal to the current value of the `city` property on the `person` object.

Then, we set `city` equal to the string `"Amsterdam"`. This doesn't change the person object: there is no reference to that object.

When logging the `person` object, the unmodified object gets returned.

###### 84. What is the output?​

- A: `"Sorry, you're too young."`
- B: `"Yay! You're old enough!"`
- C: `ReferenceError`
- D: `undefined`

Đáp án

#### Answer: C​

Variables with the `const` and `let` keyword are block-scoped. A block is anything between curly brackets (`{ }`). In this case, the curly brackets of the if/else statements. You cannot reference a variable outside of the block it's declared in, a ReferenceError gets thrown.

###### 85. What kind of information would get logged?​

- A: The result of the `fetch` method.
- B: The result of the second invocation of the `fetch` method.
- C: The result of the callback in the previous `.then()`.
- D: It would always be undefined.

Đáp án

#### Answer: C​

The value of `res` in the second `.then` is equal to the returned value of the previous `.then`. You can keep chaining `.then`s like this, where the value is passed to the next handler.

###### 86. Which option is a way to set `hasName` equal to `true`, provided you cannot pass `true` as an argument?​

- A: `!!name`
- B: `name`
- C: `new Boolean(name)`
- D: `name.length`

Đáp án

#### Answer: A​

With `!!name`, we determine whether the value of `name` is truthy or falsy. If name is truthy, which we want to test for, `!name` returns `false`. `!false` (which is what `!!name` practically is) returns `true`.

By setting `hasName` equal to `name`, you set `hasName` equal to whatever value you passed to the `getName` function, not the boolean value `true`.

`new Boolean(true)` returns an object wrapper, not the boolean value itself.

`name.length` returns the length of the passed argument, not whether it's `true`.

###### 87. What's the output?​

- A: `"""`
- B: `"I"`
- C: `SyntaxError`
- D: `undefined`

Đáp án

#### Answer: B​

In order to get a character at a specific index of a string, you can use bracket notation. The first character in the string has index 0, and so on. In this case, we want to get the element with index 0, the character `"I'`, which gets logged.

Note that this method is not supported in IE7 and below. In that case, use `.charAt()`.

###### 88. What's the output?​

- A: `NaN`
- B: `20`
- C: `ReferenceError`
- D: `undefined`

Đáp án

#### Answer: B​

You can set a default parameter's value equal to another parameter of the function, as long as they've been defined before the default parameter. We pass the value `10` to the `sum` function. If the `sum` function only receives 1 argument, it means that the value for `num2` is not passed, and the value of `num1` is equal to the passed value `10` in this case. The default value of `num2` is the value of `num1`, which is `10`. `num1 + num2` returns `20`.

If you're trying to set a default parameter's value equal to a parameter which is defined after (to the right), the parameter's value hasn't been initialized yet, which will throw an error.

###### 89. What's the output?​

- A: `{ default: function default(), name: "Lydia" }`
- B: `{ default: function default() }`
- C: `{ default: "Hello world", name: "Lydia" }`
- D: Global object of `module.js`

Đáp án

#### Answer: A​

With the `import * as name` syntax, we import all exports from the `module.js` file into the `index.js` file as a new object called `data` is created. In the `module.js` file, there are two exports: the default export, and a named export. The default export is a function which returns the string `"Hello World"`, and the named export is a variable called `name` which has the value of the string `"Lydia"`.

The `data` object has a `default` property for the default export, other properties have the names of the named exports and their corresponding values.

###### 90. What's the output?​

- A: `"class"`
- B: `"function"`
- C: `"object"`
- D: `"string"`

Đáp án

#### Answer: C​

Classes are syntactical sugar for function constructors. The equivalent of the `Person` class as a function constructor would be:

Calling a function constructor with `new` results in the creation of an instance of `Person`, `typeof` keyword returns `"object"` for an instance. `typeof member` returns `"object"`.