[toc]
# 每日英语
1. `expression` 表达式
1. `condition` 条件
1. `modified` 改变
# 关系操作符
小于（<）、大于（>）、小于等于（<=）和大于等于（>=）这几个关系操作符用于对两个值进行比较，这几个操作符都返回一个布尔值
```javascript
var result1 = 5 > 3; //true
var result2 = 5 < 3; //false
console.log(result1);
console.log(result2);
```
```javascript
console.log(3 < 2); //false
console.log(3 > 2); // true
console.log(3 >= 2); // true
console.log(3 <= 2); // false
console.log(2 <= 2); // true
```
当关系操作符的操作数使用了非数值时，也要进行数据转换
1. 如果两个操作数都是数值，则执行数值比较。
1. 如果两个操作数都是字符串，则比较两个字符串对应的字符编码值。
```javascript
console.log("hello" >= "world"); // false
console.log("hello" > "world"); // false
```
1. 如果一个操作数是数值，则将另一个操作数转换为一个数值，然后执行数值比较。
```javascript
console.log(123 > "123"); //false
console.log(123 >= "123"); //true
console.log(123 >= "123hello"); // false
console.log(123 >= []); // true
```
1. 如果一个操作数是对象，则调用这个对象的 valueOf() 方法，用得到的结果按照前面的规则执行比较。如果对象没有 valueOf() 方法，则调用 toString() 方法，并用得到的结果根据前面的规则执行比较。
1. 如果一个操作数是布尔值，则先将其转换为数值，然后再执行比较。
```javascript
console.log(1 > false); // true
console.log(1 > true); // false
```
由于大写字母的字符编码全部小于小写字母的字符编码
```javascript
var result = "Brick" < "alphabet"; //true
console.log(result);
```
```javascript
var result = "Brick".toLowerCase() < "alphabet".toLowerCase(); //false
console.log(result);
```
```javascript
var result = "23" < "3";
console.log(result);
```
```javascript
var result = "23" < 3;
console.log(result);
```
```javascript
var result = "a" < 3;
console.log(result);
```
由于字母 "a" 不能转换成合理的数值，因此就被转换成了 NaN 。
根据规则，任何操作数与 NaN 进行关系比较，结果都是 false 。
```javascript
var result1 = NaN < 3; //false
var result2 = NaN >= 3; //false
console.log(result1);
console.log(result2);
```
```javascript
var result = "Brick" < "alphabet"; // true
var result = "Brick".toLowerCase() < "alphabet".toLowerCase(); // false
var result = "23" < 3; // false
var result = "a" < 3; // false
var result = "a" > 3; // false
console.log(result);
```
# 相等操作符
确定两个变量是否相等是编程中的一个非常重要的操作。在比较字符串、数值和布尔值的相等性时， 问题还比较简单。但在涉及到对象的比较时，问题就变得复杂了。最早的 ECMAScript 中的相等和不等 操作符会在执行比较之前，先将对象转换成相似的类型。后来，有人提出了这种转换到底是否合理的质疑。最后，ECMAScript 的解决方案就是提供两组操作符：
**相等和不相等——先转换再比较，全等和不全等——仅比较而不转换。**
1. 相等和不相等
ECMAScript 中的相等操作符由两个等于号（ == ）表示，如果两个操作数相等，则返回 true 。
而不相等操作符由叹号后跟等于号（ != ）表示，如果两个操作数不相等，则返回 true 。
这两个操作符都会先转换操作数，然后再比较它们的相等性。
在转换不同的数据类型时，相等和不相等操作符遵循下列基本规则：
1. 如果有一个操作数是布尔值，则在比较相等性之前先将其转换为数值—— false 转换为 0，而 true 转换为 1；
```javascript
console.log(false == 1); // false
console.log(false == 0); // true
console.log(true == 0); // false
console.log(true == 1); // true
```
1. 如果一个操作数是字符串，另一个操作数是数值，在比较相等性之前先将字符串转换为数值；
```javascript
console.log("123" == 123); // true
console.log("123hello" == 123); // false
console.log("[]" == 0); // false
console.log([] == 0); // true
```
1. 如果一个操作数是对象，另一个操作数不是，则调用对象的 valueOf() 方法，用得到的基本类型值按照前面的规则进行比较；这两个操作符在进行比较时则要遵循下列规则。
1. null 和 undefined 是相等的。
1. 要比较相等性之前，不能将 null 和 undefined 转换成其他任何值。
1. 如果有一个操作数是 NaN ，则相等操作符返回 false ，而不相等操作符返回 true 。重要提示： 即使两个操作数都是 NaN ，相等操作符也返回 false ；因为按照规则， NaN 不等于 NaN 。
```javascript
console.log(null == undefined); // true
console.log(NaN == 0); // false
console.log(NaN == "hello"); // false
console.log(NaN == NaN); // false
```
1. 如果两个操作数都是对象，则比较它们是不是同一个对象。如果两个操作数都指向同一个对象， 则相等操作符返回 true ；否则，返回 false 。
```javascript
console.log([] == []); // false
console.log(new Array() == new Array()); // false
var a = [];
var b = a;
console.log(a == b); // true
```
```javascript
console.log(null == undefined); // true
console.log(true == 1); // true
console.log("NaN" == NaN); // false
console.log(true == 2); // false
console.log(5 == NaN); // false
console.log(undefined == 0); // false
console.log(NaN == NaN); // false
console.log(null == 0); // false
console.log(NaN != 3); // true
console.log(NaN == 3); // false
console.log("5" == 5); // true
console.log(false == 0); // true
console.log(NaN > NaN); // false
console.log(NaN < NaN); // false
```
## 全等和不全等
除了在比较之前不转换操作数之外，全等和不全等操作符与相等和不相等操作符没有什么区别。全等操作符由 3 个等于号（ === ）表示，它只在两个操作数未经转换就相等的情况下返回 true
```javascript
var result1 = "55" == 55; //true，因为转换后相等
var result2 = "55" === 55; //false，因为不同的数据类型不相等
console.log(result1);
console.log(result2);
```
不全等操作符由一个叹号后跟两个等于号（ !== ）表示，它在两个操作数未经转换就不相等的情况下返回 true
```Javascript
var result1 = ("55" != 55); //false，因为转换后相等
var result2 = ("55" !== 55); //true，因为不同的数据类型不相等
console.log(result1);
console.log(result2);
```
```javascript
console.log("123" === 123); // false
console.log("" === []); // false
console.log(0 === []); // false
console.log(null === undefined); // false
```
null == undefined 会返回 true ，因为它们是类似的值；
但 null === undefined 会返回 false ，因为它们是不同类型的值。
由于相等和不相等操作符存在类型转换问题，而为了保持代码中数据类型的完整性，推荐使用全等和不全等操作符
# 条件操作符(三元运算)
## 表达式和语句
```javascript
var age = 17; // 语句
123 > 13; // 表达式
```
有结果的语句, 就叫表达式
`variable = boolean_expression ? true_value : false_value;`
本质上，这行代码的含义就是基于对 boolean_expression 求值的结果，决定给变量 variable 赋什么值。
如果求值结果为 true ，则给变量 variable 赋 true_value 值；如果求值结果为 false ， 则给变量 variable 赋 false_value 值。
`var max = (num1 > num2) ? num1 : num2;`
```javascript
var a = 123 > 333 ? "yes" : "no";
console.log(a); // no
```
```javascript
var a = 3;
var b = 1;
var c = 4;
var max = (a > b ? a : b) > c ? (a > b ? a : b) : c;
console.log(max);
```
比 if 语句更简单
```javascript
var a = 3;
var b = 4;
var c;
if (a > b) {
c = a;
} else {
c = b;
}
console.log(c); // 4
```
```javascript
var a = 3;
var b = 4;
var c = 1;
var max;
if (a > b) {
max = a;
} else {
max = b;
}
if (max < c) {
max = c;
}
console.log(max); // 4
```
# 赋值操作符
> 简单的赋值操作符由等于号（ = ）表示，其作用就是把右侧的值赋给左侧的变量
```Javascript
var num = 10;
console.log(num)
```
如果在等于号（ = ）前面再添加乘性操作符、加性操作符或位操作符，就可以完成复合赋值操作。
这种复合赋值操作相当于是对下面常规表达式的简写形式：
```javascript
var num+=10
var num = 10;
num = num + 10;
```
```javascript
var a = "hello";
console.log((a += "world")); // helloworld
// var a = "hello";
// a = a + "world";
```
每个主要算术操作符（以及个别的其他操作符）都有对应的复合赋值操作符。这些操作符如下所示：
`乘/赋值（ *= ）；`
`除/赋值（ /= ）；`
`模/赋值（ %= ）；`
`加/赋值（ += ）；`
`减/赋值（ -= ）；`
<!-- `左移/赋值（ <<= ）；` -->
<!-- `无符号右移/赋值（ >>>= ）。` -->
```javascript
var a = 123;
console.log((a *= 10)); // 1230
var b = 10;
console.log((b /= 10)); // 1
// b/=10 ====> b = b/10
var c = 13;
console.log((c -= 1)); // 12
var d = 24;
console.log((d %= 5)); // 4
```
**设计这些操作符的主要目的就是简化赋值操作。使用它们不会带来任何性能的提升。**(测试时间)
```javascript
// var a = "hello";
// var b = a+="world";
// console.log(b);
var a = "hello";
var b = a + "world";
console.log(b);
```
# 逗号操作符
> 使用逗号操作符可以在一条语句中执行多个操作
```Javascript
var num1=1, num2=2, num3=3;
```
逗号操作符还可以用于赋值。
在用于赋值时，逗号操作符总会返回表达式中的最后一项
```javascript
var num = (5, 1, 4, 8, 0); // num 的值为 0
```
```javascript
var num = (1, 2, 3, 4, 5);
console.log(num); // 5
var num = 1;
num = 2;
num = 3;
num = 4;
num = 5;
console.log(num); // 5
```
- 每日单词
- JavaScript 入门
- JavaScript 基础
- JavaScript 基础回顾
- JavaScript 函数
- 匿名函数,多维数组,数据类型转换
- JavaScript 类型转换, 变量作用域
- js 运算符(一)
- js 运算符(二)
- js 流程控制语句
- JavaScript 扫盲日
- JavaScript 牛刀小试(一)
- JavaScript 牛刀小试(二)
- JavaScript 再谈函数
- JavaScript-BOM
- JavaScript-定时器(一)
- JavaScript-定时器(二)
- 番外-轮播图源码
- JavaScript 轮播图和 DOM 简介
- JavaScript-DOM 基础-NODE 接口-属性
- JavaScript-DOM 基础-NODE 接口-方法
- NodeList-接口-HTMLCollection-接口
- Document 节点
- CSS 复习与扩展(一)
- CSS 复习与扩展(二)
- 走进 jQuery 的世界
- 使用 jquery
- 使用 jquery-2
- jquery 中高级
- jquery 备忘清单-1
- jquery 备忘清单-2
- 聊聊 json
- jquery 备忘清单-3