返回主页

const name = "Lydia";
age = 21;

console.log(delete name);
console.log(delete age);

A: false, true
B: "Lydia", 21
C: true, true
D: undefined, undefined

const person = {
    name: 'Lydia Hallie',
    age: 21
}
[...person] // ['Lydia Hallie', 21]

A: 不需要，对象默认就是可迭代的
B: *[Symbol.iterator]() { for (let x in this) yield* this
[x]}
C: *[Symbol.iterator]() {yield* Object.values(this)}
D: *[Symbol.iterator]() { for (let x in this) yield this }

const set = new Set();

set.add(1);
set.add("Lydia");
set.add({
    name: "Lydia"
});

for (let item of set) {
    console.log(item + 2);
}

A: 3, NaN, NaN
B: 3, 7, NaN
C: 3, Lydia2, [Object object]2
D: "12", Lydia2, [Object object]2

const settings = {
    username: 'lydiahallie',
    level: 19,
    health: 90
};
const data = JSON.stringify(settings, ['level', 'health']);
console.log(data);

A: "{"level":19, "health":90}"
B: "{"username": "lydiahallie"}"
C: "{"level", "health"]"
D: "{"username": "lydiahallie", "level":19, "health":90}"

const name = "Lydia";

console.log(name());

A: SyntaxError
B: ReferenceError
C: TypeError
D: undefined

console.log("🐭" + "🐍");

A: 🐭🐍
B:257548
C:A string containing their code points
D:Error

let newList = [1, 2, 3].push(4);

console.log(newList.push(5));

A: [1,2,3,4,5]
B: [1,2,3,5]
C: [1,2,3,4]
D: Error

let name = "Lydia";

function getName() {
    console.log(name);
    let name = "Sarah";
}
getName();

A: Lydia
B: Sarah
C: undefined
D: ReferenceError

let name = 'Lydia'

function getName()
console.log(name)
}
getName() // Lydia

function getAge(...args) {
    console.log(typeof args);
}
getAge(21);

A: "number"
B: "array"
C: "object"
D: "NaN"

[1, 2, 3, 4].reduce((x, y) => console.log(x, y))

A: 1 2 and 3 3 and 6 4 
B: 1 2 and 2 3 and 3 4
C: 1 undefined and 2 undefined and 3 undefined and 4 undefined
D: 1 2 and undefined 3 and undefined 4 

[1, 2, 3, 4].reduce((x, y) => { console.log(x, y); return x + y; }, 100)

// 打印
// 100 1
// 101 2
// 103 3
// 106 4

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

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

String.prototype.giveLydiaPizza = () => {
  return "Just give Lydia pizza already!";
};

const name = "Lydia";
name.giveLydiaPizza();

A: "Just give Lydia pizza already!"
B: TypeError: not a function
C: SyntaxError
D: undefined

const {
    name: myName
} = {
    name: 'Lydia'
}

console.log(name)

A："Lydia" 
B: "myName" 
C: undefined 
D: ReferenceError

const name = 'Lydia'

console.log(name())

A：SyntaxError 
B: ReferenceError 
C: TypeError 
D: undefined

var status = '🐰'
setTimeout(() => {
    const status = '🐎'
    const data = {
        status: '🐍'
        getStatus() {
            return this.status
        }
    }
    console.log(data.getStatus())
    console.log(data.getStatus.call(this))
}, 0)

A：'🐍' and '🐎'
B: '🐍' and '🐰'
C: '🐎' and '🐰'
D: '🐰' and '🐰'

const person = {
    name: 'Lydia',
    age: 21
}

let city = person.city
city = 'Amsterdam'
console.log(person)

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

function sum(numl, num2 = numl) {
    console.log(numl + num2)
}
sum(10)

A：NaN
B: 20
C: ReferenceError
D: undefined

function test(m = n, n = 2) {
    console.log(m, n)
}
test() // Uncaught ReferenceEmor: Cannot access 
test(3) // 3 2
test(3, 4) // 3 4

function* generatorOne() {
    yield ['a', 'b', 'c'];
}

function* generatorTwo() {
    yield*['a', 'b', 'c'];
}

const one = generatorOne()
const two = generatorTwo()

console.log(one.next().value)
console.log(two.next().value)

A：a and a
B: a and undefined 
C: ['a', 'b', 'c'] and a
D: a and ['a', 'b', 'c']

console.log(one.next().value) // ['a', 'b', 'c'] 
console.log(one.next().value) // undefined

console.log(two.next().value) // 'a'
console.log(two.next().value) // 'b'
console.log(two.next().value) // 'c'
console.log(two.next().value) // underfined

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}

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

const person = {
    name: "Lydia Hallie",
    hobbies: ["coding"]
};

function addHobby(hobby, hobbies = person.hobbies) {
    hobbies.push(hobby);
    return hobbies;
}

addHobby("running", []);
addHobby("dancing");
addHobby("baking", person.hobbies);
console.log(person.hobbies);

A：["coding"]
B: ["coding", "dancing"]
C: ["coding", "dancing", "baking"]
D: ["coding", "running", "dancing","baking"]

const myLifeSummedUp = ["a", "b", "c", "d"];

for (let item in myLifeSummedUp) {
    console.log(item);
}

for (let item of myLifeSummedUp) {
    console.log(item);
}

A：0 1 2 3 and 'a' 'b' 'c' 'd'
B: 'a' 'b' 'c' 'd' and 'a' 'b' 'c' 'd'
C: 0 1 2 3 and 0 1 2 3
D: 0 1 2 3 and {
    0: 'a',
    1: 'b',
    2: 'c',
    3: 'd'
}

{
    0: 'a',
    1: 'b',
    2: 'c',
    3: 'd'
}

const myFunc = ({
    x,
    y,
    z
}) => {
    console.log(x, y, z);
};

myFunc(1, 2, 3);

A：1 2 3
B: {1: 1} {2:2} {3:3}
C: {1: undefined} undefined undefined
D: undefined undefined undefined

const colorConfig = {
    red: true,
    blue: false,
    green: true,
    black: true,
    yellow: false
};

const colors = ["pink", "red", "blue"];

console.log(colorConfig.colors[1]);

A：true
B: false
C: undefined
D: TypeError

const food = ["A", "B", "C", "D"];
const info = {
    favoriteFood: food[0]
};
info.favoriteFood = "E";
console.log(food);

A：['A','B','C','D']
B: ['E','B','C','D']
C: ['E', 'A', 'B','C','D']
D: ReferenceError

const randomValue = 21;

function getInfo() {
    console.log(typeof randomValue);
    const randomValue = "Lydia Hallie";
}
getInfo();

A："number"
B: "string"
C: undefined
D: ReferenceError

const person = {
    name: 'Lydia Hallie',
    address: {
        street: '100 Main St'
    }
};
Object.freeze(person);

A：person.name = "Evan Bacon" 
B: delete person.address
C: person.address.street = "101 Main St" 
D: person.pet = { name: "Mara"}

// module.js
export default () => 'Hello world'
export const name s 'Lydia'
// index.js
import * as data from './module'
console.log(data)

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

// sum.js
export default function sum(x) {
    return x + x;
}

// index.js
import * as sum from './sum';

A：sum(4)
B: sum.sum(4)
C: sum.default(4)
D: 默认导出不用*来导入，只能具名导出 

// info.js
export const name = 'Lydia';
export const age = 21;
export default 'I love JavaScript';

// index.js
import * as info from './info';
console.log(info);

{
    default: 'I love JavaScript',
    name: 'Lydia',
    age: 21
}

{
    default: function sum(x) {
        return x + x
    }
}

function Person(firstName, lastName) {
    this.firstName = firstName;
    this.lastName = lastName;
}
const member = new Person("Lydia', 'Hallie");
Person.getFullName = () => this.firstName + this.lastName；
console.log(member.getFullName());

A: TypeError
B: SyntaxError
C: Lydia Hallie
D: undefined undefined

Person.prototype.getFullName = function() {
    return '${this.firstName} ${this.lastName}';
}

const person = {
    name: 'Lydia',
    age: 21
}
let city = person.city
city = 'Amsterdam'
console.log(person)

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

(() => {
    let x, y;
    try {
        throw new Error。；
    } catch (x) {
        (x = 1), (y = 2);
        console.log(x);
    )
    console.log(x);
    console.log(y);
))()；

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

let num = 1;
const list = ['A', 'B', 'C', 'D'];
console.log(list[(num += 1)]);

A: B
B: C
C: SyntaxError
D: ReferenceError

class Chameleon {
    static colorChange(newColor) {
        this.newColor = newColor;
    }
    constructor({
        newColor = 'green'
    } = {}) {
        this.newColor = newColor;
    }
}
const freddie = new Chameleon({
    newColor: 'purple'
})
freddie.colorChange('orange');

A: orange
B: purple
C: green
D: TypeError

const user = {
    name: 'Lydia',
    age: 21
};
const admin = {
    admin: true,
    ...user
};
console.log(admin);

A: {
    admin: true,
    user: {
        name: "Lydia",
        age: 21
    }
}

B: {
    admin: true,
    name: "Lydia",
    age: 21
}

C: {
    admin: true,
    user: ["Lydia", 21]
}

D: {admin: true}

{
    admin: true,
    name: 'Lydia',
    age: 21
}

let newList = [1, 2, 3].push(4)
console.log(newList.push(5))

A: [1, 2, 3, 4, 5]
B: [1, 2, 3, 5]
C: [1, 2, 3, 4]
D: Error

function compareMembers(person1, person2 = person) {
    if (person1 !== person2) {
        console.log('Not the same!')
    } else {
        console.log('They are the same!')
    }
}
const person = {
    name: 'Lydia'
}
compareMembers(person)

A: Not the same!
B: They are the same!
C: ReferenceError
D: SyntaxError

const box = {
    x: 10,
    y: 20
};
Object.freeze(box);
const shape = box;
shape.x = 100;
console.log(shape);

A: {x: 100, y:20}
B: {x: 10, y:20}
C: {x: 100}
D: ReferenceError

const spookyltems = ['A', 'B', 'C'];
({
    item: spookyItems[3]
} = {
    item: 'D'
});
console.log(spookyltems);

A: ['A', 'B', 'C']
B: ['A', 'B', 'C', 'D']
C: ['A', 'B', 'C', {item: 'D'}]
D: ['A', 'B', 'C', "[object Object]"]

Promise.resolve(5)

A: 5
B: Promise {<pending>: 5}
C: Promise {<resolved>: 5}
D: Error

class Counter {
    #number = 10
    increment() {
        this.#number++
    )
    getNum() {
        return this.#number
    )
}
const counter = new Counter()
counter.increment()
console.log(counter.#number)

A: 10
B: 11
C: undefined
D: SyntaxError

const bird = {
    size: 'small'
}；
const mouse = {
    name: 'Mickey',
    small: true
}；

A: mouse.bird.size
B: mouse[bird.size]
C: mouse[bird["sizen"]]
D: All of them are valid

const one = (false || {} || null)
const two = (null || false || '')
const three = ([] || 0 || true)
console.log(one, two, three)

A: false null []
B: null "" true
C: {} "" []
D: null null true

function sumValues(x, y, z) {
    return x + y + z;
)

A: sumValues([...1, 2, 3])
B: sumValues([...[1, 2, 3]])
C: sumValues(...[1, 2, 3])
D: sumValues([1, 2, 3])

class Dog {
    constructor(name) {
        this.name = name;
    )
}
Dog.prototype.bark = function() {
    console.log(`Woof I am ${this.name}`);
)；
const pet = new Dog("Mara");
pet.bark();
delete Dog.prototype.bark;

pet.bark();

A: "Woof I am Mara", TypeError
B: "Woof I am Mara","Woof I am Mara"
C: "Woof I am Mara", undefined
D: TypeError, TypeError

let num = 1;
const list = ["a", "b", "c", "d"];
console.log(list[(num += 1)]);

A: "b"
B: "c"
C: SyntaxError
D: ReferenceError

const person = {
    name: 'Lydia Hallie'
};
Object.seal（ person）;

A: person.name = "Evan Bacon"
B: person.age = 21
C: delete person.name
D: Object.assign(person,{ age: 21})

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}

const name = "Lydia Hallie";
console.log(!typeof name === 'object');
console.log(!typeof name === 'string');

A: false true
B: true false
C: false false
D: true true