2021-08-22

2021.08.16 js core1
一、数据类型转换：
（一）强制转换
1.转字符串：
（1）var str=xx.toString( );//null和undefined不可用
（2）var str=string(xx);//万能–不如使用+"";
2.转数字：
（1）var num=parseInt(str/num);
（2）var num=parseFloat(str/num);
（3）Number(xx);
3.转布尔
Boolean(xx);//万能，
基本都为true，除了这六种情况：0、”“、NaN、undefined、null、false
（二）隐式转换：多半在运算符和表达式中进行了自我转换
二、运算符和表达式：
（一）算术运算：+、-、、%、/
1.默认转为数字在运算
2.特殊：
（1）+运算：会转为字符串进行拼接
（2）-、、%、/：纯数字进行转换，非纯数字则为NaN
(二）比较运算：< > <= >= == != === !==
1.默认：转为数字在进行比较
2.特殊：
（1）如果是字符串，则按位PK每个字符的十六进制的unnicode和十进制的ascii码
数字<大写<小写<汉字 —— 中间可能还有一些特殊的符号
（2）NaN参与任何运算结果都是false —— !isNaN(xx);//true为数字，false为NaN
（3）undefinednull —— 结果为true
undefined=null —— 结果为false；//数据类型和数值都要相同，不带隐式转换的等式比较；!==不带隐式转换的不等比较
(三）逻辑运算
1.&&：全真为真，一假则假
2.||：一真全真，全假为假
3.！：颠倒布尔值
4.隐式转换：转为布尔值在进行比较
5.特殊：短路逻辑 —— 前面真则可得出结论，前面为假后面才可以进行执行
（1）&&的短路逻辑
原理：前面条件为真，后面的操作才可执行；前面条件为假，后面的操作不可执行。
语法：条件&&（操作）；
强调：操作只能是简单的一句话
（2）||的短路逻辑
原理：前面条件为真，后面条件不会执行；前面条件为假，后面条件才会执行。
语法：var 变量=值1||值2；//两个值二选一，用来做老IE兼容
(四）位运算
左移： m<<n 读作m左移n位，相当于：m*2的n次方
右移： m>>n 读作m右移n位，相当于：m/2的n次方
注意：底数只能为2，不能修改
(五）赋值运算（先运算，在保存）
+= -= *= /= %=
1.累加/减/乘/除：m+=n 可以为任何数字
2.递增/减：i++ i-- —— 只能为，只有加减可以用
递增/递减的笔试/面试：
（1）单独使用，放前放后都一样
（2）参与了其他运算表达式中：变量中的值始终会加1
前++（++n），返回的是递增后的新值
后++（n++），返回的是递增前的旧值
(六）三目运算：
1.语法：
（1）条件？操作1：默认操作；
（2）条件1？操作1：条件2？操作2：默认操作；
2.注意：
（1）三目操作只能是一句话
（2）默认操作不能省略

2021.08.17 js core2
一：函数
（一）函数的创建：
1.声明方式创建函数：
function 函数名（形参·····） {
函数体；
return 返回值；
}
2.直接量创建函数
var 函数名=function （形参······）{
函数体；
return 返回值；
}
3.注意：return作用返回一个值，退出函数
（二）调用函数并且保存接住函数的结果
var result=函数名（ ）；
（三）强调：
1.一个function里面只有一个return
2.是否需要写return，看你需不需要获得函数的值
3.函数没有写return也是有返回值，默认为undifined
二、作用域（scope）：一个变量的可用范围
（一）全局作用域：全局变量和全局函数，js任何位置都可以使用
（二）函数作用域：局部变量（函数内创建的变量、形参）和局部函数
（三）作用：有了作用域就有了变量的使用规则 —— 优先使用自己的，自己没有就找全局，全局没有则报错
（四）特殊：全局污染 —— 在任何地方给未声明的变量直接赋值，都会导致全局污染
三、声明提前（hoist）
程序正式执行前，将var声明的变量和声明的函数放到当前作用域的顶部创建；
但是var的赋值留在原地，只有声明方式创建的函数会完整的提前，直接量创建的函数只有部分会提前赋值留在原地。
四、按值传递：
（一）如果传递的是原始类型的值：修改一个变量另一个变量不会受到影响
（二）如果传递的是引用类型的值：修改一个变量另一个变量也会受到影响
五、预定义全局函数
（一）编码和解码：url中不允许出现多字节字符（例如：汉字），如果出现就会报错

1. 编码 var code=encodeURL(“千峰”);
   解码 var 原文=decodeURL(code）；
   2.加强版
   编码 var code=encodeURLComponent(“千峰”);
   解码 var 原文=decodeURLComponent(code);
   （二） isFinte(num) —— 判断一个数字是否在有效范围内 （NaN、infinity、分母为0 都为错）
   （三）eval(str) —— 计算字符串，脱掉字符串的衣服
   六、分支结构
   （一）语法：
   switch (变量/表达式）{
   case 值1：
   操作1；
   case 值2：
   操作2；
   case 值3：
   操作3；
   default：
   默认操作；
   }
   （二）强调：
   1.case 的比较不会带有隐式转换
   2.默认只要满足一个case过后，会将后面所有的操作全部做完 —— 解决：break
   注意：有的地方可以不写break —— 最后默认操作不用加，中间多个操作相同也可以不加
   3.default 默认操作可以省略

2021.08.18 js core3
一、循环结构
（一）while （ ）{ }
（二）do {循环体} while (循环条件）
while 和 do while的区别：在于第一次，如果第一次不满足，while一次都不做，do while 至少会执行一次
（三）for (循环变量；循环条件；变量的变量）{ 循环体； }
二、数组
（一）数组的基础概念：一个内存（变量名）中保存了多个数据的一个集合结构
（二）创建
1.直接量创建 var arr=[值1，···]；
2.构造函数 var arr=new Array(值1，···）；
特殊：new Array(只放了一个数字num）—— 相当于创建了一个长度为num 的空数组，设置了长度
（三）访问 数组名[下标] —— 元素
添加 数组名[下标]=新值；
读取元素，下标越界 —— 返回 undefined
添加元素，下标越界 —— 稀疏数组
（四）三不限制：不限制个数、不限制类型、不限制下标越界
（五）arr.length —— 最大下标：arr.length-1
三个固定套路：
1.末尾添加元素： arr[arr.length]=新值；
2.获取倒数第n个： arr[arr.length-n];
3.缩容（删除元素）： arr.length-=n;
（六）遍历数组: for (var i=0;i<arr.length;i++) {arr[i];}
（七）如果一个引用类型想要释放，一定要释放干净
（八）关联数组（hash数组）——下标可以自定义 （之前为索引数组：下标为数字）
1.如何使用：
（1）创建一个空数组 var arr=[ ];
（2）为数组添加下标添加元素 arr[“自定义下标”]=新值；
（3）访问 arr[“自定义下标”]；
（4）强调：hash数组的长度永远失效
2.遍历hash数组 —— for in 循环遍历
for (var 下标名 in 数组名）{数组名[下标名]}

2021.08.18-19 js core3-4
一、数组的API
（一）arr 转 string：
1.var str=arr.join(“连接符”);
2.可以自定义连接符，也可以省略不写等效于String(arr);
3.固定套路
（1）如何将数组里面的内容拼接为一个句话（无缝拼接）
语法: var str=arr.join("");
（2）将数组拼接为页面元素
//数据
var cities=["-请选择-",“北京”,“南京”,“重庆”,“天津”,“上海”];
//数组的API join拼接上了标签
var str=""+cities.join("")+"";
//渲染到页面元素之上
sel.innerHTML=str;
4.实现：二级联动：
关键要点：（1）两个数组：一个普通数组做一级，一个二维做二级
（2）select专属事件onchange
（3）事件中：this.selectedIndex - 获取到当前选中项的下标

（二）拼接数组：添加数组元素的新方式：将concat后面的参数，拼接到arr之后
var newArr=arr.concat(值1,…);
强调：1、concat不修改原数组，只能返回一个新数组
2、concat可以直接传入数组参数，悄悄的把数组打散为单个元素

（三）截取（获取）子数组：将arr从starti位置开始，一直截取到endi - 删除元素的新方式/复制
var subArr=arr.slice(starti,endi+1);
强调：1、slice不修改原数组，只能返回一个新数组
2、含头不含尾
3、endi可以省略，截取到末尾
4、两个参数都可以省略，从头到尾复制一份 - 深拷贝（复制了一个副本）

（四）arr.splice()：删除/添加/替换的新方式
删除：var dels=arr.splice(starti,n); n - 删除个数
强调：其实此方法也有返回值，返回的是你删除的元素组成的一个新数组

添加：arr.splice(starti,0,值1,...);
      强调：1、原starti位置的元素以及后续元素都会向后移动
	 2、插入数组也行，但是不推荐，因为不会帮我们打散数组，会导致一些部分是一维，一些部分是二维

替换：var dels=arr.splice(starti,n,值1,...);
      强调：删除的个数不必等于插入的个数

（五）翻转数组：arr.reverse();

（六）排序：arr.sort();
问题1：默认会将元素们转为字符串，按位PK，希望按照数字排序？
解决：固定套路：
arr.sort(function(a,b){//悄悄的带有循环
console.log(a);//a是后一个数
console.log(b);//b是前一个数
return a-b;//如果return 返回的是一个正数，说明后一个数>前一个数
//如果return 返回的是一个负数，说明后一个数<前一个数
//如果return 返回的是0，两者一样大
//而我们的sort方法正好可以根据你返回的正数/负数/0来进行排序
})

      问题2：只能升序排列，如何降序：
解决：arr.sort(function(a,b){return b-a;})

（七）栈和队列：其实就是数组，添加元素和删除元素的新方式
栈：数组，只不过是一端封闭，只能从另一端进出的操作
开头进：arr.unshift(新元素,…);//添加元素的新方式，向前添加，缺陷：导致其余元素的下标发生变化
开头出：var first=arr.shift();//只会一次调用删除第一个//删除元素的新方式，向前删除，缺陷：导致其余元素的下标发生变化

	结尾进：arr.push(新元素,...);//添加元素的新方式，向后添加
	结尾出：var last=arr.pop();//只会一次调用删除最后一个//删除元素的新方式，向后删除

队列：数组，只不过是只能从一端进入，另一端出
   何时：按照先来后到的顺序
	依然是以上4个：
	开头进：arr.unshift(新元素,...);
	结尾出：var last=arr.pop();

	结尾进：arr.push(新元素,...);
	开头出：var first=arr.shift();

（八）二维数组：数组的元素，又引用着另一个数组
何时：在一个数组内，再次细分每个分类
创建：
var arr=[
[“张三”,18,1500],
[“李四”,18,2000],
[“王麻子”,35,12000]
];

  访问：arr[行下标][列下表];
 特殊：列下标越界，返回undefined
	行下标越界，报错！因为undefined没有资格使用[]

  遍历二维数组：必然两层循环，外层循环控制行，内存循环控制列
		for(var r=0;r<arr.length;r++){
			for(var c=0;c<arr[r].length;c++){
				console.log(arr[r][c]);
			}
		}