###### 1.输出是什么？
```javascript
function sayHi() {
console.log(name)
console.log(age)
var name = 'Lydia'
let age = 21
}
sayHi()
```
- A: `Lydia`和 `undefined`
- B: `Lydia`和 `ReferenceError`
- C: `ReferenceError`和 `21`
- D: `undefined`和 `ReferenceError`
答案
####答案: D
在函数内部，我们首先通过`var`关键字声明了 `name` 变量。这意味着变量被提升了（内存空间在创建阶段就被设置好了），直到程序运行到定义变量位置之前默认值都是 `undefined`。因为当我们打印 `name` 变量时还没有执行到定义变量的位置，因此变量的值保持为 `undefined`。
通过`let`和 `const` 关键字声明的变量也会提升，但是和 `var` 不同，它们不会被初始化。在我们声明（初始化）之前是不能访问它们的。这个行为被称之为暂时性死区。当我们试图在声明之前访问它们时，JavaScript 将会抛出一个 `ReferenceError` 错误。
###### 2.输出是什么？
```javascript
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`和 `0 1 2`
- B: `0 1 2`和 `3 3 3`
- C: `3 3 3`和 `0 1 2`
####答案: C
由于JavaScript的事件循环，`setTimeout` 回调会在*遍历结束后*才执行。因为在第一个遍历中遍历 `i` 是通过 `var` 关键字声明的，所以这个值是全局作用域下的。在遍历过程中，我们通过一元操作符 `++` 来每次递增 `i` 的值。当 `setTimeout` 回调执行的时候，`i` 的值等于 3。
在第二个遍历中，遍历`i`是通过 `let` 关键字声明的：通过 `let` 和 `const` 关键字声明的变量是拥有块级作用域（指的是任何在 {} 中的内容）。在每次的遍历过程中，`i` 都有一个新值，并且每个值都在循环内的作用域中。
###### 3.输出是什么？
```javascript
const shape = {
radius: 10,
diameter() {
return this.radius * 2
},
perimeter: () => 2 * Math.PI * this.radius
}
shape.diameter()
shape.perimeter()
```
- A: `20` and `62.83185307179586`
- B: `20` and `NaN`
- C: `20` and `63`
- D: `NaN` and `63`
####答案: B
注意`diameter`的值是一个常规函数，但是 `perimeter` 的值是一个箭头函数。
对于箭头函数，`this`关键字指向的是它当前周围作用域（简单来说是包含箭头函数的常规函数，如果没有常规函数的话就是全局对象），这个行为和常规函数不同。这意味着当我们调用 `perimeter` 时，`this` 不是指向 `shape` 对象，而是它的周围作用域（在例子中是 `window`）。
在`window`中没有 `radius` 这个属性，因此返回 `undefined`。
###### 4.输出是什么？
```javascript
;+true
!'Lydia'
```
- A: `1` and `false`
- B: `false` and `NaN`
- C: `false` and `false`
####答案: A
一元操作符加号尝试将bool转为 number。`true` 转换为 number 的话为 `1`，`false` 为 `0`。
字符串`'Lydia'`是一个真值，真值取反那么就返回 `false`。
###### 5.哪一个是无效的？
```javascript
const bird = {
size: 'small'
}
const mouse = {
name: 'Mickey',
small: true
}
```
- A: `mouse.bird.size`
- B: `mouse[bird.size]`
- C: `mouse[bird["size"]]`
- D: All of them are valid
####答案: A
在JavaScript中，所有对象的 keys 都是字符串（除非对象是 Symbol）。尽管我们可能不会定义它们为字符串，但它们在底层总会被转换为字符串。
当我们使用括号语法时（[]），JavaScript 会解释（或者 unboxes）语句。它首先看到第一个开始括号 `[` 并继续前进直到找到结束括号 `]`。只有这样，它才会计算语句的值。
`mouse[bird.size]`：首先计算 `bird.size`，这会得到 `small`。`mouse["small"]` 返回 `true`。
然后使用点语法的话，上面这一切都不会发生。`mouse`没有 `bird` 这个 key，这也就意味着 `mouse.bird` 是 `undefined`。然后当我们使用点语法 `mouse.bird.size` 时，因为 `mouse.bird` 是 `undefined`，这也就变成了 `undefined.size`。这个行为是无效的，并且会抛出一个错误类似 `Cannot read property "size" of undefined`。
###### 6.输出是什么？
```javascript
let c = { greeting: 'Hey!' }
let d
d = c
c.greeting = 'Hello'
console.log(d.greeting)
```
- A: `Hello`
- B: `undefined`
- C: `ReferenceError`
- D: `TypeError`
####答案: A
在JavaScript中，当设置两个对象彼此相等时，它们会通过*引用*进行交互。
首先，变量`c`的值是一个对象。接下来，我们给 `d` 分配了一个和 `c` 对象相同的引用。
因此当我们改变其中一个对象时，其实是改变了所有的对象。
###### 7.输出是什么？
```javascript
let a = 3
let b = new Number(3)
let c = 3
console.log(a == b)
console.log(a === b)
console.log(b === c)
```
- A: `true` `false` `true`
- B: `false` `false` `true`
- C: `true` `false` `false`
- D: `false` `true` `true`
####答案: C
`new Number()`是一个内建的函数构造器。虽然它看着像是一个 number，但它实际上并不是一个真实的 number：它有一堆额外的功能并且它是一个对象。
当我们使用`==`操作符时，它只会检查两者是否拥有相同的*值*。因为它们的值都是 `3`，因此返回 `true`。
然后，当我们使用`===`操作符时，两者的值以及*类型*都应该是相同的。`new Number()` 是一个对象而不是 number，因此返回 `false`。
###### 8.输出是什么？
```javascript
class Chameleon {
static colorChange(newColor) {
this.newColor = newColor
return this.newColor
}
constructor({ newColor = 'green' } = {}) {
this.newColor = newColor
}
}
const freddie = new Chameleon({ newColor: 'purple' })
freddie.colorChange('orange')
```
- A: `orange`
- B: `purple`
- C: `green`
- D: `TypeError`
####答案: D
`colorChange`是一个静态方法。静态方法被设计为只能被创建它们的构造器使用（也就是 `Chameleon`），并且不能传递给实例。因为 `freddie` 是一个实例，静态方法不能被实例使用，因此抛出了 `TypeError` 错误。
###### 9.输出是什么？
```javascript
let greeting
greetign = {} // Typo!
console.log(greetign)
```
- A: `{}`
- B: `ReferenceError: greetign is not defined`
- C: `undefined`
####答案: A
代码打印出了一个对象，这是因为我们在全局对象上创建了一个空对象！当我们将`greeting`写错成 `greetign` 时，JS 解释器实际在上浏览器中将它视为 `global.greetign = {}` （或者 `window.greetign = {}`）。
为了避免这个为题，我们可以使用`"use strict"。这能确保当你声明变量时必须赋值。
###### 10.当我们这么做时，会发生什么？
```javascript
function bark() {
console.log('Woof!')
}
bark.animal = 'dog'
```
- A: Nothing, this is totally fine!
- B: `SyntaxError`. You cannot add properties to a function this way.
- C: `undefined`
- D: `ReferenceError`
####答案: A
这在JavaScript中是可以的，因为函数是对象！（除了基本类型之外其他都是对象）
函数是一个特殊的对象。你写的这个代码其实不是一个实际的函数。函数是一个拥有属性的对象，并且属性也可被调用。
###### 11.输出是什么？
```javascript
function Person(firstName, lastName) {
this.firstName = firstName;
this.lastName = lastName;
}
const member = new Person("Lydia", "Hallie");
Person.getFullName = function () {
return `${this.firstName} ${this.lastName}`;
}
console.log(member.getFullName());
```
- A: `TypeError`
- B: `SyntaxError`
- C: `Lydia Hallie`
- D: `undefined` `undefined`
####答案: A
你不能像常规对象那样，给构造函数添加属性。如果你想一次性给所有实例添加特性，你应该使用原型。因此本例中，使用如下方式：
```js
Person.prototype.getFullName = function () {
return `${this.firstName} ${this.lastName}`;
}
```
这才会使`member.getFullName()`起作用。为什么这么做有益的？假设我们将这个方法添加到构造函数本身里。也许不是每个 `Person` 实例都需要这个方法。这将浪费大量内存空间，因为它们仍然具有该属性，这将占用每个实例的内存空间。相反，如果我们只将它添加到原型中，那么它只存在于内存中的一个位置，但是所有实例都可以访问它！
###### 12.输出是什么？
```javascript
function Person(firstName, lastName) {
this.firstName = firstName
this.lastName = lastName
}
const lydia = new Person('Lydia', 'Hallie')
const sarah = Person('Sarah', 'Smith')
console.log(lydia)
console.log(sarah)
```
- A: `Person {firstName: "Lydia", lastName: "Hallie"}` and `undefined`
- B: `Person {firstName: "Lydia", lastName: "Hallie"}` and `Person {firstName: "Sarah", lastName: "Smith"}`
- C: `Person {firstName: "Lydia", lastName: "Hallie"}` and `{}`
- D:`Person {firstName: "Lydia", lastName: "Hallie"}` and `ReferenceError`
####答案: A
对于`sarah`，我们没有使用 `new` 关键字。当使用 `new` 时，`this` 引用我们创建的空对象。当未使用 `new` 时，`this` 引用的是**全局对象**（global object）。
我们说`this.firstName`等于 `"Sarah"`，并且 `this.lastName` 等于 `"Smith"`。实际上我们做的是，定义了 `global.firstName = 'Sarah'` 和 `global.lastName = 'Smith'`。而 `sarah` 本身是 `undefined`。
###### 13.事件传播的三个阶段是什么？
- A: Target > Capturing > Bubbling
- B: Bubbling > Target > Capturing
- C: Target > Bubbling > Capturing
- D: Capturing > Target > Bubbling
####答案: D
在**捕获**（capturing）阶段中，事件从祖先元素向下传播到目标元素。当事件达到**目标**（target）元素后，**冒泡**（bubbling）才开始。
###### 14.所有对象都有原型。
- A: true
- B: false
####答案: B
除了**基本对象**（base object），所有对象都有原型。基本对象可以访问一些方法和属性，比如 `.tostring`。这就是为什么你可以使用内置的 JavaScript 方法！所有这些方法在原型上都是可用的。虽然 JavaScript 不能直接在对象上找到这些方法，但 JavaScript 会沿着原型链找到它们，以便于你使用。
###### 15.输出是什么？
```javascript
function sum(a, b) {
return a + b
}
sum(1, '2')
```
- A: `NaN`
- B: `TypeError`
- C: `"12"`
- D: `3`
####答案: C
JavaScript是一种**动态类型语言**：我们不指定某些变量的类型。值可以在你不知道的情况下自动转换成另一种类型，这种类型称为**隐式类型转换**（implicit type coercion）。**Coercion** 是指将一种类型转换为另一种类型。
在本例中，JavaScript将数字 `1` 转换为字符串，以便函数有意义并返回一个值。在数字类型（`1`）和字符串类型（`'2'`）相加时，该数字被视为字符串。我们可以连接字符串，比如 `"Hello" + "World"`，这里发生的是 `"1" + "2"`，它返回 `"12"`。
###### 16.输出是什么？
```javascript
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`
####答案: C
一元**后自增**运算符 `++`：
1.返回值（返回 `0`）
2.值自增（number 现在是 `1`）
一元**前自增**运算符 `++`：
1.值自增（number 现在是 `2`）
2.返回值（返回 `2`）
结果是`0 2 2`.
###### 17.输出是什么？
```javascript
function getPersonInfo(one, two, three) {
console.log(one)
console.log(two)
console.log(three)
}
const person = 'Lydia'
const age = 21
getPersonInfo`${person} is ${age} years old`
```
- A: `"Lydia"` `21` `["", " is ", " years old"]`
- B: `["", " is ", " years old"]` `"Lydia"` `21`
- C: `"Lydia"` `["", " is ", " years old"]` `21`
####答案: B
如果使用标记模板字面量，第一个参数的值总是包含字符串的数组。其余的参数获取的是传递的表达式的值！
###### 18.输出是什么？
```javascript
function checkAge(data) {
if (data === { age: 18 }) {
console.log('You are an adult!')
} else if (data == { age: 18 }) {
console.log('You are still an adult.')
} else {
console.log(`Hmm.. You don't have an age I guess`)
}
}
checkAge({ age: 18 })
```
- A: `You are an adult!`
- B: `You are still an adult.`
- C: `Hmm.. You don't have an age I guess`
####答案: C
在测试相等性时，基本类型通过它们的值（value）进行比较，而对象通过它们的引用（reference）进行比较。JavaScript 检查对象是否具有对内存中相同位置的引用。
题目中我们正在比较的两个对象不是同一个引用：作为参数传递的对象引用的内存位置，与用于判断相等的对象所引用的内存位置并不同。
这也是`{ age: 18 } === { age: 18 }`和 `{ age: 18 } == { age: 18 }` 都返回 `false` 的原因。
###### 19.输出是什么？
```javascript
function getAge(...args) {
console.log(typeof args)
}
getAge(21)
```
- A: `"number"`
- B: `"array"`
- C: `"object"`
- D: `"NaN"`
####答案: C
扩展运算符（`...args`）会返回实参组成的数组。而数组是对象，因此 `typeof args` 返回 `"object"`。
###### 20.输出是什么？
```javascript
function getAge() {
'use strict'
age = 21
console.log(age)
}
getAge()
```
- A: `21`
- B: `undefined`
- C: `ReferenceError`
- D: `TypeError`
####答案: C
使用`"use strict"`，你可以确保不会意外地声明全局变量。我们从来没有声明变量 `age`，因为我们使用 `"use strict"`，它将抛出一个引用错误。如果我们不使用 `"use strict"`，它就会工作，因为属性 `age` 会被添加到全局对象中了。
###### 21.输出是什么？
```javascript
const sum = eval('10*10+5')
```
- A: `105`
- B: `"105"`
- C: `TypeError`
- D: `"10*10+5"`
####答案: A
代码以字符串形式传递进来，`eval`对其求值。如果它是一个表达式，就像本例中那样，它对表达式求值。表达式是 `10 * 10 + 5`。这将返回数字 `105`。
###### 22. cool_secret可访问多长时间？
```javascript
sessionStorage.setItem('cool_secret', 123)
```
- A: Forever, the data doesn't get lost.
- B: When the user closes the tab.
- C: When the user closes the entire browser, not only the tab.
- D: When the user shuts off their computer.
####答案: B
关闭**tab标签页** 后，`sessionStorage` 存储的数据才会删除。
如果使用`localStorage`，那么数据将永远在那里，除非调用了 `localStorage.clear()`。
###### 23.输出是什么？
```javascript
var num = 8
var num = 10
console.log(num)
```
- A: `8`
- B: `10`
- C: `SyntaxError`
- D: `ReferenceError`
####答案: B
使用`var`关键字，你可以用相同的名称声明多个变量。然后变量将保存最新的值。
你不能使用`let`或 `const` 来实现这一点，因为它们是块作用域的。
###### 24.输出是什么？
```javascript
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`
####答案: C
所有对象的键（不包括Symbol）在底层都是字符串，即使你自己没有将其作为字符串输入。这就是为什么 `obj.hasOwnProperty('1')` 也返回 `true`。
对于集合，它不是这样工作的。在我们的集合中没有`'1'`：`set.has('1')` 返回 `false`。它有数字类型为 `1`，`set.has(1)` 返回 `true`。
###### 25.输出是什么？
```javascript
const obj = { a: 'one', b: 'two', a: 'three' }
console.log(obj)
```
- A: `{ a: "one", b: "two" }`
- B: `{ b: "two", a: "three" }`
- C: `{ a: "three", b: "two" }`
- D: `SyntaxError`
####答案: C
如果你有两个名称相同的键，则键会被替换掉。它仍然位于第一个键出现的位置，但是值是最后出现那个键的值。