- 从下列选项中找出正确的打印值
let person = { name:"Lydia" };
const members = [person];
person = null;
console.log(members);
A. null
B. [null]
C. [{}]
D. [{ name:"Lydia" }]
解析：
// - {name:"Lydia"}是对象为引用类型
let person = { name:"Lydia" };
// - 将person的地址(指针)赋值给members
const members = [person];
person = null; // - 改变person的指针
console.log(members); // - [{ name:"Lydia" }]
注：members被赋值的是person的指针；
- 简单数据类型（值类型）：Number，String，undefined，null，Boolean，Symbol
- 复杂数据类型（引用类型）：Function，Array，Object
- 浅拷贝（对象）：把原来对象里面的复杂数据类型地址拷贝给目标对象，修改目标对象会影响被拷贝对象。
- 浅拷贝（数值型）：B自己在栈中重新开辟一个内存空间，将A值赋值给B.
正确答案：D
- 从下列选项中找出正确的打印值
var foo = 1;
( function foo (){
foo = 10;
console.log(foo);
})()
A. f foo(){ foo =10; console.log(foo)}
B. 1
C. 10
D. undefined
解析：
具名的匿名函数，函数名默认指向其本身，且具有只读属性，函数会被当作函数表达式而不是一个标准的函数声明来处理，函数表达式意味着函数被直接绑定在作用域中，意味着foo只能在被自己代表的位置被调用，不会污染全局作用域。
正确答案：A
- 说出下列代码的执行结果，并解释原因
let a = {
name:"jock",
age:20
}
function change (o){
o.age = 24;
o = { name: "alan", age: 30}
return o;
}
let b = change(a);
console.log(b.age);
console.log(a.age);
解析：
// - a为对象——引用类型
let a = {
name:"jock",
age:20
}
function change (o){
o.age = 24; // - a.age = 24
o = { name: "alan", age: 30}
return o;
}
let b = change(a); // - b是change(a)的返回值 b={name: "alan", age: 30}
console.log(b.age); // - 30
console.log(a.age); // - 24
正确答案： 30 24
- 说出下列代码的一个输出结果，并解释原因
var a = 10;
(function (){
console.log(a);
a =5;
console.log(window.a);
var a = 20;
console.log(a);
})()
解析：
var a = 10;
(function (){
// - var a; // - var 隐式做的操作，指声明不赋值
console.log(a); // - undefined - 首先会看当前作用域内有没有变量a
a =5; // -当前作用域的a赋值
console.log(window.a); // - 10
// - var 声明的变量有作用域提升的作用
// - 匿名函数作用域下创建的变量a，不会影响作用域外的变量a
var a = 20; // - 前面声明，此时赋值 a===20
console.log(a); // - 20
})()
正确答案：undefined 10 20
- 从下列选项中找出正确的打印值
const person = { name: "Lydia" };
Object.defineProperty(person,"age",{ value: 21 });
console.log(person);
console.log(Object.keys(person));
A. { name: "Lydia",age: 21},["name","age"]
B. { name: "Lydia",age: 21},["name"]
C. { name: "Lydia"},["name","age"]
D.{ name: "Lydia"},["age"]
解析：
const person = { name: "Lydia" };
Object.defineProperty(person,"age",{ value: 21 }); // - ES5 默认不可枚举、遍历
// Object.defineProperty(person,"age",{ value: 21 ,enumerable:true}); // - 利用 enumerable:true 可以遍历
console.log(person); // - { name: "Lydia",age: 21}
console.log(Object.keys(person)); // - 数组["name"]
注：Object.defineProperty是ES5提供的一种给对象定义属性的方式，定义的属性默认不可以枚举、遍历，不可以删除；可以使用set、get，定义属性时触发get，修改属性值时触发set，利用其可以实现数据双向绑定。
Object.keys返回的是数组，又因Object.defineProperty定义的属性默认不可以枚举、遍历，所以只能返回对象的第一个关键字；如果想要实现遍历，可以利用enumerable:true 实现遍历，如果想要修改或删除，可以利用configurable:true实现。
正确答案：B
- 从下列选项中找出正确的打印值
const settings = {
username:"xiao ming",
level:19,
health:90
};
const data = JSON.stringify(settings,["level","health"]);
console.log(data);
A. "{"level":19,"health":90}"
B. "{"username": "xiao ming"}"
C. "["level","health"]"
D. "{"username":"xiao ming","level":19,"health":90}"
解析：
JSON.stringify(value,replacer)方法将一个 JavaScript 对象或值转换为 JSON 字符串，如果指定了一个 replacer 函数，则可以选择性地替换值，或者指定的 replacer 是数组，则可选择性地仅包含数组指定的属性。
正确答案：A
- 从下列选项中找出正确的打印值
const value = { number: 10 };
const multiply = (x = { ... value }) => {
console.log(x.number *= 2);
};
multiply();
multiply();
multiply(value);
multiply(value);
A. 20,40,80,160
B. 20,40,20,40
C. 20,20,20,40
D. NaN,NaN,20,40
解析：
const value = { number: 10 };
const multiply = (x = { ... value }) => { // - x是形参，‘...’扩展运算符将value的属性展开
console.log(x.number *= 2);
};
// - 没有传参数，x = { number:10 }
multiply(); // - 10*2=20
multiply(); // - 10*2=20
// - 传参数，x = value 指针相同
multiply(value); // - 10*2=20
multiply(value); // - 20*2=40
正确答案：C
- 从下列选项中找出正确的打印值
const add = () => {
const cache = {};
return num => {
if (num in cache) {
return `From cache! ${cache[num]}`;
} else {
const result = num + 10;
cache[num] = result;
return `Calculated! ${result}`;
}
};
};
const addFunction = add();
console.log(addFunction(10));
console.log(addFunction(10));
console.log(addFunction(5 * 2));
A. Calculated! 20 Calculated! 20 Calculated! 20
B. Calculated! 20 From cache! 20 Calculated! 20
C. Calculated! 20 From cache! 20 Form cache! 20
D. Calculated! 20 From cache! 20 Error
解析：
// - 闭包函数：一个函数作为另一个函数的返回值进行输出
const add = () => {
const cache = {};
return num => { // - num = 10 ，num作为key值
if (num in cache) { // 第二次cache有值走if
return `From cache! ${cache[num]}`; // - cache[10]=20
} else { // - 第一次cache无值走else
const result = num + 10; // - 10 + 10 = 20
cache[num] = result; // - cache = { 10:20 }
return `Calculated! ${result}`;
}
};
};
const addFunction = add();
console.log(addFunction(10)); // - Calculated! 20
console.log(addFunction(10)); // - From cache! 20
console.log(addFunction(5 * 2)); // - From cache! 20 ，先将5 * 2运算，之后就同第二次
注：闭包函数定义： 当一个函数的返回值是另外一个函数，而返回的那个函数如果调用了其父函数内部的其它变量，如果返回的这个函数在外部被执行，就产生了闭包。
表现形式：使函数外部能够调用函数内部定义的变量。
正确答案：C
- 从下列选项中找出正确的打印值
function addToList (item, list) {
return list.push(item);
}
const result = addToList("apple",["banana"]);
console.log(result);
A. ['apple','banana']
B. 2
C. true
D. undefined
解析：
function addToList (item, list) {
return list.push(item); // - ['banana','apple'] 长度为2
// - push()方法的返回值: 把指定的值添加到数组后的新长度
}
const result = addToList("apple",["banana"]);
console.log(result);
注：push()方法的返回值：把指定的值添加到数组后的新长度
正确答案：B
- 从下列选项中找出正确的打印值
async function getData () {
return await Promise.resolve("I made it!");
};
const data = getData();
console.log(data);
A. "I made it!"
B. Promise {<resolved>: "I made it!"}
C. Promise {<pending>}
D. undefined
解析：
// - 异步函数 async
async function getData () {
return await Promise.resolve("I made it!");
};
const data = getData(); // - data 等于getData()方法返回的挂起的Promise，此时的Promise并没有解决（没有调用和处理）
console.log(data); // - Promise {<pending>}
// - 挂起状态下通过.then可以调用，执行Promise.resolve()
data.then(res => {
console.log(res); // - I made it!
})
注：promise ES6语法中的异步操作的API，每一个promise包含三种状态 pending（挂起）、 resolve（成功）、 reject（失败）， 而在每一个promise对象包含then 和 catch两个方法，then方法接收一个函数，用于处理resolve成功方法，而catch方法接收一个函数，用于处理reject失败的方法。
正确答案：C
