<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script>
/*
运算符也叫操作符，
通过运算符可以对一个或多个值进行运算，并获取运算结果，
比如 typeof 就是运算符，可以来获得一个值的类型，它会将该值的类型以字符串的形式返回。
*/
var a = 123;
var result = typeof a; // number
console.log(typeof result); // string
/*
算数运算符，不会改变原变量，只会返回一个结果。
当非Number类型的值，会将这些值先转换成Number类型，再进行运算。
+
-
*
/
%
*/
/*
+ 可以对两个值进行加法运算，并把结果返回
*/
result = a + 1; // result = 124
console.log(a); // 123
result = true + 1; // 2
result = true + false; // 1
result = 2 + null; // 2
// 任何值和NaN进行运算，都为NaN.
result = 2 + NaN; // NaN
// 如果对两个字符串进行加法，会进行拼串操作，并返回结果.
result = "123" + "456"; // 123456
console.log(typeof result); // string
// 任何的值和字符串做+运算，都会先转换为字符串，然后拼串.
result = 123 + "1"; //1231
result = true + "hello"; // truehello
// 可以将任意的数据类型转换为String，只需要为任意类型+ 一个""即可转换为String
// 这是一种隐式的类型转换，有浏览器自动完成，实际上也是调用String()函数完成的.
var c = 123;
c = c + ''; // "123"
console.log(typeof c);
c = null
c = c + ""; // "null"
// 注意运算顺序
result = 1 + 2 + "3";
console.log("result =" + result); // "result = 33"
result = "1" + 2 + 3; // "123"
/*
- 可以对值进行减法运算，并返回
*/
result = 100 - 5 ; // 95
result = 100 - true; // 99
// 先转换成Number类型，再进行减法运算
result = 100 - "1"; // 99
result = "100" - "1"; // 99
/*
*可以对两个值进行乘法运算
*/
result = 2 * 2; // 4
result = 2 * "8"; // 16
result = "2" * "3"; // 6
result = 2 * undefined; //NaN
result = 2 * null ; // 0
/*
/ 可以对两个值进行除法运算
*/
result = 4 / 2; // 2
result = 3 / 2; //1.5
// 任何值做- * / 运算时都会自动转换为Number
// 可以利用这一特点做隐式的类型转换，可以通过为一个值 -0 *1 /1 来将其转换为Number
// 原理和Number()一样
var d = "123"
d = d - 0; // typeof d 为number
/*
% 取模运算（取余数）
*/
result = 9 % 3; // 0
/*
一元运算符，只需要一个操作数
+ 正号
- 正号不会对数值产生任何影响
- 负号
- 负号可以对数字进行符号的取反
- 对于非Number类型的值，先将其转换为Number，再运算。
*/
a = 123;
a = +a; // 123
a = -a; //-123
a = -2;
a = +a; // -2
a = -a; // 2
a = true;
a = -a; // -1
a = "18"; // typeof a => string
a = -a; //-18 typeof a => number
//将其他类型转换为Number，使用+
a = "18" // typeof a => string
a = +a; // 18 typeof a => number
result = 1 + "2" + 3; //"123"
// 运算符的优先级
result = 1 + +"2" + 3; // 6
/*
自增++：通过自增可以使变量在自身的基础上增加1,对于一个变量自增以后，原变量的值会立即自增。
*/
a = 1;
a = a + 1; // 2
// 等同于
a++;
++a;
// 自增有两种，后++(a++)和前++(++a)。
// 无论是a++，++a，都会立即使原变量的值自增1.不同的是，a++和++a的值不同.
// a++ 的值等于自增前的值
// ++a 的值等于自增后的值
a = 1;
console.log(a++); // 1
console.log("a = " + a); // "a = 2"
a = 1;
console.log(++a); // 2
console.log("a = " + a) // "a = 2"
c = 10;
c++;
console.log(c++); // 11
console.log(c); // 12
var d = 20;
console.log(++d); // 21
console.log(++d); // 22
// d++ 20 d 21
// ++d 22 d 22
result = d++ + ++d + d;
console.log(result); //64
d = 20;
//d++运行之后，d是21，d++是20，20赋值给d，d为20.
d = d++;
// 等价于
var e = d++;
d = e;
/*
自减--
通过自减可以使变量在自身的基础上减1
自减分成两种，后--（a--）和前--（--a）
无论是a--还是--a,都会立即使原变量的值自减1，不同的是a--和--a的值不同.
a--自减前的值
--a是自减后的值
*/
var num = 10;
num--;
--num;
/*
JS中为我们提供了三种逻辑运算符
!非 可以用来对一个值进行非运算,不改变原变量，所谓非运算就是对一个bool值进行取反操作。true变false。false变true。
&& 与
|| 或
*/
a = true;
// 对a进行非运算
a = !a; // false
// 如果对一个值进行两次取反，则不会变换。
a = !!a; // true
// 如果对一个非bool值进行非运算，则会先转换为bool值，再取反。
b = 10; // number
b = !b; // false bool
// 可以利用该特点，将其他数据类型转为bool类型。可以为任意数据类型取两次反，转换为bool类型。
a = "hello"; // string
a = !!a; // true boolean
// && 与
// 可以对符号两侧的值进行与运算并返回结果
// 如果两个值都为true则返回true
result = true && true; // true
// 只要有一个false，就返回false
result = true && false; // false
result = false && true; // false
result = false && false; // false
// JS中的与属于短路与，如果第一个值为false，则不会再看第二个
// 第一个值为true，会检查第二个
true && alert('你看我出不出来'); //会弹框
// 第一个值为false，不会检查第二个
false && alert('你看我还出不出来'); // 不会弹框
// || 或
// 可以对符号两侧的值进行或运算并返回结果
// 如果两个值只要有一个true，则返回true。两个都为false，则返回false。
// 两个都是false，则返回false.
result = false || false; // false
result = true || false; // true
result = false || true; // true
result = true || true; // true
// JS中的或属于短路或，如果第一个值为true，则不会看第二个。
// 第一个值为true，则不再检查第二个
true || alert("123");
// 第一个值为false，会检查第二个
false || alert("123"); // 会弹框
/*
对于非bool值进行与或运算：
非bool值的情况时，先将其转换为bool值，再运算，并且返回原值。
与运算：
如果第一个值为true，则返回第一个。
如果第一个值为false，则直接返回第一个值。
或运算：
如果第一个值为true，则直接返回第一个。
如果第一个值为false，则返回第二个。
*/
// 与运算，如果两个值都为true，则返回后面的
// 与运算，如果两个值中有false，则返回false。
// true && true
result = 1 && 2; // 2
result = 2 && 1； // 1
// false && true
result = 0 && 2； // 0
result = 2 && 0； // 0
// false && false
result = NaN && 0; // NaN
result = 0 && NaN: // 0
// true|| true
// 如果第一个值为true，则直接返回第一个值
result = 1 || 2； //1
result = 2 || 1; //2
result = 2 || NaN;
result = 2 || 0;
// 如果第一个值为false，则直接返回第二个值。
result = "" || "hello"; // "hello"
result = -1 || "你好"; // -1
/*
赋值运算符
= 可以将符号右侧的值赋值给左侧的变量
+= a += 5 等价于 a = a + 5;
-= a -= 5 等价于 a = a - 5;
*= a *= 5 等价于 a = a * 5;
/= a /= 5 等价于 a = a / 5;
%= a %= 5 等价于 a = a % 5;
*/
a = 123; // a = 123
a = a + 5;
// 等价于
a += 5;
a = a - 5;
// 等价于
a -= 5;
/*
关系运算符
通过关系运算符可以比较两个值之间的大小关系
如果关系成立，它会返回true，如果关系不成立，则返回false。
*/
/*
> 大于号
- 判断符号左侧的值是否大于右侧的
- 如果关系成立，返回true，如果关系不成立，则返回false。
*/
result = 5 > 10; // false
result = 5 > 4; // true
result = 5 > 5; // false
/*
>= 大于等于
- 判断符号左侧的值是否大于或等于右侧的值
- 如果关系成立，则返回true。如果关系不成立，则返回false.
*/
result = 5 >= 5; // true
result = 5 >= 10; // fals
result = 5 >= 4; // true
/*
<= 小于等于
*/
result = 5 <= 10; // true
/*
非数值比较：
先转换成数值，再进行比较。
任何值和NaN进行任何比较都是NaN.
特殊情况，如果两边都是字符串，不会将其转换为数字进行比较，而会分别比较字符串中字符的Unicode编码。
*/
console.log(1 > true ); // false
console.log(1 >= true); // true
console.log(1 > "0"); // true
console.log(10 > null); // true
console.log(10 > 'hello'); // false
console.log(10 <= "hello"); // false
console.log(true > false ); // true
console.log("1" < "5"); // true
console.log("11" < "5"); // true
console.log(11 < "5"); // false
console.log("a" < "b"); // true
console.log("a" >= "b"); // false
// 比较字符编码时，是一位一位进行比较
console.log("abc"< "b"); // true
console.log("bbc" < "bb"); // false
// 比较中文没有意义
console.log("戒" > "我"); // true
// 如果比较的是两个字符串型的数字，可能会得到不可预期的结果,一定要转型！！
console.log("1111111222" > "5"); // false
// 可改为
console.log("1111111222" > +"5"); // true
/*
相等运算符用来比较两个值是否相等，如果相等会返回true,否则返回false.
使用 == 来做相等运算.
当使用==比较两个值时，如果值的类型不同，将转换成相同的类型，再进行比较。
*/
a = 10;
console.log(a == 4); // false
console.log("1" == 1); // true
console.log(true == "1"); // true
console.log(true == 'hello'); // false
console.log(null == 0); //false
/*
undefined 衍生自null
所以这两个值做相等判断时，会返回true。
*/
console.log(undefined == null); // true
/*
NaN 不和任何值相等，包括他本身
*/
console.log(NaN == NaN); // false
b = NaN;
// 判断b的值是否是NaN
/*
可以通过isNaN()函数来判断一个值是否为NaN
如果该值是NaN，则返回true，否则返回false。
*/
console.log(isNaN(b)); // true
/*
!= 不相等用来判断两个值是否不相等，如果不相等返回true，如果相等返回false。
不相等也会对变量进行自动的类型转换，如果转换后相等，它也会返回false
*/
console.log(10 != 5); //true
console.log("abcd" != "abcd"); // false
console.log("1" != 1);
/*
===
全等用来判断两个值是否全等，它和相等类似，不同的是它不会做自动的类型转换。
如果两个值的类型不同，直接返回false。
*/
console.log("123" === 123); //false
/*
!==
不全等：用来判断两个值是否不全等，和不等类似，不同的是它不会做自动的类型转换。
如果两个值的类型不同，直接返回true。
*/
console.log("1" !== 1); // true
/*
条件运算符也叫三元运算符
语法：
条件表达式? 语句1:语句2
执行流程，
条件运算符在执行时，首先对条件表达式进行求值，
如果该值为true，则执行语句1，并返回执行结果
如果该值为false，则执行语句2，并返回执行结果
当返回的结果是个非bool值，会先将其转换为bool值，再进行运算。
*/
true ? alert("语句1") : alert("语句2"); // 语句1
a = 10;
b = 20;
c = 50;
a > b ? alert('a大'): alert('b大'); // b大
// 获取a和b中的最大值
var max = a > b ? a : b;
console.log("max =" + max);
// 获取a b c 中的最大值
max = max > c ? max : c;
// 这种写法不推荐使用，不方便阅读
max = a > b ? (a > c ? a : c ): (b > c ? b : c)
"hello"? alert('语句1'): alert("语句2"); // 语句1
""? alert("语句1"): alert("语句2"); // 语句2
/*
, 运算符
使用,可以分割多个语句，一般可以在声明多个变量时使用
*/
// 使用 , 运算符同时声明多个变量
// var a , b , c;
// 可以同时声明多个变量并赋值
// var a = 1, b = 2, c = 3;
// alert(b);
/*
就和数学中一样，在JS中运算符也有优先级，
比如： 先乘除 后加减
*/
result = 1 + 2 * 3; // 7
/*
如果|| 的优先级高，或者两个一样高，则应该返回3
如果&& 的优先级高，则应该返回1
*/
result = 1 || 2 && 3;
console.log(result); // 1
/*
可以通过()来改变优先级
*/
rsult = (1 || 2) && 3; // 3
</script>
</head>
<body>
</body>
</html>
