day 1

1、数组的基础（填坑）：

1、创建数组：

	1、直接量：var arr=[值1,...];
	2、构造函数：var arr=new Array(值1,...);此方法有一个坑：new Array(num);创建了一个长度为num的空数组，里面没有任何东西，只有无数的undefined

2、按值传递：

传递的如果是原始类型：其实是复制了一个副本给对方，两者互不影响
    传递的如果是引用类型：js中不是原始类型，就是引用类型（函数、数组，都是引用类型）- 浅拷贝：赋值了自己的地址值给对方，两者用的是同一个地址值，一个修改另一个也会变化

3、如何释放一个引用类型：一定要看清楚有几个变量引用着这个引用类型，每个变量都要释放后才能释放干净

索引数组：下标都是数字组成的数组

2、hash数组（关联数组）

1、创建：

    创建空数组：var arr=[];

2、为数组添加自定义下标并且赋值：

    arr["自定义下标"]=新值;

3、访问元素：

    arr["自定义下标"];

4、强调：

    hash数组的length失效了，永远为0！

5、遍历hash数组：使用for in循环

			for(var i in 数组名){
				i;//下标
				数组名[i];//当前次元素
			}

6、***hash数组的原理：

		hash算法：将字符串，计算出一个尽量不重复的数字（地址值），字符串内容相同，则计算出来的数字也一定是相同的
		添加元素：将自定义下标交给hash算法，得到一个数字（地址值），直接将你要保存的数据放到此地址保存起来
		获取元素：将指定的自定义下标交给hash算法，得到一个和当初保存时一样的数字（地址值），通过此地址找到你当初保存的数据，取出来使用

7、js里面一切的东西都是对象，万物皆对象，除了undefined和null，【一切对象的底层都是hash数组】

3、数组的API：

1、*arr 转 str：

	var str=arr.join("自定义连接符");
	固定套路：2个
		1、var str=arr.join("");
		2、将数组拼接为DOM页面元素 - var str="<开始标签>"+arr.join("</结束标签><开始标签>")+"</结束标签>";
                    

2、*数组拼接：添加元素的新方式

	将你传入的实参全部拼接到arr的末尾
	var newArr=arr.concat(新值1,arr1,...);
	特殊：
            1、不修改原数组，只会返回一个新数组
            2、concat支持传入数组参数，悄悄的将你传入的数组打散为单个元素再拼接

3、*截取子数组：

	根据你传入的开始下标截取到结束下标
	var subArr=arr.slice(starti,endi+1);
	特殊：
		1、不修改原数组，只会返回一个新数组
		2、含头不含尾
		3、endi可以省略不写，如果省略，会从starti位置一直截取到末尾
		4、starti也可以省略，如果两个实参都省略，那么会从头到尾完全的复制一份：此操作也叫做深拷贝 - 复制了一个副本给对方
		5、支持负数参数，-1代表倒数第1个

4、删插替：

删除：var dels=arr.splice(starti,n);//n代表删除的个数

	    特殊：直接修改原数组，返回的是被删除的数据组成的一个新数组

插入：arr.splice(starti,0,新值,...);

	    特殊：1、原starti位置的元素以及后续元素都会向后移动
	         2、插入一个数组，会导致我们的数组一些是一维，一些是二维

替换：var dels=arr.splice(starti,n,新值,...);

	    特殊：删除的个数和插入的个数不必相同

5、翻转数组：arr.reverse();

6、数组排序：

1、：冒泡排序：

2、开发时：arr.sort();

		默认：将数组中的元素转为字符串后，再按位PK每个字符的unicode号（ASCII码）
		希望按照数字升序排列：arr.sort(function(a,b){return a-b;}
		希望按照数字降序排列：arr.sort(function(a,b){return b-a;}	
		1、以后只要网页上有功能带有排序，他的底层一定是数组，因为js中只有数组可以排序
		2、以后只要网页上有随机的功能，那么他的底层一定用到了随机数公式！
                    

day2

1、数组的API：

1、栈和队列：添加元素和删除元素的新方式：
	开头进：arr.unshift(新值,...);添加元素的新方式，向前添加，
            缺点：导致其余元素的下标都发生变化
	开头出：var first=arr.shift();删除元素的新方式，向前删除，一次只能删除一个，
            缺点：导致其余元素的下标都发生变化
            结尾进：arr.push(新值,...);添加元素的新方式，向后添加。
	结尾出：var last=arr.pop();删除元素的新方式，向后添加。

	队列：其实就是数组，只不过一端进，从另一端出：
		开头进：arr.unshift(新值,...);
		结尾出：var last=arr.pop();
		结尾进：arr.push(新值,...);
		开头出：var first=arr.shift();
                    

2、二维数组：数组的元素，又引用着另一个数组

访问：arr[行下标][列下标];
特殊：列下标越界，返回undefined
     行下标越界，得到是一个报错
    遍历二维数组：必然两层循环，外层循环控制行，内层循环控制列
		

3、ES5还提供了3组6个API：

1、判断：2个

	every：每一个，要求所有元素都满足条件才会为true，只要有一个不满足则为false
		var bool=arr.every(function(val,i,arr){
			//val - 当前的值
			//i - 当前的值的下标
			//arr - 当前数组本身
			return 判断条件;
		})
                    
	some：有一些，要求只要有一个元素都满足条件会为true，所有元素都不满足则为false，非常类似于我们的||
		var bool=arr.some(function(val,i,arr){
			return 判断条件;
		})
                    

2、遍历：拿到数组中的每个元素做相同 或 相似的操作

	forEach - 直接修改原数组
		arr.forEach(function(val,i,arr){
			操作;
		})

	map - 不修改原数组返回一个新数组
		var newArr=arr.map(function(val,i,arr){
			return 操作;
		})

3、过滤和汇总：

	过滤：筛选出你需要的部分，但是和现实不一样的是原数组并不会发生变化
		var subArr=arr.filter(function(val,i,arr){
			return 判断条件;
	          	})

	汇总：
		var result=arr.reduce(function(prev,val,i,arr){
			return prev+val;
	          	},基础值)

4、ES6箭头函数：简化一切匿名回调函数的：

	固定公式：function去掉，()和{}之间添加=>，如果形参只有一个，那么()可以省略，如果函数体只有一句话，那么{}也可以省略，如果函数体只有一句话并且是return，那么return和{}都可以省略

4、String的概念：

多个字符组成的【只读】字符【数组】
    （只读：明天我们要学习的所有的字符串的API都不会修改原字符串，都会返回一个新的字符串）
和数组有相同点：
	1、字符串中的个数：str.length;
	2、获取字符串中的某个字符：str[i];
	3、遍历字符串
	4、所有数组不修改原数组的API，字符串也可以使用（concat、slice）
            
和数组也有很多不同的地方：
	所有数组的直接修改原数组的API，字符串都不可以使用，比如排序只有数组可以使用，但是
	字符串也有很多很多属于自己的API，等待我们明天学习

引用/对象类型：11个
	*String Number Boolean -> 包装类型
	*Array *Function Date（日期） Math（数学） *RegExp（正则：验证）
	Error（错误）
	*Object（面向对象开发方式）
	Global（全局对象）- 只有在浏览器中被window对象代替了， 自然保存着全局变量和全局函数，只不过window可以省略不写，有一天我们会去学习node.js这个后端语言，而在node.js中全局对象就叫做global

包装类型：专门用于将原始类型的值封装为一个引用类型的对象的
	原始类型的值原本就是没有任何属性和方法，意味着原始类型本身是不支持.去做任何操作的
	何时使用：只要你试图使用原始类型的变量调用属性或方法的时候，自动包装
	何时释放：方法调用完毕后，自动释放包装类型，又变成了原始类型

day03

1、转义字符：

	作用：
		1、将字符串中和程序冲突的字符转为原文 '\''        
		2、包含特殊功能的符号：
                    换行：\n
		制表符：\t大空格==tab按键效果
		3、输出unicode编码的字符

2、大小写转换：将字符串中的每个字符统一的转为大写 或 小写

	何时：只要程序不区分大小写，就要【先统一】的转为大写 或 小写，再比较 （做验证码）
	如何：
		大写：var upper=str.toUpperCase();
		小写：var upper=str.toLowerCase();

3、获取字符串中指定位置的字符：

            str.charAt(i)===str[i]

4、获取字符串中指定位置的字符的ASCII码：

            var ascii=str.charCodeAt(i);

        通过ASCII码转回原文：
	var 原文=String.fromCharCode(ascii);

5、检索字符串：检查索引，检查下标：获取关键字的下标

	var i=str/arr.indexOf("关键字",starti);
	从starti位置开始，查找右侧第一个关键字的第一个字符的位置
	starti可以省略，默认从0位置开始查找
	*返回值：找到了，返回第一个关键字的第一个字符的下标位置
		没找到，返回-1，其实我们根本不关心下标为多少，我们只关心下标为不为-1
	作用：判断
	强调：数组也能使用此方法，数组这个方法是后期才添加上的，原本此方法只有字符串可用，比如老IE的数组就没此方法。
	鄙视题：默认只能获取到第一个关键字的下标，如何才能获取到所有的关键字的下标？
		var str="no zuo no die no can no bibi no";
		var index=-1;
		while((index=str.indexOf("no",index+1))!=-1){
			console.log("找到了，下标为："+index);
		}

6、拼接字符串：

            var newStr=str.concat("新字符串",...) 还不如 +运算

7、截取字符串：3个

	var subStr=str/arr.slice(starti,endi+1);//用法和数组的用法完全一致
		   str.substring(starti,endi+1);//用法几乎和slice一致，但是不支持负数参数
		   str.substr(starti,n);//n代表的是截取的个数，不必考虑含头不含尾

8、替换字符串：

	var newStr=str.replace("固定关键字"/正则表达式,"新内容");

9、切割/分割/分隔字符串：

	作用：将字符串转为数组：
	var arr=str.split("自定义切割符");
	注意：
		1、切割后，切割符就不存在了
		2、如果你的切割符写的是""，切散每一个字符

10、去掉空白字符：

            str.trim 去除两端的空白/trimStart 去除开头的空白/trimEnd() 去除结尾的空白
            

day04

1、Math对象：专门提供了数学计算的API

强调：
    不需要创建，直接使用
属性：
    Math属性Math.PI
API：

1、取整：3种

	1、上取整：超过一点点，就取下一个整数
	var num=Math.ceil(num);//小数位数不能超过15位，否则此方法只能取整，不能上取整
            
	2、下取整：无论超过多少，都会省略小数部分
	var num=Math.floor(num);
            
	3、四舍五入取整：
	var num=Math.round(num);//只看小数位数的第一位

	以上三个方法都是：都是在取整，只能取整
		取整的方式：以上三个+*parseInt(str去掉单位)+*num.toFixed(d);
	num.toFixed(d); 
            优点：
               1、可以四舍五入，并且保留指定小数位数，d其实就是保留的小数位数
	   2、解决浏览器带来的舍入误差
              
	缺点：
               结果是一个字符串，可搭配上parseFloat()使用
               

2、乘方和开方：

	乘方：Math.pow(底数,幂);===== 更简化：底数**幂
	开方：Math.sqrt(num); - 仅仅只能开平方

3、最大值和最小值：

	var max/min=Math.max/min(....);自动在你传入的数字中比较出最大值或最小值，本身不支持数组参数
	解决方法：Math.max/min.apply(Math,arr);//apply具有打散数组的功能

4、绝对值：把负数转为正数

	Math.abs(-1);

5、随机数：Math.random(); 在0-1之间取一个随机的小数

	搭配上parseInt，只能取到0-1之间，意味着取不到最大值
	公式：parseInt(Math.random()*(max-min+1)+min)
	强调：随机的功能的底层一定用到了随机数

2、Date对象：日期对象，提供了操作日期和时间的API。

创建：4种

1、创建一个当前日期：

	var now=new Date();

2、创建一个自定义时间：

	var birth=new Date("yyyy/MM/dd hh:mm:ss");

3、创建一个自定义时间：

	var birth=new Date(yyyy,MM,dd,hh,mm,ss);//修改月份，从0~11，0代表1月

4、复制一个日期：

	日期的所有API都是直接修改原日期的，无法获得修改之前的日期所以，在执行API之前先进行复制，然后再操作复制后的日期
	var end=new Date(start);

使用：2类

1、两个日期对象之间，可以相减（大-小），得到一个毫秒差，换算出自己想要的任何一部分 - 日期的本质其实就是保存了一个毫秒数 - 做倒计时的关键

	创建日期的最后一种方式，绝对没人用：var date=new Date(毫秒数);//计算机元年:1970年1月1日 8点整

2、API：

	分量：时间的单位
	年月日星期：FullYear Month Date Day
	时分秒毫秒：Hours Minutes Seconds Milliseconds
	每一个分量都有一对儿getXXX/setXXX的方法
	其中getXXX负责获取一个分量的值
	其中setXXX负责设置一个分量的值

特殊：

1、取值范围：

	FullYear - 当前年份的数字
	Month - 0~11
	Date - 1~31
	Day - 0~6：0代表是星期天，外国人的眼里星期天才是一周的第一天的
	Hours - 0~23
	Minutes、Seconds：0~59

2、Day，没有set方法

3、如果希望对某个分量进行加减操作：

	date.setXXX(date.getXXX()+/-n)

4、格式化日期为本地字符串：

	date.toLocaleString()：具有兼容性问题，

3、定时器：

1、周期性定时器：每过一段时间就会执行一次，先等后做

	开启：
            timer=setInterval(callback,间隔毫秒数);
	停止：
            clearInterval(timer);

2、一次性定时器：等待一段时间，只会做一次就结束了

	开启：
            timer=setTimeout(callback,间隔毫秒数);
	停止：
            clearTimeout(timer);
	同步技术：
            代码必须一行一行的执行，前面没做完，后面就等着

day05

1、BOM：Browser Object Model - 浏览器对象模型：专门用于操作浏览器的，但是它使用的不多，远不如ES和DOM，浏览器很多操作都是自带的，而且BOM没有标准，

		         各个浏览器都有自己的定义，但是大部分浏览器的都是一致规范的，除了老IE（8-）

2、window对象：扮演着两个角色：

1、全局对象：

      保存着全局变量和全局函数

2、指代当前窗口本身：

属性：

1、获取浏览器的完整大小：

      outerWidth/outerHeight

2、*获取浏览器的文档显示区域的大小：

      innerWidth/innerHeight - 获取每台电脑的浏览器的文档显示区的大小

3、获取屏幕的完整大小：

      跟window没关系：screen.width/height; 

方法：

1、*打开链接的新方式：

		1、当前窗口打开，可以后退：
			HTML：<a href="url">内容</a>
			       JS：open("url","_self");

		2、当前窗口打开，禁止后退：使用场景：
			history：当前【窗口的历史记录】，他其实可以做的事儿就是前进后退
			location：当前【窗口正在打开的url】，有一个API：
			location.replace("新url");//叫做替换，不叫做跳转

		3、新窗口打开，可以打开多个
			HTML：<a href="url" target="_blank">内容</a>
			       JS：open("url","_blank");

		4、新窗口打开，只能打开一个：使用场景：比如电商网站，只允许用户打开一个结账页面
			HTML：<a href="url" target="自定义一个name">内容</a>
			       JS：open("url","自定义一个name");

		    a标签的其他用途：
				1、跳转
				2、锚点
				3、下载按钮：<a href="xx.exe/rar/zip/7z">下载</a>
				4、打开图片和txt文档：<a href="xx.png/jpg/jpeg/gif/txt">打开图片和txt</a>
				5、直接书写js-不需要绑定点击事件：<a href="javascript:js代码;">打开图片和txt</a>

2、打开新窗口/新链接：

                  newW=open("url","target","width=?,height=?,left=?,top=?");
	      特殊：1、如果没有加第三个参数，那么窗口会和浏览器融为一体
			          2、如果你加了第三个参数，那么窗口会脱离浏览器独立存在

3、关闭窗口：

                 window/newW.close();

4、改变新窗口的大小：

                 newW.resizeTo(新宽,新高);

5、改变新窗口的位置：

                 newW.moveTo(新X,新Y);

6、*window提供了三个框：

		警告框：alert("警告文字");
		输入框：var user=prompt("提示文字");
		确认框：var bool=confirm("提示文字");

7、*****定时器也是window的

8、事件：

		1、window.onload事件 - load - 加载：等待其他所有的资源加载完毕后才会执行的代码，放在里面的代码其实要最后才会执行
		2、*window.onresize事件 - 窗口如果大小发生了变化，就会触发，搭配上判断innerWidth可以理解为是js版本的css媒体查询
		3、***window.onscroll事件 - 滚动事件，一旦滚动就会触发
			1、获取滚动条当前的位置：window.scrollY
			2、获取元素距离页面顶部有多远：elem.offsetTop/offsetLeft

9、*****本地/客户端存储技术：

		cookie：淘汰了，存储的大小只有2kb，而且操作极其麻烦，尤其要到处切割，只能最多保存30天
		webStorage：H5带来了一个新特性，存储的大小有8mb，永久保存，而且非常简单
			分类2种：
			1、sessionStorage - 会话级，只要浏览器一旦关闭，数据就会死亡了
			2、localStorage - 本地即，只要你不清空，就会永久存在
			两者的用法是一模一样的，不用创建，直接可用
			操作：

			1、添加：xxxStorage.属性名="属性值";
			2、读取：xxxStorage.属性名;
			3、删除：xxxStorage.removeItem("属性名");
			4、清空：xxxStorage.clear();