JavaScript02

1.常量

const pi=3.14

常量也是用于存储数据的容器
常量一旦声明必须赋值，不允许重新赋值

const pi=3.14;
//pi=3.1415;//报错，不允许重新赋值
//console.log(pi);

2.数据类型

分为原始类型和引用类型
原始类型分为数值型、字符串型、布尔型、未定义型、空

(1)数值型

整型
10进制
1 2 3 … 7 8 9 10 … 15 16
8进制，以0开头的数字，例如010
1 2 3 … 7 10 11 12
16进制，以0x开头的数字，例如0xa 不区分大小写
1 2 3 … 7 8 9 a … f 10

//数值型
var n1 = 11;
//8进制，以0开头的数字
var n2 = 010;
//16进制，以0x开头的数字
var n3 = 0xf;
//console.log(n3);

浮点型
3141.5e-1 //314.15
314.15
31.415e+1
3.1415e+2 // 314.15

typeof 检测数据类型 ‘number’ ‘string’ ‘boolean’ ‘undefined’ ‘object’

console.log(typeof str2);

(2)字符串型

被引号包含的数据就是字符串型，不区分单双引号
查看任意一个字符的Unicode码

//字符串型
var str1 = 'tao';
var str2 = '2';
var str3 = 'str1';  //不再具有变量的功能了

//console.log(typeof str2);
//console.log(str3);
//查看一个字符的编码值
//存储字符有一种编码 - Unicode码-比如计算机底层要存储字符,需要吧字符编码
//console.log( '桑'.charCodeAt() );

‘sb’.charCodeAt() //错

(3)布尔型

只有两个值，分别是true和false，代表真和假，表示只有两个结果的数据，例如是否登录、是否注册…

var b1 = true;
var a = 3 > 1
//console.log(b1,typeof b1);
//console.log(1>3);

(4)未定义型

只有一个值undefined
声明了变量未赋值则为undefined，属于一种空值

var a;//var a=undefined;
//console.log(a,typeof a);

(5)空

只有一个值null
类型是object(对象)，常结合引用类型数据使用

var b=null;
console.log(b,typeof b);

3.数据类型转换

分为隐式转换和强制转换

1)隐式转换

在运算过程中发生的转换

(1)数字+字符串 数字转为字符串
2 + ‘1’ //‘21’ typeof()
加号(+)的作用
(1)加法运算
(2)字符串之间的拼接
(2)数字+布尔型 布尔型转为数值 true-1 false-0
1+true //2
1+false //1
(3)字符串+布尔型 布尔型转为字符串
‘5’+true //‘5true’

练习：

查看以下程序的运行结果
var a=2,b=true,c=‘tedu’;
console.log(a+b+c); //‘3tedu’
console.log(b+c+a); //‘truetedu2’
console.log(c+a+b); //‘tedu2true’

加号(+)的作用
(1)加法运算
(2)字符串之间的拼接

假设从后端获取到了商品的标题和价格，最终显示出以下效果
//标题：xxx 价格：xxx

var title = 'apple macbook air';
var price = 6199;
//console.log('标题：'+title+'  价格：'+price);

练习：假设从后端获取到了一个用户的用户名和手机号码，最后打印以下形式

//欢迎：xxx  您当前绑定的手机号码xxx
var userName = 'tao';
var phone = '18312345678';
//console.log('欢迎：'+userName+'  您当前绑定的手机号码'+phone);

NaN：Not a Number，不是一个数字，是在将数据转数值的时候失败的结果，和任何的值执行数学运算结果还是NaN

var a1 = 2 + undefined;//NaN  Not a Number 不是一个数字
var a2 = 2 + null;//2

var a3 = '2' * 3;//6
var a4 = '4' / '2';//2
var a5 = true - '5';//-4
var a6 = undefined - '2';
var a7 = '2a'/2; //NaN   (typeof a7)
console.log(a7);
//console.log(NaN/2);

>隐式转换为数值自动的调用函数Number()

2)强制转换

(1)强制转换为数值 >Number()

//强制转为数值
var n1 = Number(true);//1
var n2 = Number(false);//0
//练习：转以下数据为数值
// '2'  '2a'  undefined   null
var n3 = Number('2');//2
var n4 = Number('2a');//NaN
var n5 = Number(undefined);//NaN
var n6 = Number(null);//0
//console.log(n5,n6);

(2)强制转换为整型>parseInt()

通常用于将小数和字符串转为整型，其它的转换为NaN

//转整型
var p1 = parseInt(8.9); //8
var p2 = parseInt('3.14');//3
var p3 = parseInt('6.18a');//6
var p4 = parseInt('a6.18');//NaN
var p5 = parseInt(true);
//console.log(p5);

(3)强制转换为浮点型 > parseFloat()

通常用于将字符串转为浮点型，其它的转换为NaN

//转浮点型
//'5.18'  '7a'  'a4.13'
var f1 = parseFloat('5.18');//5.18
var f2 = parseFloat('7a');//7
var f3 = parseFloat('a4.13');//NaN
//console.log(f1,f2,f3);

(4)将数值和布尔型强制转为字符串（了解） >toString()

//数值、布尔型转字符串
var num = 2;
//产生一个新的字符串数据
var str = num.toString(); //'2'
console.log(str,typeof str);

4.运算符

表达式：由数据或者由运算符连接的操作数据组成的形式称作表达式
运算符分为算术运算符、比较运算符、逻辑运算符、位运算符、赋值运算符、三目运算符

(1)算术运算符

+ - * / % ++ –
++ 在自己基础上加1
– 在自己的基础上-1
% 取余

//取余
//找奇数偶数 - 跟2取余
//找闰年
//console.log(5%2);//1
//console.log(2%5);//2

++ 自增，在原来的基础之上加1
– 自减，在原来的基础之上减1

/*
var a = 1;
//在原来基础知识加1
//a++;  单独使用两者没有区别
++a;  
console.log(a);

var b = 2;//先把b赋给c，然后b再自增var c = b++;
var d = 2;//先让d执行自增，然后把自增后的结果赋给evar e = ++d;

var n1 = 5;
var n2 = n1--;
var n3 = --n1;
console.log(n1,n2,n3);

整个算术运算符都会将数据隐式转换为数值型

//console.log( '5'%'3' );//2
var n = '3';
n++;
console.log(n);//4
*/
//正负号也具有隐式转换
console.log( 5 + -'1' );
// +'3' -> 3

(2)比较运算符

> < >= <= (等于) != =(全等于) !(不全等于)
== 等于，只是比较值是否相同，可能会发生隐式转换
=== 全等于，先比较类型，然后再比较值
!= 不等于，比较值不等于
! 不全等于，类型不同或者值不同

//console.log(2 == '2');//true
//console.log(2 === '2');//false

//1  true
//console.log(1 == true);
//console.log(1 === true);

//console.log(null == undefined);//true
//console.log(null === undefined);//false

3>'10'  //字符串转为数值
'3'>'10'  //比较的是首个字符的Unicode码
'3' -> 51  '1 '-> 49
3>'10a' //false
3<'10a' //false
3=='10a' //false
NaN==NaN //false
 NaN和任何值比较(>  <  >=  <=  ==  ===)结果都是false

(3)逻辑运算符

&& || !
&& 逻辑与，关联的两个条件都是true结果是true，否则是false
|| 逻辑或，关联的两个条件有一个是true结果是true，否则是false
! 取反

//判断一个人的工资是否在5000~8000之间
var salary = 3000;
//console.log(salary>=5000 && salary<=8000);

//声明变量保存用户输入的用户名和密码，如果用户名是root并且密码是123456，打印结果true，否则打印结果false
var uname = 'tao';
var upwd = '123456';
//console.log( uname==='root' && upwd==='123456' );

//60岁及以上，或者12岁及以下都免费
var age = 65;
//console.log( age>=60 || age<=12 );

//练习：声明变量保存用户输入的值，如果是绑定的邮箱root@163.com，或者是用户名tao，或者是绑定的手机号码18313458983，打印true，否则打印false
var input = '18913458983';
//console.log(input === 'root@163.com' || input === 'tao' || input === '18313458983');

//取反
//console.log( !false );
/*
//练习：查看以下程序是否会报错
var  a=5;
a > 10  && console.log(num);
a > 2  ||  console.log(num);
*/
//练习:声明变量保存年龄，如果满18岁打印 '成年人'
var age = 11;
age>=18 && console.log('成年人');

短路逻辑

当执行完第一个条件不再执行第二个条件，就会产生短路逻辑
关注点在于第二个条件(表达式)是否执行
&& 当第一条件为false就不再执行第二个条件
|| 当第一个条件为true就不再执行第二个条件

练习：查看以下程序是否会报错
var a=5;
a > 10 && console.log(num);
a > 2 || console.log(num);

(4)位运算符

模拟计算机底层的运算，先将数据转为二进制，然后进行运算，当运算完再把结果转回成十进制。

1 2 3 4 5 6 7

1 10 11 100 101 110 111

& 按位与，上下两位比较，如果都是1结果是1，否则是0

| 按位或，上下两位比较，如果含有1结果是1，否则是0

^ 按位异或，上下两位比较，不同是1，相同时0

>> 按位右移，删除末尾的位数

<< 按位左移，在末尾补0

32>>2

100000

1000000

5&7 8|13 7^12

101 1000 0111

111 1101 1100

———— ———— ———

101 1101 1011

练习：

声明变量保存任意一个年份，判断是否为闰年，如果是闰年，使用短路逻辑打印‘闰年’

闰年：能被4整除，并且不能被100整除，或者能被400整除

var year = 2020;
console.log(year % 4 === 0 && year % 100 !== 0 || year % 400 === 0);

(year % 4 === 0 && year % 100 !== 0 || year % 400 === 0) && console.log('闰年');

//(2+3)*4```