JavaScript九大面试问题集锦，助你顺利通关！

全文共6287字，预计学习时长20分钟或更长

图片来源：Irvan Smith / Unsplash

人们认为JavaScript是最适合初学者的语言。一部分缘由在于JavaScript在互联网中运用普遍，另外一部分缘由在于其自身特性使得即便编写的代码不那么完美依然能够运行：不管是否少了一个分号或是内存管理问题，它都不像许多其余语言那样严格，但在开始学习以前，要确保你已经知道JavaScript的前因后果，包括能够自动完成的事情和“幕后”的操做。

本文将介绍一些面试时关于JavaScript的常见问题，以及一些突发难题。固然，每次面试都是不一样的，你也可能不会碰见这类问题。可是知道的越多，准备的就越充分。

第一部分：突发难题

若是在面试中忽然问到下列问题，彷佛很难回答。即使如此，这些问题在准备中仍发挥做用：它们揭示了JavaScript的一些有趣的功能，并强调在提出编程语言时，首先必须作出的一些决定。

了解有关JavaScript的更多功能，建议访问https://wtfjs.com。

1. 为何Math.max（）小于Math.min（）？

Math.max（）> Math.min（）输出错误这一说法看上去有问题，但其实至关合理。

若是没有给出参数，Math.min（）返回infinity（无穷大），Math.max（）返回-infinity(无穷小)。这只是max（）和min（）方法规范的一部分，但选择背后的逻辑值得深议。了解其中缘由，请看如下代码：

Math.min(1) // 1
Math.min(1, infinity)// 1
Math.min(1, -infinity)// -infinity

若是-infinity（无穷小）做为Math.min（）的默认参数，那么每一个结果都是-infinity（无穷小），这毫无用处！ 然而，若是默认参数是infinity（无穷大），则不管添加任何参数返回都会是该数字 - 这就是咱们想要的运行方式。

2. 为何0.1+0.2不等于0.3

简而言之，这与JavaScript在二进制中存储浮点数的准确程度有关。在Google Chrome控制台中输入如下公式将获得：

0.1 + 0.2// 0.30000000000000004 
0.1 + 0.2 - 0.2// 0.10000000000000003 
0.1 + 0.7// 0.7999999999999999

若是是简单的等式，对准确度没有要求，这不太可能产生问题。可是若是须要测试相等性，即便是简单地应用也会致使使人头疼的问题。解决这些问题，有如下几种方案。

Fixed Point固定点

例如，若是知道所需的最大精度（例如，若是正在处理货币），则可使用整数类型来存储该值。所以，能够存储499而非4.99美圆，并在此基础上执行任何等式，而后可使用相似result =（value / 100）.toFixed（2）的表达式将结果显示给最终用户，该表达式返回一个字符串。

BCD代码

若是精度很是重要，另外一种方法是使用二进制编码的十进制（BCD）格式，可使用BCD库（https://formats.kaitai.io/bcd/javascript.html）访问JavaScript。每一个十进制值分别存储在一个字节（8位）中。鉴于一个字节能够存储16个单独值，而该系统仅使用0-9位，因此这种方法效率低下。可是，若是十分注重精确度，采用何种方法都值得考量。

3. 为何018减017等于3？

018-017返回3实际是静默类型转换的结果。这种状况，讨论的是八进制数。

八进制数简介

你或许知道计算中使用二进制（base-2）和十六进制（base-16）数字系统，可是八进制（base-8）在计算机历史中的地位也举足亲重：在20世纪50年代后期和 20世纪60年代间，八进制被用于简化二进制，削减高昂的制造系统中的材料成本。

不久之后Hexadecimal（十六进制）开始登上历史舞台：

1965年发布的IBM360迈出了从八进制到十六进制的决定性一步。咱们这些习惯八进制的人对这一举措感到震惊！

沃恩·普拉特（Vaughan Pratt）

现在的八进制数

但在现代编程语言中，八进制又有何做用呢？针对某些案例，八进制比十六进制更具优点，由于它不须要任何非数字（使用0-7而不是0-F）。

一个常见用途是Unix系统的文件权限，其中有八个权限变体：

4 2 1

0 - - - no permissions

1 - - x only execute

2 - x - only write

3 - x x write and execute

4 x - - only read

5 x - x read and execute

6 x x - read and write

7 x x x read, write and execute

出于类似的起因，八进制也用于数字显示器。

回到问题自己

在JavaScript中，前缀0将全部数字转换为八进制。可是，八进制中不使用数字8，任何包含8的数字都将自动转换为常规十进制数。

所以，018-017实际上等同于十进制表达式：18-15，由于017使用八进制而018使用十进制。

第二部分：常见问题

图片来源：pexels.com/@divinetechygirl

本节中，将介绍面试中一些更加常见的JavaScript问题。第一次学习JavaScript时，这些问题容易被忽略。但在编写最佳代码时，了解下述问题用处颇大。

4. 函数表达式与函数声明有哪些不一样？

函数声明使用关键字function，后跟函数的名称。相反，函数表达式以var，let或const开头，后跟函数名称和赋值运算符=。请看如下代码：

// Function Declaration
function sum(x, y) 
{  return x + y;
};

// Function Expression: ES5
var sum = function(x, y) {  
return x + y;}; 

// Function Expression: ES6+
const sum = (x, y) => { return x + y };

实际操做中，关键的区别在于函数声明要被提高，而函数表达式则没有。这意味着JavaScript解释器将函数声明移动到其做用域的顶部，所以能够定义函数声明并在代码中的任何位置调用它。相比之下，只能以线性顺序调用函数表达式：必须在调用它以前解释。

现在，许多开发人员偏心函数表达式有以下几个缘由：

· 首先，函数表达式实施更加可预测的结构化代码库。固然，函数声明也可以使用结构化代码库; 只是函数声明让你更容易摆脱凌乱的代码。

· 其次，能够将ES6语法用于函数表达式：这一般更为简洁，let和const能够更好地控制是否从新赋值变量，咱们将在下一个问题中看到。

5. var，let和const有什么区别？

自ES6发布以来，现代语法已进入各行各业，这已经是一个极其常见的面试问题。Var是初版JavaScript中的变量声明关键字。但它的缺点致使在ES6中采用了两个新关键字：let和const。

这三个关键字具备不一样的分配，提高和域 - 所以咱们将单独讨论。

i) 分配

最基本的区别是let和var能够从新分配，而const则不能。这使得const成为不变变量的最佳选择，而且它将防止诸如意外从新分配之类的失误。注意，当变量表示数组或对象时，const确实容许变量改变，只是没法从新分配变量自己。

Let 和var均可从新分配，可是正如如下几点应该明确的那样，若是不是全部状况都要求更改变量，多数选择中，let具备优于var的显著优点。

ii)提高

与函数声明和表达式（如上所述）之间的差别相似，使用var声明的变量老是被提高到它们各自的顶部，而使用const和let声明的变量被提高，可是若是你试图在声明以前访问，将会获得一个TDZ（时间死区）错误。因为var可能更容易出错，例如意外从新分配，所以运算是有用的。请看如下代码：

var x = "global scope";

function foo() {  
var x = "functional scope"; 
 console.log(x);
}

foo(); // "functional scope"
console.log(x); // "global scope"

这里，foo（）和console.log（x）的结果与预期一致。可是，若是去掉第二个变量又会发生什么呢？

var x = "global scope";

function foo() {
  x = "functional scope"; 
 console.log(x);
}foo(); // "functional scope"
console.log(x); // "functional scope"

尽管在函数内定义，但x =“functional scope”已覆盖全局变量。须要重复关键字var来指定第二个变量x仅限于foo（）。

iii) 域

虽然var是function-scoped(函数做用域)，但let和const是block-scoped(块做用域的：通常状况下，Block是大括号{}内的任何代码，包括函数，条件语句和循环。为了阐明差别，请看如下代码：

var a = 0;
let b = 0;
const c = 0;
if (true) { 
 var a = 1;
  let b = 1; 
 const c = 1;
}
console.log(a); // 1
console.log(b); // 0
console.log(c); // 0

在条件块中，全局范围的var a已从新定义，但全局范围的let b和const c则没有。通常而言，确保本地任务保持在本地执行，将使代码更加清晰，减小出错。

6. 若是分配不带关键字的变量会发生什么？

若是不使用关键字定义变量，又会如何？从技术上讲，若是x还没有定义，则x = 1是window.x = 1的简写。

要想彻底杜绝这种简写，能够编写严格模式，——在ES5中介绍过——在文档顶部或特定函数中写use strict。后，当你尝试声明没有关键字的变量时，你将收到一条报语法错误：Uncaught SyntaxError：Unexpected indentifier。

7. 面向对象编程（OOP）和函数式编程（FP）之间的区别是什么？

JavaScript是一种多范式语言，即它支持多种不一样的编程风格，包括事件驱动，函数和面向对象。

编程范式各有不一样，但在当代计算中，函数编程和面向对象编程最为流行 - 而JavaScript两种均可执行。

面向对象编程

OOP以“对象”这一律念为基础的数据结构，包含数据字段（JavaScript称为类）和程序(JavaScript中的方法)。

一些JavaScript的内置对象包括Math（用于random，max和sin等方法），JSON（用于解析JSON数据）和原始数据类型，如String，Array，Number和Boolean。

不管什么时候采用的内置方法，原型或类，本质上都在使用面向对象编程。

函数编程

FP（函数编程）以“纯函数”的概念为基础，避免共享状态，可变数据和反作用。这可能看起来像不少术语，但可能已经在代码中建立了许多纯函数。

输入相同数据，纯函数老是返回相同的输出。这种方式没有反作用：除了返回结果以外，例如登陆控制台或修改外部变量等都不会发生。

至于共享状态，这里有一个简单的例子，即便输入是相同的，状态仍能够改变函数的输出。设置一个具备两个函数的代码：一个将数字加5，另外一个将数字乘以5。

const num = { 
val: 1
};const add5 = () => num.val += 5;
const multiply5 = () => num.val *= 5;

若是先调用add5在调用乘以5，则总体结果为30。可是若是以相反的方式执行函数并记录结果，则输出为10，与以前结果不一致。

这违背了函数式编程的原理，由于函数的结果因Context调用方法而异。 从新编写上面的代码，以便结果更易预测：

const num = { 
val: 1
};
const add5 = () => Object.assign({}, num, {val: num.val + 5}); const multiply5 = 
() => Object.assign({}, num, {val: num.val * 5});

如今，num.val的值仍然为1，不管Context调用的方法如何，add5（num）和multiply5（num）将始终输出相同的结果。

8. 命令式和声明性编程之间有什么区别？

关于命令式编程和声明式编程的区别，能够以OOP（面向对象编程）和FP（函数式编程）为参考。

这两种是描述多种不一样编程范式共有特征的归纳性术语。FP（函数式编程）是声明性编程的一个范例，而OOP（面向对象编程）是命令式编程的一个范例。

从基本的意义层面，命令式编程关注的是如何作某事。它以最基本的方式阐明了步骤，并以for和while循环，if和switch陈述句等为特征。

const sumArray = array => {
  let result = 0; 
 for (let i = 0; i < array.length; i++) { 
    result += array[i] 
 }; 
 return result;
}

相比之下，声明性编程关注的是作什么，它经过依赖表达式将怎样作抽出来。这一般会产生更简洁的代码，可是在规模上，因为透明度低，调试会更加困难。

这是上述的sumArray（）函数的声明方法。

const sumArray = array => { return array.reduce((x, y) => x + y) };

图片来源：pexels.com/@rawpixel

9. 是什么基于原型的继承？

最后，要讲到的是基于原型的继承。面向对象编程有几种不一样的类型，JavaScript使用的是基于原型的继承。该系统经过使用现有对象做为原型，容许重复运行。

即便是首次遇到原型这一律念，使用内置方法时也会遇到原型系统。 例如，用于操做数组的函数（如map，reduce，splice等）都是Array.prototype对象的方法。实际上，数组的每一个实例（使用方括号[]定义，或者 -不常见的 new Array（））都继承自Array.prototype，这就是为何map，reduce和spliceare等方法都默承认用的缘由。

几乎全部内置对象都是如此，例如字符串和布尔运算：只有少数，如Infinity，NaN，null和undefined等没有类或方法。

在原型链的末尾，能发现 Object.prototype，几乎JavaScript中的每一个对象都是Object的一个实例。好比Array. prototype和String. prototype都继承了Object.prototype的类和方法。

要想对使用prototype syntax的对象添加类和方法，只需将对象做为函数启动，并使用prototype关键字添加类和方法：

funcion Person() {};
Person.prototype.forename = "John";
Person.prototype.surname = "Smith";

是否应该覆盖或扩展原型运算？

可使用与建立扩展prototypes一样的方式改变内置运算，可是大多数开发人员（以及大多数公司）不会建议这样作。

若是但愿多个对象进行一样的运算，能够建立一个自定义对象（或定义你本身的“类”或“子类”），这些对象继承内置原型而不改变原型自己。若是打算与其余开发人员合做，他们对JavaScript的默认行为有必定的预期，编辑此默认行为很容易致使出错。

总的来讲，这些问题可以帮助你更好理解JavaScript，包括其核心功能和其余不为人知的功能 ，而且望能助你为下次的面试作好准备。

留言 点赞 关注

咱们一块儿分享AI学习与发展的干货
欢迎关注全平台AI垂类自媒体 “读芯术”

（添加小编微信：dxsxbb，加入读者圈，一块儿讨论最新鲜的人工智能科技哦～）