JavaScript 进阶问题列表(各种js代码段66-107)_Javascript

我在我的 instagram 上每天都会发布 javascript 的多选问题，并且同时也会在这个仓库中发布。

从基础到进阶，测试你有多了解 javascript，刷新你的知识，或者帮助你的 coding 面试！ :muscle: :rocket: 我每周都会在这个仓库下更新新的问题。

答案在问题下方的折叠部分，点击即可展开问题。祝你好运

66. 使用哪个构造函数可以成功继承`dog`类？

class dog {
  constructor(name) {
    this.name = name;
  }
};

class labrador extends dog {
  // 1 
  constructor(name, size) {
    this.size = size;
  }
  // 2
  constructor(name, size) {
    super(name);
    this.size = size;
  }
  // 3
  constructor(size) {
    super(name);
    this.size = size;
  }
  // 4 
  constructor(name, size) {
    this.name = name;
    this.size = size;
  }

};

a: 1
b: 2
c: 3
d: 4

答案

答案：b

在子类中，在调用super之前不能访问到this关键字。如果这样做，它将抛出一个referenceerror：1 和 4 将引发一个引用错误。

使用super关键字，需要用给定的参数来调用父类的构造函数。父类的构造函数接收name参数，因此我们需要将name传递给super。

labrador类接收两个参数，name参数是由于它继承了dog，size作为labrador类的额外属性，它们都需要传递给labrador的构造函数，因此使用构造函数 2 正确完成。

67. 输出什么？

// index.js
console.log('running index.js');
import { sum } from './sum.js';
console.log(sum(1, 2));

// sum.js
console.log('running sum.js');
export const sum = (a, b) =&gt; a + b;

a: running index.js, running sum.js, 3
b: running sum.js, running index.js, 3
c: running sum.js, 3, running index.js
d: running index.js, undefined, running sum.js

答案

答案：b

import命令是编译阶段执行的，在代码运行之前。因此这意味着被导入的模块会先运行，而导入模块的文件会后执行。

这是 commonjs 中require（）和import之间的区别。使用require()，您可以在运行代码时根据需要加载依赖项。如果我们使用require而不是import，running index.js，running sum.js，3会被依次打印。

68. 输出什么？

console.log(number(2) === number(2))
console.log(boolean(false) === boolean(false))
console.log(symbol('foo') === symbol('foo'))

a: true, true, false
b: false, true, false
c: true, false, true
d: true, true, true

答案

答案：a

每个symbol都是完全唯一的。传递给symbol的参数只是给symbol的一个描述。symbol的值不依赖于传递的参数。当我们测试相等时，我们创建了两个全新的符号：第一个symbol（'foo'），第二个symbol（'foo'），这两个值是唯一的，彼此不相等，因此返回false。

69. 输出什么？

const name = "lydia hallie"
console.log(name.padstart(13))
console.log(name.padstart(2))

a: "lydia hallie", "lydia hallie"
b: " lydia hallie", " lydia hallie" ("[13x whitespace]lydia hallie", "[2x whitespace]lydia hallie")
c: " lydia hallie", "lydia hallie" ("[1x whitespace]lydia hallie", "lydia hallie")
d: "lydia hallie", "lyd"

答案

答案：c

使用padstart方法，我们可以在字符串的开头添加填充。传递给此方法的参数是字符串的总长度（包含填充）。字符串lydia hallie的长度为12，因此name.padstart（13）在字符串的开头只会插入 1（13 - 12 = 1）个空格。

如果传递给padstart方法的参数小于字符串的长度，则不会添加填充。

70. 输出什么？

console.log("🥑" + "💻");

a: "🥑💻"
b: 257548
c: a string containing their code points
d: error

答案

答案：a

使用+运算符，您可以连接字符串。上述情况，我们将字符串“🥑”与字符串”💻“连接起来，产生”🥑💻“。

71. 如何能打印出`console.log`语句后注释掉的值？

function* startgame() {
  const 答案 = yield "do you love javascript?";
  if (答案 !== "yes") {
    return "oh wow... guess we're gone here";
  }
  return "javascript loves you back ❤️";
}

const game = startgame();
console.log(/* 1 */); // do you love javascript?
console.log(/* 2 */); // javascript loves you back ❤️

a: game.next("yes").value and game.next().value
b: game.next.value("yes") and game.next.value()
c: game.next().value and game.next("yes").value
d: game.next.value() and game.next.value("yes")

答案

答案：c

generator函数在遇到yield关键字时会“暂停”其执行。首先，我们需要让函数产生字符串do you love javascript?，这可以通过调用game.next().value来完成。上述函数的第一行就有一个yield关键字，那么运行立即停止了，yield表达式本身没有返回值，或者说总是返回undefined，这意味着此时变量 答案 为undefined

next方法可以带一个参数，该参数会被当作上一个 yield 表达式的返回值。当我们调用game.next("yes").value时，先前的 yield 的返回值将被替换为传递给next()函数的参数"yes"。此时变量 答案 被赋值为 "yes"，if语句返回false，所以javascript loves you back ❤️被打印。

72. 输出什么？

console.log(string.raw`hello\nworld`);

a: hello world!
b: hello world
c: hello\nworld
d: hello\n world

答案

答案：c

string.raw函数是用来获取一个模板字符串的原始字符串的，它返回一个字符串，其中忽略了转义符（\n，\v，\t等）。但反斜杠可能造成问题，因为你可能会遇到下面这种类似情况：

const path = `c:\documents\projects\table.html`
string.raw`${path}`

这将导致：

"c:documentsprojects able.html"

直接使用string.raw

string.raw`c:\documents\projects\table.html`

它会忽略转义字符并打印：c:\documents\projects\table.html

上述情况，字符串是hello\nworld被打印出。

73. 输出什么？

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

答案

答案：c

异步函数始终返回一个 promise。await仍然需要等待 promise 的解决：当我们调用getdata()并将其赋值给data，此时data为getdata方法返回的一个挂起的 promise，该 promise 并没有解决。

如果我们想要访问已解决的值"i made it!"，可以在data上使用.then()方法：

data.then(res => console.log(res))

这样将打印 "i made it!"

74. 输出什么？

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

答案

答案：b

push()方法返回新数组的长度。一开始，数组包含一个元素（字符串"banana"），长度为 1。在数组中添加字符串"apple"后，长度变为 2，并将从addtolist函数返回。

push方法修改原始数组，如果你想从函数返回数组而不是数组长度，那么应该在 push item之后返回list。

75. 输出什么？

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

答案

答案：b

object.freeze使得无法添加、删除或修改对象的属性（除非属性的值是另一个对象）。

当我们创建变量shape并将其设置为等于冻结对象box时，shape指向的也是冻结对象。你可以使用object.isfrozen检查一个对象是否被冻结，上述情况，object.isfrozen（shape）将返回true。

由于shape被冻结，并且x的值不是对象，所以我们不能修改属性x。x仍然等于10，{x：10，y：20}被打印。

注意，上述例子我们对属性x进行修改，可能会导致抛出 typeerror 异常（最常见但不仅限于严格模式下时）。

76. 输出什么？

const { name: myname } = { name: "lydia" };

console.log(name);

a: "lydia"
b: "myname"
c: undefined
d: referenceerror

答案

答案：d

当我们从右侧的对象解构属性name时，我们将其值lydia分配给名为myname的变量。

使用{name：myname}，我们是在告诉 javascript 我们要创建一个名为myname的新变量，并且其值是右侧对象的name属性的值。

当我们尝试打印name，一个未定义的变量时，就会引发referenceerror。

77. 以下是个纯函数么？

function sum(a, b) {
  return a + b;
}

a: yes
b: no

答案

答案：a

纯函数在相同的输入值时，需产生相同的输出，其输出的结果，与输入值以外的其他隐藏信息或状态无关，也和由 i/o 设备产生的外部输出无关。纯函数不会产生副作用。

纯函数与副作用的定义可参考： https://zh.wikipedia.org/wiki/%e5%89%af%e4%bd%9c%e7%94%a8_(%e8%ae%a1%e7%ae%97%e6%9c%ba%e7%a7%91%e5%ad%a6)

78. 输出什么？

const add = () =&gt; {
  const cache = {};
  return num =&gt; {
    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 from cache! 20
d: calculated! 20 from cache! 20 error

答案

答案：c

add函数是一个记忆函数。通过记忆化，我们可以缓存函数的结果，以加快其执行速度。上述情况，我们创建一个cache对象，用于存储先前返回过的值。

如果我们使用相同的参数多次调用addfunction函数，它首先检查缓存中是否已有该值，如果有，则返回缓存值，这将节省执行时间。如果没有，那么它将计算该值，并存储在缓存中。

我们用相同的值三次调用了addfunction函数：

在第一次调用，num等于10时函数的值尚未缓存，if 语句num in cache返回false，else 块的代码被执行：calculated! 20，并且其结果被添加到缓存对象，cache现在看起来像{10:20}。

第二次，cache对象包含10的返回值。if 语句 num in cache 返回true，from cache! 20被打印。

第三次，我们将5 * 2(值为 10) 传递给函数。cache对象包含10的返回值。if 语句 num in cache 返回true，from cache! 20被打印。

79. 输出什么？

const mylifesummedup = ["☕", "💻", "🍷", "🍫"]

for (let item in mylifesummedup) {
  console.log(item)
}

for (let item of mylifesummedup) {
  console.log(item)
}

a: 0 1 2 3 and "☕" "💻" "🍷" "🍫"
b: "☕" "💻" "🍷" "🍫" and "☕" "💻" "🍷" "🍫"
c: "☕" "💻" "🍷" "🍫" and 0 1 2 3
d: 0 1 2 3 and {0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}

答案

答案：a

通过for-in循环，我们可以遍历一个对象自有的、继承的、可枚举的、非 symbol 的属性。在数组中，可枚举属性是数组元素的“键”，即它们的索引。类似于下面这个对象：

{0: "☕", 1: "💻", 2: "🍷", 3: "🍫"}

其中键则是可枚举属性，因此 0，1，2，3被记录。

通过for-of循环，我们可以迭代可迭代对象（包括 array，map，set，string，arguments等）。当我们迭代数组时，在每次迭代中，不同属性的值将被分配给变量item，因此“☕”，“💻”，“🍷”，“🍫”被打印。

80. 输出什么？

const list = [1 + 2, 1 * 2, 1 / 2]
console.log(list)

a: ["1 + 2", "1 * 2", "1 / 2"]
b: ["12", 2, 0.5]
c: [3, 2, 0.5]
d: [1, 1, 1]

答案

答案：c

数组元素可以包含任何值。数字，字符串，布尔值，对象，数组，null，undefined，以及其他表达式，如日期，函数和计算。

元素将等于返回的值。1 + 2返回3，1 * 2返回'2，'1 / 2返回0.5。

81. 输出什么？

function sayhi(name) {
  return `hi there, ${name}`
}

console.log(sayhi())

a: hi there,
b: hi there, undefined
c: hi there, null
d: referenceerror

答案

答案：b

默认情况下，如果不给函数传参，参数的值将为undefined。上述情况，我们没有给参数name传值。name等于undefined，并被打印。

在 es6 中，我们可以使用默认参数覆盖此默认的undefined值。例如：

function sayhi (name =“lydia”){...}

在这种情况下，如果我们没有传递值或者如果我们传递undefined，name总是等于字符串lydia

82. 输出什么？

var status = "😎"

settimeout(() =&gt; {
  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 "😎"

答案

答案：b

this关键字的指向取决于使用它的位置。在函数中，比如getstatus，this指向的是调用它的对象，上述例子中data对象调用了getstatus，因此this指向的就是data对象。当我们打印this.status时，data对象的status属性被打印，即"🥑"。

使用call方法，可以更改this指向的对象。data.getstatus.call(this)是将this的指向由data对象更改为全局对象。在全局对象上，有一个名为status的变量，其值为”😎“。因此打印this.status时，会打印“😎”。

83. 输出什么？

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"

答案

答案：a

我们将变量city设置为等于person对象上名为city的属性的值。这个对象上没有名为city的属性，因此变量city的值为undefined。

请注意，我们没有引用person对象本身，只是将变量city设置为等于person对象上city属性的当前值。

然后，我们将city设置为等于字符串“amsterdam”。这不会更改 person 对象：没有对该对象的引用。

因此打印person对象时，会返回未修改的对象。

84. 输出什么？

function checkage(age) {
  if (age &lt; 18) {
    const message = "sorry, you're too young."
  } else {
    const message = "yay! you're old enough!"
  }

  return message
}

console.log(checkage(21))

a: "sorry, you're too young."
b: "yay! you're old enough!"
c: referenceerror
d: undefined

答案

答案：c

const和let声明的变量是具有块级作用域的，块是大括号（{}）之间的任何东西，即上述情况if / else语句的花括号。由于块级作用域，我们无法在声明的块之外引用变量，因此抛出referenceerror。

85. 什么样的信息将被打印？

fetch('https://www.website.com/api/user/1')
  .then(res =&gt; res.json())
  .then(res =&gt; console.log(res))

a: fetch方法的结果
b: 第二次调用fetch方法的结果
c: 前一个.then()中回调方法返回的结果
d: 总是undefined

答案

答案：c

第二个.then中res的值等于前一个.then中的回调函数返回的值。你可以像这样继续链接.then，将值传递给下一个处理程序。

86. 哪个选项是将`hasname`设置为`true`的方法，前提是不能将`true`作为参数传递？

function getname(name) {
  const hasname = //
}

a: !!name
b: name
c: new boolean(name)
d: name.length

答案

答案：a

使用逻辑非运算符!，将返回一个布尔值，使用!! name，我们可以确定name的值是真的还是假的。如果name是真实的，那么!name返回false。!false返回true。

通过将hasname设置为name，可以将hasname设置为等于传递给getname函数的值，而不是布尔值true。

new boolean（true）返回一个对象包装器，而不是布尔值本身。

name.length返回传递的参数的长度，而不是布尔值true。

87. 输出什么？

console.log("i want pizza"[0])

a: """
b: "i"
c: syntaxerror
d: undefined

答案

答案：b

可以使用方括号表示法获取字符串中特定索引的字符，字符串中的第一个字符具有索引 0，依此类推。在这种情况下，我们想要得到索引为 0 的元素，字符'i'被记录。

请注意，ie7 及更低版本不支持此方法。在这种情况下，应该使用.charat（）

88. 输出什么？

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

sum(10)

a: nan
b: 20
c: referenceerror
d: undefined

答案

答案：b

您可以将默认参数的值设置为函数的另一个参数，只要另一个参数定义在其之前即可。我们将值10传递给sum函数。如果sum函数只接收 1 个参数，则意味着没有传递num2的值，这种情况下，num1的值等于传递的值10。num2的默认值是num1的值，即10。num1 + num2返回20。

如果您尝试将默认参数的值设置为后面定义的参数，则可能导致参数的值尚未初始化，从而引发错误。比如：

function test(m = n, n = 2) {
	console.log(m, n)
}
test() // uncaught referenceerror: cannot access 'n' before initialization
test(3) // 3 2
test(3, 4) // 3 4

89. 输出什么？

// module.js 
export default () =&gt; "hello world"
export const name = "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

答案

答案：a

使用import * as name语法，我们将module.js文件中所有export导入到index.js文件中，并且创建了一个名为data的新对象。在module.js文件中，有两个导出：默认导出和命名导出。默认导出是一个返回字符串“hello world”的函数，命名导出是一个名为name的变量，其值为字符串“lydia”。

data对象具有默认导出的default属性，其他属性具有指定 exports 的名称及其对应的值。

90. 输出什么？

class person {
  constructor(name) {
    this.name = name
  }
}

const member = new person("john")
console.log(typeof member)

a: "class"
b: "function"
c: "object"
d: "string"

答案

答案：c

类是构造函数的语法糖，如果用构造函数的方式来重写person类则将是：

function person() {
  this.name = name
}

通过new来调用构造函数，将会生成构造函数person的实例，对实例执行typeof关键字将返回"object"，上述情况打印出"object"。

91. 输出什么？

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

答案

答案：d

.push方法返回数组的长度，而不是数组本身！通过将newlist设置为[1,2,3].push(4)，实际上newlist等于数组的新长度：4。

然后，尝试在newlist上使用.push方法。由于newlist是数值4，抛出 typeerror。

92. 输出什么？

function givelydiapizza() {
  return "here is pizza!"
}

const givelydiachocolate = () =&gt; "here's chocolate... now go hit the gym already."

console.log(givelydiapizza.prototype)
console.log(givelydiachocolate.prototype)

a: { constructor: ...} { constructor: ...}
b: {} { constructor: ...}
c: { constructor: ...} {}
d: { constructor: ...} undefined

答案

答案：d

常规函数，例如givelydiapizza函数，有一个prototype属性，它是一个带有constructor属性的对象（原型对象）。然而，箭头函数，例如givelydiachocolate函数，没有这个prototype属性。尝试使用givelydiachocolate.prototype访问prototype属性时会返回undefined。

93. 输出什么？

const person = {
  name: "lydia",
  age: 21
}

for (const [x, y] of object.entries(person)) {
  console.log(x, y)
}

a: name lydia and age 21
b: ["name", "lydia"] and ["age", 21]
c: ["name", "age"] and undefined
d: error

答案

答案：a

object.entries()方法返回一个给定对象自身可枚举属性的键值对数组，上述情况返回一个二维数组，数组每个元素是一个包含键和值的数组：

[['name','lydia'],['age', 21]]

使用for-of循环，我们可以迭代数组中的每个元素，上述情况是子数组。我们可以使用const [x，y]在for-of循环中解构子数组。x等于子数组中的第一个元素，y等于子数组中的第二个元素。

第一个子阵列是[“name”，“lydia”]，其中x等于name，而y等于lydia。第二个子阵列是[“age”，21]，其中x等于age，而y等于21。

94. 输出什么？

function getitems(fruitlist, ...args, favoritefruit) {
  return [...fruitlist, ...args, favoritefruit]
}

getitems(["banana", "apple"], "pear", "orange")

a: ["banana", "apple", "pear", "orange"]
b: [["banana", "apple"], "pear", "orange"]
c: ["banana", "apple", ["pear"], "orange"]
d: syntaxerror

答案

答案：d

... args是剩余参数，剩余参数的值是一个包含所有剩余参数的数组，并且只能作为最后一个参数。上述示例中，剩余参数是第二个参数，这是不可能的，并会抛出语法错误。

function getitems(fruitlist, favoritefruit, ...args) {
  return [...fruitlist, ...args, favoritefruit]
}

getitems(["banana", "apple"], "pear", "orange")

上述例子是有效的，将会返回数组：[ 'banana', 'apple', 'orange', 'pear' ]

95. 输出什么？

function nums(a, b) {
  if
  (a &gt; b)
  console.log('a is bigger')
  else 
  console.log('b is bigger')
  return 
  a + b
}

console.log(nums(4, 2))
console.log(nums(1, 2))

a: a is bigger, 6 and b is bigger, 3
b: a is bigger, undefined and b is bigger, undefined
c: undefined and undefined
d: syntaxerror

答案

答案：b

在 javascript 中，我们不必显式地编写分号 (;)，但是 javascript 引擎仍然在语句之后自动添加分号。这称为自动分号插入。例如，一个语句可以是变量，或者像throw、return、break这样的关键字。

在这里，我们在新的一行上写了一个return语句和另一个值a + b 。然而，由于它是一个新行，引擎并不知道它实际上是我们想要返回的值。相反，它会在return后面自动添加分号。你可以这样看：

  return;
  a + b

这意味着永远不会到达a + b，因为函数在return关键字之后停止运行。如果没有返回值，就像这里，函数返回undefined。注意，在if/else语句之后没有自动插入！

96. 输出什么？

class person {
  constructor() {
    this.name = "lydia"
  }
}

person = class anotherperson {
  constructor() {
    this.name = "sarah"
  }
}

const member = new person()
console.log(member.name)

a: "lydia"
b: "sarah"
c: error: cannot redeclare person
d: syntaxerror

答案

答案：b

我们可以将类设置为等于其他类/函数构造函数。在这种情况下，我们将person设置为anotherperson。这个构造函数的名字是sarah，所以新的person实例member上的 name 属性是sarah。

97. 输出什么？

const info = {
  [symbol('a')]: 'b'
}

console.log(info)
console.log(object.keys(info))

a: {symbol('a'): 'b'} and ["{symbol('a')"]
b: {} and []
c: { a: "b" } and ["a"]
d: {symbol('a'): 'b'} and []

答案

答案：d

symbol类型是不可枚举的。object.keys方法返回对象上的所有可枚举的键属性。symbol类型是不可见的，并返回一个空数组。记录整个对象时，所有属性都是可见的，甚至是不可枚举的属性。

这是symbol的众多特性之一：除了表示完全唯一的值（防止对象意外名称冲突，例如当使用 2 个想要向同一对象添加属性的库时），您还可以隐藏这种方式对象的属性（尽管不完全。你仍然可以使用object.getownpropertysymbols()方法访问 symbol。

98. 输出什么？

const getlist = ([x, ...y]) =&gt; [x, y]
const getuser = user =&gt; { name: user.name, age: user.age }

const list = [1, 2, 3, 4]
const user = { name: "lydia", age: 21 }

console.log(getlist(list))
console.log(getuser(user))

a: [1, [2, 3, 4]] and syntaxerror
b: [1, [2, 3, 4]] and { name: "lydia", age: 21 }
c: [1, 2, 3, 4] and { name: "lydia", age: 21 }
d: error and { name: "lydia", age: 21 }

答案

答案：a

getlist函数接收一个数组作为其参数。在getlist函数的括号之间，我们立即解构这个数组。您可以将其视为：

[x, ...y] = [1, 2, 3, 4]

使用剩余的参数... y，我们将所有剩余参数放在一个数组中。在这种情况下，其余的参数是2，3和4。 y的值是一个数组，包含所有其余参数。在这种情况下，x的值等于1，所以当我们打印[x，y]时，会打印[1，[2,3,4]]。

getuser函数接收一个对象。对于箭头函数，如果只返回一个值，我们不必编写花括号。但是，如果您想从一个箭头函数返回一个对象，您必须将它写在圆括号之间，否则两个花括号之间的所有内容都将被解释为一个块语句！在这种情况下，花括号之间的代码不是有效的 javascript 代码，因此会抛出 syntaxerror。

以下函数将返回一个对象：

const getuser = user => ({ name: user.name, age: user.age })

99. 输出什么？

const name = "lydia"

console.log(name())

a: syntaxerror
b: referenceerror
c: typeerror
d: undefined

答案

答案：c

变量name保存字符串的值，该字符串不是函数，因此无法调用。

当值不是预期类型时，会抛出typeerrors。javascript 期望name是一个函数，因为我们试图调用它。但它是一个字符串，因此抛出typeerror：name is not a function

当你编写了一些非有效的 javascript 时，会抛出语法错误，例如当你把return这个词写成retrun时。当 javascript 无法找到您尝试访问的值的引用时，抛出referenceerrors。

100. 输出什么？

// 🎉✨ this is my 100th question! ✨🎉

const output = `${[] &amp;&amp; 'im'}possible!
you should${'' &amp;&amp; `n't`} see a therapist after so much javascript lol`

a: possible! you should see a therapist after so much javascript lol
b: impossible! you should see a therapist after so much javascript lol
c: possible! you shouldn't see a therapist after so much javascript lol
d: impossible! you shouldn't see a therapist after so much javascript lol

答案

答案：b

[]是一个真值。使用&&运算符，如果左侧值是真值，则返回右侧值。在这种情况下，左侧值[]是一个真值，所以返回im。

""是一个假值。如果左侧值是假的，则不返回任何内容。n't不会被退回。

101.输出什么？

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

答案

答案：c

使用||运算符，我们可以返回第一个真值。如果所有值都是假值，则返回最后一个值。

（false || {} || null）：空对象{}是一个真值。这是第一个（也是唯一的）真值，它将被返回。one等于{}。

（null || false ||“”）：所有值都是假值。这意味着返回传递的值""。two等于""。

（[] || 0 ||“”）：空数组[]是一个真值。这是第一个返回的真值。three等于[]。

102. 依次输出什么？

const mypromise = () =&gt; promise.resolve('i have resolved!')

function firstfunction() {
  mypromise().then(res =&gt; console.log(res))
  console.log('second')
}

async function secondfunction() {
  console.log(await mypromise())
  console.log('second')
}

firstfunction()
secondfunction()

a: i have resolved!, second and i have resolved!, second
b: second, i have resolved! and second, i have resolved!
c: i have resolved!, second and second, i have resolved!
d: second, i have resolved! and i have resolved!, second

答案

答案：d

有了 promise，我们通常会说：当我想要调用某个方法，但是由于它可能需要一段时间，因此暂时将它放在一边。只有当某个值被 resolved/rejected，并且执行栈为空时才使用这个值。

我们可以在async函数中通过.then和await关键字获得该值。尽管我们可以通过.then和await获得 promise 的价值，但是它们的工作方式有所不同。

在 firstfunction中，当运行到mypromise方法时我们将其放在一边，即 promise 进入微任务队列，其他后面的代码（console.log('second')）照常运行，因此second被打印出，firstfunction方法到此执行完毕，执行栈中宏任务队列被清空，此时开始执行微任务队列中的任务，i have resolved被打印出。

在secondfunction方法中，我们通过await关键字，暂停了后面代码的执行，直到异步函数的值被解析才开始后面代码的执行。这意味着，它会等着直到 mypromise 以值i have resolved被解决之后，下一行second才开始执行。

103. 输出什么？

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

答案

答案：c

“+”运算符不仅用于添加数值，还可以使用它来连接字符串。每当 javascript 引擎发现一个或多个值不是数字时，就会将数字强制为字符串。

第一个是数字 1。1 + 2 返回数字 3。

但是，第二个是字符串“lydia”。 “lydia”是一个字符串，2 是一个数字：2 被强制转换为字符串。 “lydia”和“2”被连接起来，产生字符串“lydia2”。

{name：“lydia”}是一个对象。数字和对象都不是字符串，因此将二者都字符串化。每当我们对常规对象进行字符串化时，它就会变成[object object]。与“2”串联的“ [object object]”成为“[object object]2”。

104. 结果是什么？

promise.resolve(5)

a: 5
b: promise {<pending>: 5}
c: promise {<fulfilled>: 5}
d: error

答案

答案：c

我们可以将我们想要的任何类型的值传递promise.resolve，无论是否promise。该方法本身返回带有已解析值的promise ()。如果您传递常规函数，它将是具有常规值的已解决promise。如果你通过了 promise，它将是一个已经 resolved 的且带有传的值的 promise。

上述情况，我们传了数字 5，因此返回一个 resolved 状态的 promise，resolve 值为5

105. 输出什么？

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

答案

答案：b

对象通过引用传递。当我们检查对象的严格相等性（===）时，我们正在比较它们的引用。

我们将“person2”的默认值设置为“person”对象，并将“person”对象作为“person1”的值传递。

这意味着两个值都引用内存中的同一位置，因此它们是相等的。

运行“else”语句中的代码块，并记录they are the same!。

106. 输出什么？

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

答案

答案：d

在 javascript 中，我们有两种访问对象属性的方法：括号表示法或点表示法。在此示例中，我们使用点表示法（colorconfig.colors）代替括号表示法（colorconfig [“colors”]）。

使用点表示法，javascript 会尝试使用该确切名称在对象上查找属性。在此示例中，javascript 尝试在 colorconfig 对象上找到名为 colors 的属性。没有名为“colors”的属性，因此返回“undefined”。然后，我们尝试使用[1]访问第一个元素的值。我们无法对未定义的值执行此操作，因此会抛出cannot read property '1' of undefined。

javascript 解释（或取消装箱）语句。当我们使用方括号表示法时，它会看到第一个左方括号[并一直进行下去，直到找到右方括号]。只有这样，它才会评估该语句。如果我们使用了 colorconfig [colors [1]]，它将返回 colorconfig 对象上 red 属性的值。

107. 输出什么？

console.log('❤️' === '❤️')

a: true
b: false

答案

答案：a

在内部，表情符号是 unicode。heat 表情符号的 unicode 是“u + 2764 u + fe0f”。对于相同的表情符号，它们总是相同的，因此我们将两个相等的字符串相互比较，这将返回 true。


验证码：

JavaScript 进阶问题列表(各种js代码段66-107)

2024年11月25日 • Javascript •我要评论

66. 使用哪个构造函数可以成功继承dog类？

答案：b

67. 输出什么？

答案：b

68. 输出什么？

答案：a

69. 输出什么？

答案：c

70. 输出什么？

答案：a

71. 如何能打印出console.log语句后注释掉的值？

答案：c

72. 输出什么？

答案：c

73. 输出什么？

答案：c

74. 输出什么？

答案：b

75. 输出什么？

答案：b

76. 输出什么？

答案：d

77. 以下是个纯函数么？

答案：a

78. 输出什么？

答案：c

79. 输出什么？

答案：a

80. 输出什么？

答案：c

81. 输出什么？

答案：b

82. 输出什么？

答案：b

83. 输出什么？

答案：a

84. 输出什么？

答案：c

85. 什么样的信息将被打印？

答案：c

86. 哪个选项是将hasname设置为true的方法，前提是不能将true作为参数传递？

答案：a

87. 输出什么？

答案：b

88. 输出什么？

答案：b

89. 输出什么？

答案：a

90. 输出什么？

答案：c

91. 输出什么？

答案：d

92. 输出什么？

答案：d

93. 输出什么？

答案：a

94. 输出什么？

答案：d

95. 输出什么？

答案：b

96. 输出什么？

答案：b

97. 输出什么？

答案：d

98. 输出什么？

答案：a

99. 输出什么？

答案：c

100. 输出什么？

答案：b

101.输出什么？

答案：c

102. 依次输出什么？

答案：d

103. 输出什么？

答案：c

104. 结果是什么？

答案：c

66. 使用哪个构造函数可以成功继承`dog`类？

71. 如何能打印出`console.log`语句后注释掉的值？

86. 哪个选项是将`hasname`设置为`true`的方法，前提是不能将`true`作为参数传递？