9个常见的JavaScript问题

JavaScript 被认为是对初学者很友好的一门语言。部分缘由在于她在互联网上的普遍使用，还有一部分在于她的一些功能使得编写不完美的代码仍然能够运行（她不像许多其余语言那样严格，你没必要再受分号或者内存管理的折磨)。

本文中，咱们将介绍一些有趣的 JavaScript 问题。

1. 为何 Math.max()小于 Math.min()?

Math.max() > Math.min()返回 false 的事实听起来是荒唐的，但它确实有点意思。

若是没有给出参数，则 Math.min( ) 返回 infinity 而 Math.max( ) 返回 -infinity。这只是 max( ) 和 min( ) 方法规范的一部分，但在这背后有很好的逻辑。要了解缘由，请查看一下代码：

Math.min（1）
// 1
Math.min（1，infinity）
// 1
Math.min（1，-infinity）
// - 无穷大
复制代码

若是 -infinity被认为是 Math.min( )的默认参数 ,那么每一个结果都是infinity,这是毫无心义的!若是默认参数是infinity,则添加任何其余参数将返回该数字——这才是咱们想要的结果。

---

2. 为何 0.1 + 0.2 === 0.3 返回 false？

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

0.1 + 0.2
// 0.30000000000000004
0.1 + 0.2  -  0.2
// 0.10000000000000003
0.1 + 0.7
// 0.7999999999999999 ```
复制代码

若是您在不须要高精度的状况下执行简单的方程式，这不太可能致使问题。可是若是你须要测试相等性，它甚至能够在简单的应用程序中引发麻烦。有一些解决方案。

固定小数点

例如，若是你知道所需的最大精度（例如，若是你正在处理货币），则可使用整数类型来存储该值。所以$4.99 ，您能够存储 499 并执行任何方程式。而后，您可使用result = (value / 100).toFixed(2) 返回字符串的表达式将结果显示给最终用户。

二进制编码的小数

若是精度很是重要，另外一种选择是使用二进制编码的十进制（BCD）格式，您可使用此BCD库在 JavaScript 中访问该格式。每一个十进制值分别存储在一个字节（8 位）中。这是低效的，由于一个字节能够存储 16 个单独的值，而且该系统仅使用值 0-9。可是，若是精度对你的应用很重要，那么可能值得权衡。

---

3. 为何 018 减 017 等于 3 ?

018-017返回的结果3是默认类型转换的结果。在这种状况下，咱们谈论的是八进制数。

八进制数简介

你知道在计算中使用二进制（base-2）和十六进制（base-16）数字系统，可是八进制（base-8）在计算机历史中也占有突出地位：在 20 世纪 50 年代后期和 20 世纪 60 年代，它被用来缩写二进制。在高昂的制造系统中削减材料成本！

以后不久就出现了十六进制（base-8）。

八进制数还有用吗？

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

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

4 2 1 0 - - - 无权限 1 - - x 仅执行 2 - x - 仅写 3 - xx 写入并执行 4 x - - 仅读取 5 x - x 读取并执行 6 xx - 读取和写入 7 xxx 读取，写和执行

出于相似的缘由，它也用于数字显示器。

回到问题

在 JavaScript 中，前缀 0 会将任何数字转换为八进制。可是，8 不会在八进制中使用，而且任何包含 an 的数字 8 都将以静默方式转换为常规十进制数。

所以，018 — 017 实际上至关于十进制表达式 18 — 15 ，由于它 017 是八进制可是 018 十进制。

---

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
}
//函数表达式：ES6 +
const sum =（x，y）=>{ return x + y }
复制代码

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

现在，许多开发人员更喜欢函数表达式，这有几个缘由：

• 首先，函数表达式强制实施更可预测的结构化代码库。固然，结构化代码库也可使用声明; 它只是声明容许您更容易地摆脱凌乱的代码。
• 其次，咱们可使用 ES6 语法函数表达式：这个通常比较简洁，let 并 const 在一个变量是否能够从新分配提供更多的控制与否，咱们将在接下来的问题中看到的。

---

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

var 是初版 JavaScript 中的变量声明关键字。但它的缺点致使在 ES6 中采用了两个新的关键词：let 和 const 。

i）分配

最基本的区别是，let 并 var 同时能够从新分配 const 不能。这是 const 不须要更改的变量的最佳选择，它能够防止意外从新分配等错误。注意，const 它容许变量变异，这意味着若是它表示一个数组或一个对象，它们能够改变。您没法从新分配变量自己。

双方 let 并 var 能够从新分配，而是-由于如下几点应明确-  let 超过了显著的优点 var ，使得它在大多数更好的选择，如不及时救治变量须要改变的全部状况。

ii）变量提高

相似于函数声明和表达式之间的区别（如上所述），使用声明的变量 var 老是被提高到它们各自范围的顶部，而变量声明使用 const 和 let 被提高，可是若是你在声明以前尝试访问它们，那么你将会出现“暂时死区”错误。这是有用的行为，由于 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 呢？

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 是函数做用域的，let 而且 const 是块做用域的：一般，块是花括号内的任何代码{} ，包括函数，条件语句和循环。为了说明差别，请查看如下代码：

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 是一种多范式语言，意味着它支持多种不一样的编程风格，包括事件驱动，功能和面向对象。

有许多不一样的编程范式，但在当代计算中，两种最流行的样式是函数式编程（FP）和面向对象编程（OOP） - 而 JavaScript 能够同时执行这两种操做。

面向对象编程（OOP）

OOP 基于“对象”的概念。这些是包含数据字段的数据结构 - 在 JavaScript 中称为“属性” - 和“方法”。

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

不管什么时候依赖内置的方法，原型或类，实际上你都在使用面向对象的编程。

函数式编程（FP）

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

给定相同的输入，纯函数老是返回相同的输出。它没有反作用：除了返回结果以外，这些都是任何东西，例如记录到控制台或修改外部变量。

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

const num = {
  val：1
}
const add5 =（）=> num.val + = 5
const multiply5 =（）=> num.val * = 5
const multiply5 =（）=> num.val * = 5
复制代码

若是咱们 add5 先调用第一个multiply5，那么整体结果是30 。可是若是咱们以相反的方式调用函数并记录结果，咱们会获得一些不一样的值：10 。

这违背了函数式编程的原理，由于函数的结果根据上下文而不一样。咱们能够从新编写上面的代码，以便结果可预测：

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 ，无关上下文,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) }
复制代码

---

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

最后，咱们来了解基于原型的继承。有几种不一样风格的面向对象编程，JavaScript 使用的是基于 Prototype 的继承。该系统容许经过使用充当“原型”的现有对象来重复行为。

即便原型的想法对你来讲是新的，你也会经过使用内置方法遇到原型系统。例如，使用的功能来操做像map，reduce ，splice等等基于Array.prototype的对象的全部方法。事实上，一个数组的每一个实例（定义使用方括号[]，或使用 new Array()）继承 Array.prototype ，这就是为何相似的方法 map ，reduce 并 splice 默承认用。

一样，几乎全部其余内置对象，如strings和booleans：只有少部分，如Infinity ，NaN ，null和undefined没有属性或方法。

在原型链的末端，咱们发现Object.prototype ，几乎每个对象在JavaScript中是一个 Object.prototype：Array.prototype 和 String.prototype 的实例，它们都继承了 Object.prototype 的属性和方法 。

要使用原型语法向对象添加属性和方法，只需将对象做为函数调用，而后使用 prototype 关键字添加属性和方法：

function Person() {}
Person.prototype.forename = "John"
Person.prototype.surname = "Smith"
复制代码

咱们应该覆盖仍是扩展原型的行为？

能够像咱们建立和扩展咱们本身的原型同样改变内置原型的行为，可是大多数开发人员（以及大多数公司）会建议不要这样作。

若是您但愿多个对象共享相同的行为，你始终能够建立一个自定义对象（或定义你本身的“类”或“子类”），该对象继承自内置原型而不对原型自己进行任何更改。若是您打算与其余开发人员合做，他们对JavaScript的默认行为有必定的指望，编辑此默认行为很容易致使错误。

然而，值得注意的是，并不是全部人都清冽反对这种对内置原型的扩展。例如，请参阅JavaScript 的建立者 Brendan Eich 撰写的这篇文章。在这篇文章中（从 2005 年开始），Eich 建议原型系统其实是部分构建的 - 以使扩展成为可能！