JS的学习（2）操作符，类型转换，流程控制语句，数组

1. 操作符
   表达式 ： 操作符 和 操作数组成
   (1) 算术操作符
   允许非number类型的操作数进行运算，在运算之前，一般需要先将其他数据类型转换为数字类型再进行运算，当操作数中出现了字符串，则变成了字符串拼接操作。
   +、 +=
   var a = 3;
   var b += a; // var b = b + a;

   var result = 1 + 2;
   var result = 1 + true;
   
   当操作数中出现了字符串，+ 运算就变成了字符串拼接运算。
   var result = true + '1';		//	true1
   -、-=
   var result = 3 - 2;
   var result = 3 - true; 	//2
   var result = 3 - 'a' 		//NaN
   *、*=
   var result = 2 * 3;
   /、/=
   var result = 5/2;
   %、%=
   var result = 5%2;

   (2) 比较操作符
   运算结果一般为boolean
   <
   <=
   >
   >=

   == 		等于   两个对象比较{}=={}其结果为false,因为其地址不同
   将操作数转换为同一数据类型再进行比较
   1) 基本数据类型的值
   
   2) 引用数据类型的值
   比较的引用地址。
   var a = {name:"terry"}
   var b = {name:"terry"}
   a == b;
   
   '{"name":"terry"}' == '{"name":"terry"}'
   
   === 	全等  两个对象比较{}=={}其结果为false,因为其地址不同
   先比较两个操作数的数据类型，如果数据类型不一致，直接返回false,当数据类型一致的时候才对比值
   
   1 == "1"			// true
   1 === "1" 		// false
   
   如何比较两个对象的属性是否一致
   1. 先将对象序列化为json字符串
   2. 对json字符串进行对比

   (3) 逻辑操作符【短路运算符】
   &&
   返回值不一定是boolean类型

   true && false // 	false
   true && true 	// 	true
   
   var gender = 'female'
   if(gender==='male' && age>18){
   
   }
   对于以上代码，gender === 'male'运算结果为false,整个&&表达式的结果就为false,无需再进行其他运算。
   
   var a ;
   var result = a && 3;							//undefined
   var result = 3 && a;							//undefined
   
   var result = "hello world" && 3;	//3
   对于以上代码,"hello world"如果转换为boolean将为true,整个&&表达式的运算结果取决于&&后面的表达式，所以将&&后的结果直接返回。
   
   var gender = 'female'
   var age = 13;
   var result = gender == 'male' && age > 12;
   问：age>12是否可以执行？如何证明？
   
   ||
   var result = true || false; 	//true, 有真则真
   var result = false || false; 	//false,同假才假
   
   var result = 1>2 || 'hello';	// hello
   如上，1>2为false，但是无法确定整个表达式的结果，整个表达式的结果取决于第二个表达式，将其返回即可。
   
   var result = 1<2 || 'hello' 	// true
   如上，1<2为true,能确定整个表达式的结果，无需进行接下来的运算。
   !
   !true 		//false
   !false 		//true
   !!true 		//true
   将其他数据类型转换为boolean类型
   !"hello" 	//false
   !!"hello"	//true

   (4) 三目操作符
   表达式1 ? 表达式2 : 表达式3
   如果表达式1为真，返回表达式2；如果表达式1为假，返回表达式3
   var age = 19;
   let result = age > 16 ?“成年人”:“小孩子”;
   (5) 一元运算符
   +
   +3 //3
   一元加运算符后的操作数如果是其他数据类型，则转换为数字类型
   +true //1
   -
   一元减，负
   -3 //-3
   -true //-1
   -(-true) //1
   ++
   自增
   var a = 3;
   var result = a++ + ++a

   console.log(result);	//8
   console.log(a);				//5
   --
   自减

   (6) 位运算 *
   原、反、补
   针对于数字类型的值进行运算，在运算之前先转换为二进制
   &
   1000 0010
   0000 0100
   |
   ^
   问题：
   && 与 &区别，|| 与|区别？

   机试
   1) 软考
   2) 大厂 ： 华为、阿里 （校招）、哔哩哔哩
   100+道算法

2. 类型转换

   -> 数字类型
   通常在dom中或者是从后端拿到的数据不是纯数字类型，但是需要进行数学运算，在运算之前要先转换为数字类型
   Number(a)
   +a
   -(-a)
   parseInt(a)
   parseFloat(a)

   • -> 布尔类型
     Boolean(a)
     false : null 0 undefined NaN “” Infinity…
     true: {} 1 “hello”
     !!a

     if(exp1){}
     exp1 可以是任意数据类型，因为js在执行过程中会自动将其转换为boolean
     if(obj != null){ }
     if(obj){ }

   • -> 字符串类型
     String(a)
     a+""

3. 流程控制语句

   [ol]

   分支语句

   if 分支
   if(exp){
   xxx
   }

   当exp为true或者可以被转换为true的时候，大括号内部的代码会执行

   if(exp){

   } else {

   }
   当exp为true,执行if代码块的内容，否则执行else代码块的内容

   if(exp1){

   } else if(exp2) {

   } else {

   }

   练习：
   提供函数，接收数字参数『1，2，3…』，当参数为1，输入"周一",当参数为2,输出"周二"
   function foo(num){
   if(num === 1){
   console.log(“周一”);
   } else if(num === 2){
   console.log(“周二”);
   } else if(num === 3){
   console.log(“周三”);
   } else if(num === 4){
   console.log(“周四”);
   } else if(num ===5 ){
   console.log(“周五”);
   } else {
   console.log(“周末”);
   }
   }
   foo(2);

4. switch分支
   解决if-else if -…-else繁琐，switch更加简洁一些
   switch(v){
   case c1:
   …
   break;
   case c2:
   …
   break;
   …
   default:
   …
   }
   v 表示变量
   c1、c2、c3、… 常量
   当 v === c1的时候，执行c1代码块中的内容，break表示跳槽switch代码块，如果不加break，后续代码都会执行直到遇到break或者switch结束
   default代码块可以位于switch中的任意位置，但是要注意，如果不是位于最下方，一定在代码块中添加break

1. Array.*
   Array.isArray()
   判断一个变量是否是数组
   Array.from();
   将一个可迭代的对象转换为数组
   Array.of();
   将参数中的值作为数组的元素
2. Array.prototype.*

1. 遍历相关的方法
   这些方法有个共同点，都需要传递一个回调函数作为参数，回调函数都有三个形参，分别为item,index,arr
   Array.prototype.forEach()
   遍历数组对象
   参数:
   返回值:undefined
   代码：handler为回调函数，用来回传计算后得到的数据

Array.prototype.myForEach=function(handler){
for(var i =0;i<this.length;i++){
var item=this.[i];
handler.call(this,item,i,this);
}
}

var arr=["terry","larry","tom"];
arr.myForEach((item,index,arr)=>{
console.log(item,index,arr);
})

Array.prototype.every()
元素是否都满足同一个条件
参数：回调函数需要返回boolean
返回值：boolean
Array.prototype.some()
是否有元素满足同一个条件
参数：回调函数需要返回boolean
返回值：boolean
Array.prototype.filter()
返回回调函数返回true的元素的集合
参数：回调函数需要返回boolean
返回值：数组
Array.prototype.map()
返回回调函数返回值组成的数组
参数：回调函数，一定要返回值
返回值：数组
代码：

var arr=[{
name:"terry",
gender:"male"
},{
name:"larry",
gender:"male"
},{
name:"nacy",
gender:"female"
}]
var result1=arr.every(function(item){
return item.gender=="female";
})
console.log("是否每个都是女生："，result1);
var result2=arr.some(item=>item.gender=="female");
console.log("是否有女生："，result);
var result3=arr.filter(item=>item.gender=="male");
console.log("男生有哪些："，result3);
var result4=arr.map(item=>item.name);
console.log("学生名字",result4);

2) 栈、队列相关方法
Array.prototype.push()
向数组的末尾追加指定值
参数：任意值
返回值：数组长度
Array.prototype.pop()
参数：无
返回值：删除的栈顶元素
Array.prototype.shift();
出队列
参数：无
返回值：删除的队列首部元素
Array.prototype.unshift();
将指定元素插入到队列的首部
参数：
返回值：插入后数组的长度
3) 排序相关
Array.prototype.reverse();
Array.prototype.soft();
默认将数组元素转换为字符串，然后进行排序
soft允许接收一个比较器函数作为参数，比较器函数接受两个参数，
如果a > b，返回1，升序
如果a > b，返回-1，降序
[{name:“terry”,age:19,grade:98}]
提供一个函数，接受属性作为参数，要求按照name/age/grade进行排序
代码：

var arr1=[1,25,45,56,25];
console.log(arr1);
var result1=arr1.sort();
console.log("用sort直接排序：",result1);
arr1.sort(function foo(a,b){
if(a>b){
return 1;
}else{
return -1;
}
});
console.log("使用比较器函数排序后：",arr1);
var arr2=[{
name:"terry",
age:15
},{
name:"larry",
age:25
},{
name:"vicky",
age:12
}]
console.log(arr2);
console.log("排序后")；
function sort(arr2,prop){
arr2.sort((function(prop){
return function(a,b){
if(a[prop]>b[prop]){
return 1;
}else{
return -1
}
}
})(prop))
}
sort(arr2,"name");
console.log(arr2);

闭包：函数内部嵌套函数，内部函数拥有外部函数的变量，内部函数与外部函数的这个变量就组成了闭包。