<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>相等运算符</title>
<script type="text/javascript">
/*
相等运算符用来比较两个值是否相等，
如果相等会返回true，否则返回false
使用 == 来做相等运算
- 当使用==来比较两个值时，如果值的类型不同，则会自动进行类型转换，将其转换为相同的类型，然后再比较
不相等
不相等用来判断两个值是否不相等，如果不相等返回true，否则返回false
- 使用 != 来做不相等运算
- 不相等也会对变量进行自动的类型转换，如果转换后相等它也会返回false
===
全等
- 用来判断两个值是否全等，它和相等类似，不同的是它不会做自动的类型转换
如果两个值的类型不同，直接返回false
!==
不全等
- 用来判断两个值是否不全等，和不等类似，不同的是它不会做自动的类型转换
如果两个值的类型不同，直接返回true
*/
console.log(1 == 1);
var a = 10;
// console.log(a == 4);//false
console.log('1' == 4);//true
console.log(true == '1');//true
console.log(null == 0);//false
console.log(null == undefined);//true
console.log(NaN == '1');//false
console.log(NaN == undefined);//false
console.log(NaN == NaN);//false
var b =NaN;
// console.log(b == NaN);//false
// console.log(isNaN(b));//true
// console.log(10 != 5);//true
// console.log(10 != 10);//false
// console.log('abcd' != 'abcd');//false
// console.log('1' != 1);//false
// console.log('123' == 123);//true
// console.log('123' === 123);//false
// console.log(null == undefined);//true
// console.log(null === undefined);//false
console.log(1 != '1');//false
console.log(1 !== '1');//true
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Boolean</title>
<script type="text/javascript">
/*
Boolean 布尔值
布尔值只有两个，主要用来做逻辑判断
true
- 表示真
false
- 表示假
使用typeof检查一个布尔值时，会返回boolean
*/
var bool = false;
console.log(bool);
console.log(typeof bool);//boolean
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Null和Undefined</title>
<script type="text/javascript">
/*
Null（空值）类型的值只有一个，就是null
null这个值专门用来表示一个为空的对象
使用typeof检查一个null值时，会返回object
Undefined（未定义）类型的值只有一个，就undefind
当声明一个变量，但是并不给变量赋值时，它的值就是undefined
使用typeof检查一个undefined时也会返回undefined
*/
var a =null;
console.log(a);
console.log(typeof a);//object
var b;//undefined
console.log(b);
console.log(typeof b)
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>运算符的优先级</title>
<script type="text/javascript">
/*
, 运算符
使用,可以分割多个语句，一般可以在声明多个变量时使用
*/
// var a,b,c;
var a=1, b=2, c=3;
// alert(b);//2
var result = 1+2*3;
result = 1 || 2 && 3;
console.log('result =' + result);
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>条件运算符</title>
<script type="text/javascript">
/*
条件运算符也叫三元运算符
语法：
条件表达式?语句1:语句2;
- 执行的流程：
条件运算符在执行时，首先对条件表达式进行求值，
如果该值为true，则执行语句1，并返回执行结果
如果该值为false，则执行语句2，并返回执行结果
如果条件的表达式的求值结果是一个非布尔值，会将其转换为布尔值然后在运算
*/
// true ? alert("语句1") : alert("语句2");
// false ? alert("语句1") : alert("语句2");
var a = 30;
var b = 43;
var c = 50;
// a>b ? alert('a大') ; alert('b大')；
// var max = a>b ? a : b;
// max = max>c ? max : c;
var max = a > b ? (a > c ? a : c) : (b > c ? b : c);
// console.log('max =' + max);
'hello' ? alert('语句1') : alert('语句2');
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>关系运算符</title>
<script type="text/javascript">
/*
通过关系运算符可以比较两个值之间的大小关系，
如果关系成立它会返回true，如果关系不成立则返回false
> 大于号
- 判断符号左侧的值是否大于右侧的值
- 如果关系成立，返回true，如果关系不成立则返回false
>= 大于等于
- 判断符号左侧的值是否大于或等于右侧的值
< 小于号
<= 小于等于
非数值的情况
- 对于非数值进行比较时，会将其转换为数字然后再比较
- 如果符号两侧的值都是字符串时，不会将其转换为数字进行比较，而会分别比较字符串中字符的Unicode编码
*/
var result = 5 > 10;//flase
var rasult = 5 > 4;//true
var result = 5 > 5;//false
var result = 5 >= 5;//true
var result = 5 >= 4;//true
var result = 5 < 4;//false
var result = 4 <= 4;//true
// console.log("result = "+result);
// console.log(1 > true);//false
// console.log(1 >= true);//true
// console.log(1 >= '0');//true
// console.log(10 > 'null');//true 10>0
//Nan和任何值比较结果都是false
// console.log(10 > 'hello');//false
// console.log(10 >= 'hello');//false
// console.log(10 < 'hello');//false
// console.log(10 <= 'hello');//false
console.log(true > false);//true 1>0
console.log('1' < '5');//true
console.log(11 < '5');//false
console.log('a' < 'b');//true
console.log('abc' < 'b')//true
console.log('bbc' < 'b')//false
console.log('bbc' < 'bcd')//true
console.log('我' < '你')//false
console.log('1112332131' < +'5');//false
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>赋值运算符</title>
<script type="text/javascript">
/*
=
可以将符号右侧的值赋值给符号左侧的变量
+=
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
*/
var a = 10;
//a = a + 5;
// a -= 5;
// a += 5;
// a *= 5;
// a /= 5;
a %= 3;//1
console.log("a = "+a);
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>与或运算</title>
<script type="text/javascript">
/*
&& || 非布尔值的情况
- 对于非布尔值进行与或运算时，会先将其转换为布尔值，然后再运算，并且返回原值
- 与运算：
- 如果第一个值为true，则必然返回第二个值
- 如果第一个值为false，则直接返回第一个值
- 或运算
- 如果第一个值为true，则直接返回第一个值
- 如果第一个值为false，则返回第二个值
*/
var result = 1 && 2;//true && true 2
result = 2 && 1;//true&&true 1
result = 0 && 2;//false && true 0
result = 2 && 0;//true && false 0
result = NaN && 0;//false && false NaN
result = 0 && NaN;//false && false 0
result = 2 || 1;//true && true 2
result = 2 || NaN;//true && false 2
result = NaN || 0;//false && false 0
result = ''||'hello';//false||true 'hello'
result = -1 || '您好';//true||true -1
console.log("result = "+result);
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>逻辑运算符</title>
<script type="text/javascript">
/*
JS中为我们提供了三种逻辑运算符
! 非
- !可以用来对一个值进行非运算
- 所谓非运算就是值对一个布尔值进行取反操作，
true变false，false变true
- 如果对一个值进行两次取反，它不会变化
- 如果对非布尔值进行元素，则会将其转换为布尔值，然后再取反
所以我们可以利用该特点，来将一个其他的数据类型转换为布尔值
可以为一个任意数据类型取两次反，来将其转换为布尔值，原理和Boolean()函数一样
&& 与
- &&可以对符号两侧的值进行与运算并返回结果
- 运算规则
- 两个值中只要有一个值为false就返回false，
只有两个值都为true时，才会返回true
- JS中的“与”属于短路的与，
如果第一个值为false，则不会看第二个值
|| 或
- ||可以对符号两侧的值进行或运算并返回结果
- 运算规则：
- 两个值中只要有一个true，就返回true
如果两个值都为false，才返回false
- JS中的“或”属于短路的或
如果第一个值为true，则不会检查第二个值
*/
var a = false;
a = !!a;
// console.log("a = " + a);
var b = 10;//true
b = !!b;//false
// console.log('b = ' + b);
// console.log(typeof b)
var result = true && true;//true
result = true && false;//false
result = false && true;//false
result = false && false;//false
// console.log('result = ' + result);
// true && alert('看我出不出来');
// false && alert('看我出不出来');
result = false || false;//false
result = true || false;//true
result = false || true;//true
result = true || true;//true
// console.log('result = ' + result);
//false ||alert('123');
true || alert('123');
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>自增和自减的练习</title>
<script type="text/javascript">
var n1=10;
var n2=20;
var n = n1++; //
console.log('n=' + n); //
console.log('n1=' + n1); //
n = ++n1; //
console.log('n=' + n); //
console.log('n1=' + n1); //
n = n2--;//
console.log('n=' + n); //
console.log('n2=' + n2); //
n = --n2; //
console.log('n=' + n); //
console.log('n2=' + n2); //
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>自增和自减</title>
<script type="text/javascript">
/*
自增 ++
- 通过自增可以使变量在自身的基础上增加1
- 对于一个变量自增以后，原变量的值会立即自增1
- 自增分成两种：后++(a++) 和 前++(++a)
无论是a++还是++a，都会立即使原变量的值自增1
不同的是a++和++a的值不同
a++的值等于原变量的值（自增前的值）
++a的值等于新值 （自增后的值）
自减 --
- 通过自减可以使变量在自身的基础上减1
- 自减分成两种：后--(a--) 和 前--(--a)
无论是a--还是--a都会立即使原变量的值自减1
不同的是a-- 和 --a的值不同
a-- 是变量的原值 （自减前的值）
--a 是变量的新值 （自减以后的值）
*/
var a = 1;
// a = a + 1;
// a++;
// ++a;
// console.log(a++);//1 先赋值
// console.log(++a)l//2 先自增
// console.log("a = " + a);
var c = 10;
c++;
console.log(c++);
</script>
</head>
<body>
</body>
</html>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>一元运算符</title>
<script type="text/javascript">
/*
一元运算符，只需要一个操作数
+ 正号
- 正号不会对数字产生任何影响
- 负号
- 负号可以对数字进行符号的取反
- 对于非Number类型的值，它会将先转换为Number，然后再运算
- 可以对一个其他的数据类型使用+,来将其转换为number，它的原理和Number()函数一样
*/
var a = 123;
a = +a;
a = -a;
a = true;//1
a = -a;
a = '18';
a = +a;
// console.log(typeof a);
// console.log("a = " + a);
// var result = 1 + '2' + 3;//'123'
var result = 1 + +'2' + 3;//6
console.log('result = ' + result);
</script>
</head>
<body>
</body>
</html>
