2018年，最经典的26个JavaScript面试题和答案！

时间 2019-11-06

标签 2018年经典 javascript 面试答案栏目 JavaScript 繁體版

原文原文链接

根据 Stack Overflow 的 2018 年度调查，JavaScript 连续六年成为最经常使用的编程语言。因此咱们必须面对这样的现实，JavaScript 已经成为全栈开发技能的基石，在全栈开发面试中都会不可避免地涉及到与 JavaScript 有关的问题。FullStack.Cafe 汇编了最多见的 JavaScript 面试问题和答案，但愿可以帮助读者找到下一份梦想中的工做。面试

Q1：JavaScript 中的强制转型（coercion）是指什么？

难度：0算法

在 JavaScript 中，两种不一样的内置类型间的转换被称为强制转型。强制转型在 JavaScript 中有两种形式：显式和隐式。数据库

这是一个显式强制转型的例子：编程

var a = "42";
var b = Number( a );
a;                // "42"
b;                // 42 -- 是个数字!

这是一个隐式强制转型的例子：设计模式

var a = "42";
var b = a * 1;    // "42" 隐式转型成 42 
a;                // "42"
b;                // 42 -- 是个数字!

Q2：JavaScript 中的做用域（scope）是指什么？

难度：⭐数组

在 JavaScript 中，每一个函数都有本身的做用域。做用域基本上是变量以及如何经过名称访问这些变量的规则的集合。只有函数中的代码才能访问函数做用域内的变量。promise

同一个做用域中的变量名必须是惟一的。一个做用域能够嵌套在另外一个做用域内。若是一个做用域嵌套在另外一个做用域内，最内部做用域内的代码能够访问另外一个做用域的变量。浏览器

Q3：解释 JavaScript 中的相等性。

难度：⭐安全

JavaScript 中有严格比较和类型转换比较：闭包

严格比较（例如 ===）在不容许强制转型的状况下检查两个值是否相等；
抽象比较（例如 ==）在容许强制转型的状况下检查两个值是否相等。

var a = "42";
var b = 42;
a == b;            // true
a === b;        // false

一些简单的规则：

若是被比较的任何一个值多是 true 或 false，要用 ===，而不是 ==；
若是被比较的任何一个值是这些特定值（0、“”或 []），要用 ===，而不是 ==；
在其余状况下，能够安全地使用 ==。它不只安全，并且在不少状况下，它能够简化代码，而且提高代码可读性。

Q4：解释什么是回调函数，并提供一个简单的例子。

难度：⭐⭐

回调函数是能够做为参数传递给另外一个函数的函数，并在某些操做完成后执行。下面是一个简单的回调函数示例，这个函数在某些操做完成后打印消息到控制台。

function modifyArray(arr, callback) {
  // 对 arr 作一些操做
  arr.push(100);
  // 执行传进来的 callback 函数
  callback();
}

var arr = [1, 2, 3, 4, 5];

modifyArray(arr, function() {
  console.log("array has been modified", arr);
});

Q5：“use strict”的做用是什么？

难度：⭐⭐

use strict 出如今 JavaScript 代码的顶部或函数的顶部，能够帮助你写出更安全的 JavaScript 代码。若是你错误地建立了全局变量，它会经过抛出错误的方式来警告你。例如，如下程序将抛出错误：

function doSomething(val) {
  "use strict"; 
  x = val + 10;
}

它会抛出一个错误，由于 x 没有被定义，并使用了全局做用域中的某个值对其进行赋值，而 use strict 不容许这样作。下面的小改动修复了这个错误：

function doSomething(val) {
  "use strict"; 
  var x = val + 10;
}

Q6：解释 JavaScript 中的 null 和 undefined。

难度：⭐⭐

JavaScript 中有两种底层类型：null 和 undefined。它们表明了不一样的含义：

还没有初始化的东西：undefined；
目前不可用的东西：null。

Q7：编写一个能够执行以下操做的函数。

难度：⭐⭐

var addSix = createBase(6);
addSix(10); // 返回 16
addSix(21); // 返回 27

能够建立一个闭包来存放传递给函数 createBase 的值。被返回的内部函数是在外部函数中建立的，内部函数就成了一个闭包，它能够访问外部函数中的变量，在本例中是变量 baseNumber。

function createBase(baseNumber) {
  return function(N) {
    // 咱们在这里访问 baseNumber，即便它是在这个函数以外声明的。
    // JavaScript 中的闭包容许咱们这么作。
    return baseNumber + N;
  }
}

var addSix = createBase(6);
addSix(10);
addSix(21);

Q8：解释 JavaScript 中的值和类型。

难度：⭐⭐

JavaScript 有类型值，但没有类型变量。JavaScript 提供了如下几种内置类型：
string
number
boolean
null 和 undefined
object
symbol (ES6 中新增的)

Q9：解释事件冒泡以及如何阻止它？

难度：⭐⭐

事件冒泡是指嵌套最深的元素触发一个事件，而后这个事件顺着嵌套顺序在父元素上触发。

防止事件冒泡的一种方法是使用 event.cancelBubble 或 event.stopPropagation()（低于 IE 9）。

Q10：JavaScript 中的 let 关键字有什么用？

难度：⭐⭐

除了能够在函数级别声明变量以外，ES6 还容许你使用 let 关键字在代码块（{..}）中声明变量。

Q11：如何检查一个数字是否为整数？

难度：⭐⭐

检查一个数字是小数仍是整数，可使用一种很是简单的方法，就是将它对 1 进行取模，看看是否有余数。

function isInt(num) {
  return num % 1 === 0;
}

console.log(isInt(4)); // true
console.log(isInt(12.2)); // false
console.log(isInt(0.3)); // false

Q12：什么是 IIFE（当即调用函数表达式）？

难度：⭐⭐⭐

它是当即调用函数表达式（Immediately-Invoked Function Expression），简称 IIFE。函数被建立后当即被执行：

(function IIFE(){
    console.log( "Hello!" );
})();
// "Hello!"

在避免污染全局命名空间时常用这种模式，由于 IIFE（与任何其余正常函数同样）内部的全部变量在其做用域以外都是不可见的。

Q13：如何在 JavaScript 中比较两个对象？

难度：⭐⭐⭐

对于两个非原始值，好比两个对象（包括函数和数组），== 和 === 比较都只是检查它们的引用是否匹配，并不会检查实际引用的内容。

例如，默认状况下，数组将被强制转型成字符串，并使用逗号将数组的全部元素链接起来。因此，两个具备相同内容的数组进行 == 比较时不会相等：

var a = [1,2,3];
var b = [1,2,3];
var c = "1,2,3";

a == c;        // true
b == c;        // true
a == b;        // false

对于对象的深度比较，可使用 deep-equal 这个库，或者本身实现递归比较算法。

Q14：你能解释一下 ES5 和 ES6 之间的区别吗？

难度：⭐⭐⭐

ECMAScript 5（ES5）：ECMAScript 的第 5 版，于 2009 年标准化。这个标准已在全部现代浏览器中彻底实现。
ECMAScript 6（ES6）或 ECMAScript 2015（ES2015）：第 6 版 ECMAScript，于 2015 年标准化。这个标准已在大多数现代浏览器中部分实现。
如下是 ES5 和 ES6 之间的一些主要区别：
箭头函数和字符串插值：

const greetings = (name) => {
    return `hello ${name}`;
}

const greetings = name => `hello ${name}`;

常量

常量在不少方面与其余语言中的常量同样，但有一些须要注意的地方。常量表示对值的“固定引用”。所以，在使用常量时，你实际上能够改变变量所引用的对象的属性，但没法改变引用自己。

const NAMES = [];
NAMES.push("Jim");
console.log(NAMES.length === 1); // true
NAMES = ["Steve", "John"]; // error

块做用域变量。

新的 ES6 关键字 let 容许开发人员声明块级别做用域的变量。let 不像 var 那样能够进行提高。

默认参数值

默认参数容许咱们使用默认值初始化函数。若是省略或未定义参数，则使用默认值，也就是说 null 是有效值。

// 基本语法
function multiply (a, b = 2) {
   return a * b;
}
multiply(5); // 10

类定义和继承

ES6 引入了对类（关键字 class）、构造函数（关键字 constructor）和用于继承的 extend 关键字的支持。

for…of 操做符

for…of 语句将建立一个遍历可迭代对象的循环。

用于对象合并的 Spread 操做

const obj1 = { a: 1, b: 2 }
const obj2 = { a: 2, c: 3, d: 4}
const obj3 = {...obj1, ...obj2}

promise

promise 提供了一种机制来处理异步操做结果。你可使用回调来达到一样的目的，可是 promise 经过方法连接和简洁的错误处理带来了更高的可读性。

const isGreater = (a, b) => {
return new Promise ((resolve, reject) => {
  if(a > b) {
    resolve(true)
  } else {
    reject(false)
  }
  })
}
isGreater(1, 2)
.then(result => {
  console.log('greater')
})
.catch(result => {
  console.log('smaller')
})

模块导出和导入

const myModule = { x: 1, y: () => { console.log('This is ES5') }}
export default myModule;

import myModule from './myModule';

问题 15：解释 JavaScript 中“undefined”和“not defined”之间的区别。

难度：⭐⭐⭐

在 JavaScript 中，若是你试图使用一个不存在且还没有声明的变量，JavaScript 将抛出错误“var name is not defined”，让后脚本将中止运行。但若是你使用 typeof undeclared_variable，它将返回 undefined。

在进一步讨论以前，先让咱们理解声明和定义之间的区别。

“var x”表示一个声明，由于你没有定义它的值是什么，你只是声明它的存在。

var x; // 声明 x
console.log(x); // 输出: undefined

“var x = 1”既是声明又是定义（咱们也能够说它是初始化），x 变量的声明和赋值相继发生。在 JavaScript 中，每一个变量声明和函数声明都被带到了当前做用域的顶部，而后进行赋值，这个过程被称为提高（hoisting）。

当咱们试图访问一个被声明但未被定义的变量时，会出现 undefined 错误。

var x; // 声明
if(typeof x === 'undefined') // 将返回 true

当咱们试图引用一个既未声明也未定义的变量时，将会出现 not defined 错误。

console.log(y);  // 输出: ReferenceError: y is not defined

Q16：匿名和命名函数有什么区别？

难度：⭐⭐⭐

var foo = function() { // 赋给变量 foo 的匿名函数
    // ..
};

var x = function bar(){ // 赋给变量 x 的命名函数 bar
    // ..
};

foo(); // 实际执行函数
x();

Q17：Javascript 中的“闭包”是什么？举个例子？

难度：⭐⭐⭐⭐

闭包是在另外一个函数（称为父函数）中定义的函数，而且能够访问在父函数做用域中声明和定义的变量。

闭包能够访问三个做用域中的变量：

在本身做用域中声明的变量；
在父函数中声明的变量；
在全局做用域中声明的变量。

var globalVar = "abc";

// 自调用函数
(function outerFunction (outerArg) { // outerFunction 做用域开始
  // 在 outerFunction 函数做用域中声明的变量
  var outerFuncVar = 'x';    
  // 闭包自调用函数
  (function innerFunction (innerArg) { // innerFunction 做用域开始
    // 在 innerFunction 函数做用域中声明的变量
    var innerFuncVar = "y";
    console.log(         
      "outerArg = " + outerArg + "\n" +
      "outerFuncVar = " + outerFuncVar + "\n" +
      "innerArg = " + innerArg + "\n" +
      "innerFuncVar = " + innerFuncVar + "\n" +
      "globalVar = " + globalVar);
  // innerFunction 做用域结束
  })(5); // 将 5 做为参数
// outerFunction 做用域结束
})(7); // 将 7 做为参数

innerFunction 是在 outerFunction 中定义的闭包，能够访问在 outerFunction 做用域内声明和定义的全部变量。除此以外，闭包还能够访问在全局命名空间中声明的变量。

上述代码的输出将是：

outerArg = 7
outerFuncVar = x
innerArg = 5
innerFuncVar = y
globalVar = abc

Q18：如何在 JavaScript 中建立私有变量？

难度：⭐⭐⭐⭐

要在 JavaScript 中建立没法被修改的私有变量，你须要将其建立为函数中的局部变量。即便这个函数被调用，也没法在函数以外访问这个变量。例如：

function func() {
  var priv = "secret code";
}

console.log(priv); // throws error

要访问这个变量，须要建立一个返回私有变量的辅助函数。

function func() {
  var priv = "secret code";
  return function() {
    return priv;
  }
}

var getPriv = func();
console.log(getPriv()); // => secret code

Q19：请解释原型设计模式。

难度：⭐⭐⭐⭐

原型模式可用于建立新对象，但它建立的不是非初始化的对象，而是使用原型对象（或样本对象）的值进行初始化的对象。原型模式也称为属性模式。

原型模式在初始化业务对象时很是有用，业务对象的值与数据库中的默认值相匹配。原型对象中的默认值被复制到新建立的业务对象中。

经典的编程语言不多使用原型模式，但做为原型语言的 JavaScript 在构造新对象及其原型时使用了这个模式。

Q20：判断一个给定的字符串是不是同构的。

难度：⭐⭐⭐⭐

若是两个字符串是同构的，那么字符串 A 中全部出现的字符均可以用另外一个字符替换，以便得到字符串 B，并且必须保留字符的顺序。字符串 A 中的每一个字符必须与字符串 B 的每一个字符一对一对应。

paper 和 title 将返回 true。
egg 和 sad 将返回 false。
dgg 和 add 将返回 true。

isIsomorphic("egg", 'add'); // true
isIsomorphic("paper", 'title'); // true
isIsomorphic("kick", 'side'); // false

function isIsomorphic(firstString, secondString) {

  // 检查长度是否相等，若是不相等, 它们不多是同构的
  if (firstString.length !== secondString.length) return false

  var letterMap = {};

  for (var i = 0; i < firstString.length; i++) {
    var letterA = firstString[i],
        letterB = secondString[i];

    // 若是 letterA 不存在, 建立一个 map，并将 letterB 赋值给它
    if (letterMap[letterA] === undefined) {
      letterMap[letterA] = letterB;
    } else if (letterMap[letterA] !== letterB) {
      // 若是 letterA 在 map 中已存在, 但不是与 letterB 对应，
      // 那么这意味着 letterA 与多个字符相对应。
      return false;
    }
  }
  // 迭代完毕，若是知足条件，那么返回 true。
  // 它们是同构的。
  return true;
}

Q21：“Transpiling”是什么意思？

难度：⭐⭐⭐⭐

对于语言中新加入的语法，没法进行 polyfill。所以，更好的办法是使用一种工具，能够将较新代码转换为较旧的等效代码。这个过程一般称为转换（transpiling），就是 transforming + compiling 的意思。

一般，你会将转换器（transpiler）加入到构建过程当中，相似于 linter 或 minifier。如今有不少很棒的转换器可选择：

Babel：将 ES6+ 转换为 ES5
Traceur：将 ES六、ES7 转换为 ES5

Q22：“this”关键字的原理是什么？请提供一些代码示例。

难度：⭐⭐⭐⭐

在 JavaScript 中，this 是指正在执行的函数的“全部者”，或者更确切地说，指将当前函数做为方法的对象。

function foo() {
    console.log( this.bar );
}

var bar = "global";

var obj1 = {
    bar: "obj1",
    foo: foo
};

var obj2 = {
    bar: "obj2"
};

foo();             // "global"
obj1.foo();        // "obj1"
foo.call( obj2 );  // "obj2"
new foo();         // undefined

Q23：如何向 Array 对象添加自定义方法，让下面的代码能够运行？

难度：⭐⭐⭐⭐

var arr = [1, 2, 3, 4, 5];
var avg = arr.average();
console.log(avg);

JavaScript 不是基于类的，但它是基于原型的语言。这意味着每一个对象都连接到另外一个对象（也就是对象的原型），并继承原型对象的方法。你能够跟踪每一个对象的原型链，直到到达没有原型的 null 对象。咱们须要经过修改 Array 原型来向全局 Array 对象添加方法。

Array.prototype.average = function() {
  // 计算 sum 的值
  var sum = this.reduce(function(prev, cur) { return prev + cur; });
  // 将 sum 除以元素个数并返回
  return sum / this.length;
}

var arr = [1, 2, 3, 4, 5];
var avg = arr.average();
console.log(avg); // => 3

Q24：什么是 JavaScript 中的提高操做？

难度：⭐⭐⭐⭐

提高（hoisting）是 JavaScript 解释器将全部变量和函数声明移动到当前做用域顶部的操做。有两种类型的提高：

变量提高——很是少见
函数提高——更常见

不管 var（或函数声明）出如今做用域的什么地方，它都属于整个做用域，而且能够在该做用域内的任何地方访问它。

var a = 2;
foo();                   // 由于`foo()`声明被"提高"，因此可调用

function foo() {
    a = 3;
    console.log( a );    // 3
    var a;               // 声明被"提高"到 foo() 的顶部
}

console.log( a );    // 2

Q25：如下代码输出的结果是什么？

难度：⭐⭐⭐⭐

0.1 + 0.2 === 0.3

这段代码的输出是 false，这是由浮点数内部表示致使的。0.1 + 0.2 并不恰好等于 0.3，实际结果是 0.30000000000000004。解决这个问题的一个办法是在对小数进行算术运算时对结果进行舍入。

Q26：请描述一下 Revealing Module Pattern 设计模式。

难度：⭐⭐⭐⭐⭐

暴露模块模式（Revealing Module Pattern）是模块模式的一个变体，目的是维护封装性并暴露在对象中返回的某些变量和方法。以下所示：

var Exposer = (function() {
  var privateVariable = 10;

  var privateMethod = function() {
    console.log('Inside a private method!');
    privateVariable++;
  }

  var methodToExpose = function() {
    console.log('This is a method I want to expose!');
  }

  var otherMethodIWantToExpose = function() {
    privateMethod();
  }

  return {
      first: methodToExpose,
      second: otherMethodIWantToExpose
  };
})();

Exposer.first();        // 输出: This is a method I want to expose!
Exposer.second();       // 输出: Inside a private method!
Exposer.methodToExpose; // undefined

它的一个明显的缺点是没法引用私有方法。

原文连接：https://www.jianshu.com/p/8c3...