声明
本系列文章内容全部梳理自以下几个来源：
作为一个前端小白，入门跟着这几个来源学习，感谢作者的分享，在其基础上，通过自己的理解，梳理出的知识点，或许有遗漏，或许有些理解是错误的，如有发现，欢迎指点下。
PS：梳理的内容以《JavaScript权威指南》这本书中的内容为主，因此接下去跟 JavaScript 语法相关的系列文章基本只介绍 ES5 标准规范的内容、ES6 等这系列梳理完再单独来讲讲。
正文-运算符
程序中的代码其实就是利用各种运算符来辅助完成各种指令功能，在 JavaScript 中，有一些不同于 Java 中的运算符处理，这次就来讲讲这些运算符。
由于我已经有了 Java 的基础了，本节不会讲基础的运算符介绍，比如算术表达式中的加减乘除取余等、关系表达式中的大于小于等、逻辑表示式中的自增、自减、移位等等，这些基础运算符的含义、用法、优先级这些跟 Java 基本没有区别，所以就不介绍了。
下面着重讲一些在 JavaScript 比较不同的行为的一些运算符：
"+" 运算符
任何数据类型的变量都可以通过 "+" 运算符来进行计算，所以它有一套处理规则，通常要么就是按数字的加法运算处理、要么就是按照字符串的拼接处理，处理规则如下：
- 如果操作数中存在对象类型，先将其按照上节介绍的转换规则，转成原始值；
- 如果操作数已经全部是原始值，此时如果有字符串类型的原始值，那么将两个原始值都转为字符串后，按字符串拼接操作处理；
- 如果操作数已经全部是原始值且没有字符串类型的，那么将操作数都转为数字类型后，按数字的加法处理;
- NaN 加上任意类型的值后都是 NaN.
以上的处理规则是针对于通过 "+" 运算符处理两个操作数的场景，如果一个表达式中存在多个 "+" 运算符，那么分别以优先级计算过程中，每一次计算 "+" 运算符的两个操作数使用上述规则进行处理。
举个例子：
1 + 2 // => 3, 因为操作数都是数字类型的原始值
1 + "2" // => "12"，因为操作数中存在字符串类型的原始值，所以是按字符串拼接来处理
1 + {} // => "1[object Object]"，因为有操作是对象类型，先将其转为原始值，{} 转为原始值为字符串 "[object Object]"，所以将操作数都转为字符串后，按字符串拼接处理
1 + true // => 2，因为两个都是原始值，且没有字符串类型，所以将 true 转为数字类型后是 1，按加法处理
1 + undefined // => NaN，因为 undefined 转为数字类型后为 NaN，NaN 与任何数运算结果都为 NaN
1 + 2 + " dasu" // => "3 dasu"， 因为先计算 1+2=3，然后再计算 3 + " dasu"，所以是 "3 dasu"
1 + (2 + " dasu") // => "12 dasu"，因为先计算 2 + " dasu" = "2 dasu"，再计算 1 + "2 dasu" = "12 dasu"因为 "+" 运算符在编程中很常见，也很常用，而 JavaScript 又是弱类型语言，变量无需声明类型，那么程序中，"+" 运算符的两个操作数究竟是哪两种类型在进行计算，结果又会是什么，这点在心里至少是要明确的。
"==" 和 "===" 相等运算符
"==" 和 "===" 都是用于判断两个操作数是否相等的运算符，但它们是有区别的。
"==" 比较相等的两个操作数会自动进行一些隐式的类型转换后，再进行比较，俗称不严格相等。
"===" 比较相等的两个操作数，不会进行任何类型转换，相等的条件就是类型一样，数值也一样，所以俗称严格相等。
而 "!=" 和 "!==" 自然就是这两个相等运算符的求反运算。下面分别来看看：
"==="
当通过这个运算符来比较两个操作数是否严格相等时，具体规则如下：
- 如果两个操作数的类型不相同，则它们不相等
- 如果其中一个操作数是 NaN 时，则它们不相等（因为 NaN 跟任何数包括它本身都不相等）
- 如果两个操作数都是对象类型，那么只有当两个操作数都指向同一个对象，即它们的引用一样时，它们才相等
- 如果两个操作数都是字符串类型时，当字符串一致时，在某些特殊场景下，比如具有不同编码的 16 位值时，它们也不相等，但大部分情况下，字符串一致是会相等，但要至少清楚不是百分百
- 如果两个操作数都是布尔类型、数字类型、null、undefined，且值都一致时，那它们相等
总之，这里的规则跟 Java 里的相等比较类似，Java 里没有严格不严格之分，它处理的规则就是按照 JavaScript 这里的严格相等来处理，所以大部分比较逻辑可参考 Java。
需要注意的就是，NaN 与任何数包括它本身也不相等、同一个字符串内容可能会有不同的编码值，所以并不是百分百相等。
"=="
这个通常称为不严格相等，当比较是否相等的两个操作数的数据类型不一样时，会尝试先进行转换，然后再进行比较，相比于上面的 "===" 严格相等运算符来说，它其实就是放宽了比较的条件，具体规则如下：
- 如果两个操作数的类型一样，那么规则跟 "===" 一样
- 如果一个类型是 null，另一个类型是 undefined，此时，它们也是相等的
- 如果一个类型是数字，另一个类型是字符串，那么先将字符串转为数字，再进行比较
- 如果一个类型是布尔，先将布尔转成 1（true）或 0（false），然后再根据当前两个类型是否需要再进一步处理再比较
- 如果一个类型是对象，那么先将对象转换成原始值，然后再根据当前两个类型是否需要再进一步处理再比较
总之，"==" 的比较相对于 "===" 会将条件放宽，下面可以看些例子：
null === undefined // => false，两个类型不一样
null == undefined // => true，不严格情况下两者可认为相等
1 == "1" // => true，"1" 转为数字 1 后，再比较
1 == [1] // => true，[1] 先转为字符串 "1"，此时等效于比较 1 == "1"，所以相等
2 == true // => false，因为 true 先转为数字 1，此时等效于比较 2 == 1"&&” 逻辑与
逻辑与就是两个条件都要满足，这点跟 Java 里的逻辑与操作 && 没有任何区别。
但 JavaScript 里的逻辑与 && 操作会更强大，在 Java 里，逻辑与 && 运算符的两个操作数都必须是关系表达式才行，而且整个逻辑与表达式最终的结果只返回 true 或 false。
但在 JavaScript 里，允许逻辑与 && 运算符的两个操作数是任意的表达式，而且整个逻辑与 && 表达式最终返回的值并不是 true 或 false，而是其中某个操作数的值。
什么意思，来看个例子：
x == 0 && y == 0这是最基本的用法，跟 Java 没有任何区别，当且仅当 x 和 y 都为 0 时，返回 true，否则返回 false。
上面那句话，是从这个例子以及延用 Java 那边对逻辑与 && 运算符的理解所进行的解释。
但实际上，在 JavaScript 里，它是这么处理逻辑与 && 运算符的：
- 如果左操作数的值是假值，那么不会触发右操作数的计算，且整个逻辑与 && 表达式返回左操作数的值
- 如果左操作数的值是真值，那么整个逻辑与 && 表达式返回右操作数的值
- 假值真值可以通俗的理解成，上节介绍各种数据类型间的转换规则中，各类型转换为布尔类型的值，转为布尔后为 true，表示这个值为真值。反之，为假值。
所以，按照这种理论，我们再来看看上面那个例子，首先左操作数是个关系表达式：x == 0，如果 x 为 0，这个表达式等于 true，所以它为真值，那么整个逻辑与 && 表达式返回右操作数的值。右操作数也是个关系表达式：y == 0，如果 y 也等于 0，右操作数的值就为 true，所以整个逻辑与 && 表达式就返回 true。
虽然结果一样，但在 JavaScript 里对于逻辑与 && 表达式的解释应该按照第二种，而不是按照第一种的 Java 里的解释。如果还不理解，那么再来看几个例子：
function getName() {
return "dasu"
}
null && getName() //输出 => null，因为左操作数 null 转成布尔是 false，所以它是假值，所以逻辑与 && 直接返回左操作数的值 null
getName && getName() //输出 => "dasu"，因为左操作数是一个函数对象，如果该函数对象被声明定义了，那么转为布尔值就是 true，所以逻辑与 && 表达式返回右操作数的值，右操作数是 getName()，调用了函数，返回了 "dasu"，所以这个就是这个逻辑与 && 表达式的值。第一个逻辑与表达式：null && getName() 会输出 null，是因为左操作数 null 转成布尔是 false，所以它是假值，所以逻辑与 && 直接返回左操作数的值 null。
第二个逻辑与表达式：getName && getName() 会输出 "dasu"，是因为左操作数是一个函数对象，如果该函数对象被声明定义了，那么转为布尔值就是 true，所以逻辑与 && 表达式返回右操作数的值，右操作数是 getName()，调用了函数，返回了 "dasu"，所以这个就是这个逻辑与 && 表达式的值。
所以 JavaScript 里的逻辑与 && 表达式会比 Java 更强大，它有一种应用场景：
应用场景
function queryName(callback) {
//...
//回调处理
callback && callback();
}在 Java 中，我们提供回调机制的处理通常是定义了一个接口，然后接口作为函数的参数，如果调用的时候，传入了这个接口的具体实现，那么在内部会去判断如果传入的接口参数不为空，就调用接口里的方法实现通知回调的效果。
在 JavaScript 里实现这种回调机制就特别简单，通过逻辑与 && 表达式，一行代码就搞定了，如果有传入 callback 函数，那么 callback 就会是真值，逻辑与 && 表达式就会去执行右操作数的 callback()。
当然，如果你想严谨点，你可以多加几个逻辑与 && 表达式来验证传入的 callback 参数是否是函数类型。
"||" 逻辑或
逻辑或 || 跟逻辑与 && 就基本是一个东西了，理解了上面讲的逻辑与 && 运算符的理论，那么自然也就能够理解逻辑或 || 运算符了。
它们的区别，仅在于对表达式的处理，逻辑或 || 表达式是这么处理的：
- 如果左操作数的值是真值，那么不会触发右操作数的计算，且整个逻辑或 || 表达式返回左操作数的值
- 如果左操作数的值是假值，那么整个逻辑或 || 表达式返回右操作数的值
- 假值真值可以通俗的理解成，上节介绍各种数据类型间的转换规则中，各类型转换为布尔类型的值，转为布尔后为 true，表示这个值为真值。反之，为假值。
这里就直接来说下它的一个应用场景了：
应用场景
function queryNameById(id) {
//参数的默认值
id = id || 10086;
//...
}处理参数的默认值，如果调用函数时，没有传入指定的参数时。
当然，还有其他很多应用场景。总之，善用逻辑与 && 和逻辑或 || 运算符，可以节省很多编程量，同时实现很多功能。
"," 逗号运算符
在 Java 中，"," 逗号只用于在声明同一类型变量时，可同时声明，如：
int a, b, c;在 JavaScript 里，"," 逗号运算符同样具有这个功能，但它更强大，因为带有 "," 逗号运算符的表达式会有一个返回值，返回值是逗号最后一项操作数的值。
逗号运算符跟逻辑与和逻辑或唯一的区别，就在于：逗号运算符会将每一项的操作数都进行计算，而且表示式一直返回最后一项的操作数的值，它不管每个操作数究竟是真值还是假值，也不管后续操作数是否可以不用计算了。
举个例子：
function getName() {
return "dasu"
}
function queryNameById(id, callback) {
id = id || 10086;
callback && callback();
}
function myCallback() {
console.log("I am dasu");
}
var me = (queryNameById(0, myCallback), getName()) //me会被赋值为 "dasu",且控制台输出 "I am dasu"变量 me 会被赋值为 "dasu"，且控制台输出 "I am dasu"。
typeof 运算符
返回指定操作数的数据类型，例：
在 JavaScript 中数据类型大体上分两类：原始类型和引用类型。
原始类型对应的值是原始值，引用类型对应的值为对象。
对于原始值而言，使用 typeof 运算符可以获取原始值所属的原始类型，对于函数对象，也可以使用 typeof 运算符来获取它的数据类型，但对于其他自定义对象、数组对象、以及 null，它返回的都是 object，所以它的局限性也很大。
delete 运算符
delete 是用来删除对象上的属性的，因为 JavaScript 里的对象有个特性，允许在运行期间，动态的为对象添加某个属性，那么，自然也允许动态的删除属性，就是通过这个运算符来操作。
这个在对象一节还会拿出来讲，因为并不是所有的属性都可以成功被删除的，属性可以设置为不可配置，此时就无法通过 delete 来删除。
另外，之前也说过，在函数外声明的全局变量，本质上都是以属性的形式被存在在全局对象上的，但这些通过 var 或 function 声明的全局变量，无法通过 delete 来进行删除。
之前也说过，如果在声明变量时，不小心漏掉了 var 关键字，此时程序并不会出异常，因为漏掉 var 关键字对一个不存在的变量进行赋值操作，会被 js 解释器认为这行代码是要动态的为全局对象添加一个属性，这个动态添加的属性就可以通过 delete 来进行删除，因为动态添加的属性默认都是可配置的。
instanceof 运算符
在 Java 中，可以通过 instanceof 运算符来判断某个对象是否是从指定类实例化出来的，也可以用于判断一群对象是否属于同一个类的实例。
在 JavaScript 中有些区别，但也有些类似。
var b = {}
function A() {}
A.prototype = b;
var a = new A();
if (a instanceof A) { //符合，因为 a 是从A实例化的，继承自A.prototype即b
console.log("true");
}
function B() {}
B.prototype = b;
var c = new B();
if (c instanceof A) {//符合，虽然c是从B实例化的，但c也同样继承自b，而A.prototype指向b，所以满足
console.log("true");
}
if (c instanceof Object) {//符合，虽然 c 是继承自 b，但 b 继承自 Object.prototype，所以c的原型链中有 Object.prototype
console.log("true");
}在 JavaScript 中，instanceof 运算符的左侧是对象，右侧是构造函数。但他们的判断是，只要左侧对象的原型链中包括右侧构造函数的 prototype 指向的原型，那么条件就满足，即使左侧对象不是从右侧构造函数实例化的对象。
例子代码看不懂么事，这个在后续介绍原型时，还会再拿出来说，先清楚有这么个运算符，运算符大概的作用是什么就可以了。
大家好，我是 dasu，欢迎关注我的公众号（dasuAndroidTv），公众号中有我的联系方式，欢迎有事没事来唠嗑一下，如果你觉得本篇内容有帮助到你，可以转载但记得要关注，要标明原文哦，谢谢支持~