JS[13—20]
//13_其他进制的数字
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script type="text/javascript">
var a = 123;
/*
*在JS中，如果需要表示16进制的数字，则需要以0X开头
* 如果需要表示8进制的数字，则需要以0开头
* 如果需要表示2进制的数字，则需要以0b开头
* ————但不是所有浏览器都支持
*/
//十六进制
a = 0X17;
//八进制
a = 070;
//二进制
a = 0b10;
//像“070”这种字符串，有的浏览器会当成8进制解析，有的会当成10进制解析
a = "070";
/*
*解决方法：可以在parseInt()中传递一个第二个参数，用来指定数字进制
*/
a = parseInt(a,8);
console.log(typeof a);
console.log(a);
</script>
</head>
<body>
</body>
</html>
//14_转换为Boolean
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script type="text/javascript">
/*
*将其他的数据类型转换为Boolean
* ————使用Boolean()函数
* ——数字-->布尔
* 除了0和NaN,其余的都是true
* ——字符串-->布尔
* 除了空串，其余都是true
* ———null和undefined都会转换为false
* ———对象也会转换为true
*/
var a = 123;// true
a = -123;//true
a = 0;//false
a = Infinity;//true
a = NaN;//false
//调用Boolean()函数将a转换为布尔值
a = "hello";//true
a = "true";//true
a = "false";//true
a = "错误";//true
a = "";//false
a = " ";//true
a = null;//false
a = undefined;//false
a = Boolean(a);
console.log(typeof a);
console.log(a);
</script>
</head>
<body>
</body>
</html>
//15_算数运算符
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script type="text/javascript">
/*
*运算符也叫操作符，
* 通过运算符可以对一个或多个值进行运算，并获取运算结果
* 比如:typeof就是运算符，可以用来获得一个值的类型
* 它会将该值的类型以字符串的形式返回
* number boolean string object undefined
*
*
* 算数运算符 (不会对原变量产生影响，除非重新给赋值回去)
* 当对非Number类型的值进行运算时，会将这些值转换为Number,然后再运算（除了字符串加法）
* 任何值和NaN做运算，都得NaN
*
* +：1.可以对两个值进行加法运算，并将结果返回
* 2.如果对两个字符串进行加法运算，则会进行拼串操作
* 会将两个字符串拼接成一个字符串，并返回
* 3.任何的值和字符串做加法运算，都会先转换为字符串，然后和字符串做拼串操作
*
* —：1.可以对两个值进行减法运算，并将结果返回
*
* *：1.可以对两个值进行乘法运算，并将结果返回
*
* /：1.可以对两个值进行除法运算，并将结果返回
*
* %：1.取模运算（取余数）
*/
var a = 123;
result = a + 1;
result = 456 + 789;
result =true + 1;
result =true + false;
result =false+ 1;
result = 2 + null;
result = 2 +NaN;
result = "123" + "456";//返回字符串“123456”，拼串
result= "你好" + "大帅哥";//返回字符串“你好大帅哥”，执行了拼串操作
var str = "锄禾日当午,"+
"汗滴禾下土。"+
"谁知盘中餐，"+
"粒粒皆辛苦。"
result = 123 +"1";//返回字符串“1231”
result = true +"hello";//返回字符串“truehello”
//任何值和字符串相加，都会转换为字符串，并作拼串操作
/*
* 我们可以利用这一特点，来将一个任意的数据类型转换为String
* 我们只需要为任意的数据类型 + 一个“”，即可将其转化为String
* 这是一种隐士的类型转换，由浏览器自动完成，实际上它也是调用的String()函数
*/
//var result = typeof(a);
var c = 123;
//c=String(c);
//c = c + "";
// c = null;
// c = c +"";
//console.log(result);
// console.log(typeof c);
// console.log("c= "+c);
result = 1 + 2 +"3";//返回字符串“33”
result ="1" + 2 + 3;//返回字符串“123”
result =100 -5;//返回95
result =100 -true;//返回99
result =100-"1";//当对非Number类型的值进行运算时，会将这些值转换为Number,然后再运算（除了字符串加法）
result =100+"1";//字符串加法
result = 2 * 2;
result = 2 * "8";
result = 2 * undefined;//2是number,undefined是非number，会转换成number，即NaN。返回值为：NaN
result = 2 * null;//返回0
result = 4 / 2;//返回2
result = 3 / 2;
// console.log("result = " + result);
/*总结：
* 任何值做减、乘、除运算时，都会转化为number
* 我们可以利用这一特点，做一隐式的类型转换
* 可以通过为一个值做：减0、乘1、除1，将其转化为number
* 加0不可以，加0会遇到字符串，会出现自动拼串的结果
* 原理和Number()函数一样，但要简单一些
*/
var d = "123";
//d = Number(d);
d = d -0;
/* console.log(typeof d);
console.log(d); */
result = 9 % 5;
console.log(typeof result);
console.log(result);
</script>
</head>
<body>
</body>
</html>
//16_一元运算符
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script type="text/javascript">
/*
* 一元运算符，只需要一个操作数
* + 正号:1.正好不会对数字产生任何影响
* - 负号:1.负号可以对数字进行符号的取反
*
* 对于非Number类型的值，
* 会将其转换为Number,然后再运算
* 可以对一个其他数据类型使用 + ，将其转换为Number
* 它的原理和Number()函数一样
*
*/
var a = -123;
a = -a;
a = true;
a = -a;
a = "18";
a = +a;
/* console.log("a =" +a);
console.log(typeof a); */
var result = 1 + +"2" + 3;
console.log("result = "+result);
console.log(typeof result);
</script>
</head>
<body>
</body>
</html>
//17_自增和自减
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script type="text/javascript">
/*
* 自增(自增运算符是：++)
* ——通过自增可以使变量在自身的基础上增加 1
* ——对于一个变量自增以后，原变量的值会立即自增1
* ——自增分两种：后++（a++） 和 前++ (++a)
* 无论是a++,还是++a,都会使原变量自增1
* 不同的是 a++ 和 ++a 的值不同
* a++的值，等于原变量的值（自增前的值）
* ++a的值，等于原变量新值（自增后的值）
*
*
* 自减（自减运算符是：--）
* ——通过自减可以使变量在自身基础上减1
* ——自减分成两种：前--（--num） 和 后--（num--）
* 无论是num-- 和 --num,都会使自变量值自减1
* 不同的是num-- 和 --num的值不同
* num--是变量的原值（自减前的值），
* --num是变量的新值（自减后的值）
/*
var num = 10;
//num --;
//-- num;
console.log("num -- = " + --num);
console.log("num = " +num);
*/
/* var a = 1;
//a = a+1;
//a++;//使a自增1
a++;
console.log("a++ = " + a++);
console.log("++a = " + ++a);
console.log("a = " +a);
console.log(typeof a); */
/* var c =10;
//第一次c++ 是在10的基础上自增，此时c变成11
c++;//此时值为11
//第二次c++ 是在11的基础上自增，此时c变成12，而它的原值是11
console.log("c++ =" + c++);//在原值 c++ 的基础上新增的，所以返回值为11
console.log(c); */
/* var d = 20;
//var result = d++ + ++d + d;
//d = d++;
d = d++;
console.log("d = " + d );//21
//console.log(++d);//22 */
</script>
</head>
<body>
</body>
</html>
//18_自增练习
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script type="text/javascript">
//练习
var n1 = 10,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>
//19_逻辑运算符
<!DOCTYPE html>
<html>
<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,则不会检查第二个值
*
*
*/
//如果两个值都是true,则返回true
var result = true && true;
//只要一个false，就返回false
result = true && false;
result = false && true;
result = false && false;
//console.log("result = " + result);
//第一个值为true,会检查第二个值
//true && alert("看我出不出来");
//第一个值为false,不会检查第二个值
//false && alert("看我出不出来");
/* var a = false;
a = !!!a;
console.log("a = " +a); */
/* var b = 10;
b = !!b;
console.log("b = " +b);
console.log(typeof b);
*/
/* var c = "hello";
c =!!c;
console.log("c = " +c);
console.log(typeof c);
*/
/* //两个都是false,则返回false
result = false || false ;
console.log("result = " + result);
//只要有一个true,就返回true
result = true || false ;
console.log("result = " + result);
result = false || true ;
console.log("result = " + result);
result = true || true ;
console.log("result = " + result); */
//第一个值为false,则会检查第二个值
//false || alert("看我出不出来");
true || ("看我出不出来");
//alert("看我出不出来") || false;
</script>
</head>
<body>
</body>
</html>
//20_非布尔值的与或运算
<!DOCTYPE html>
<html>
<head>
<meta charset="utf-8">
<title></title>
<script type="text/javascript">
/*
* && || 非布尔值的情况
* 对于非布尔值进行与或运算时，
* 会先将其转换为布尔值，然后再运算，并且返回原值
* ——与运算：
* 如果第一个值为true,则必然返回第二个值
* 如果第一个值为false,则必然返回第一个值
*
* ——或运算：
* 如果第一个值为true,则直接返回第一个值
* 如果第一个值为false,则直接返回第二个值
*/
//true && true
//与运算，如果两个值都为true,则返回后边的
var result = 2 && 1;
//如果两个值中有false,则返回靠前的false
// false&&true
result = 0 && 2;
//false&&false
result = NaN && 0;
result = 0 && NaN;
//true || true
//如果第一个值为true,则直接返回第一个值
result = 1 || 2;
result = 2 || 1;
result = 2 || NaN;
//如果第一个值为false,则直接返回第二个值
result = NaN || 1;
result = NaN || 0;
result = "" || "hello";
result = -1 || "你好";
console.log("result = " + result);
</script>
</head>
<body>
</body>
</html>