js（字符串，数组，对象，作用域链，js运行规则，函数，数据类型）

基础语法

输入输出

prompt（‘这是一个输入框’）//弹出一个输入框 --> 获取的值是string类型
alert（‘这是一个输出框’）//弹出一个输出框
console.log('控制台输出')//在控制台输出

变量

本质：变量是内存中存放数据的空间
特殊情况：
	var age；//undefined
	console.log(tel) //未声明，会直接报错
	age = 100 === var age = 100
命名特点：
	1. 区分大小写
	2. 不能以数字开头
	3. 不能以&符号开头		

数据类型

数字型的三个特殊值：
	infinity: 无穷大
	-infinity：无穷小
	NaN：非数字
	判断一个值是否为数字：isNaN（参数）//返回一个boolean类型
string类型：
	字符串转义：
		\n : 换行 
		\\ : 斜杠\
		\' : 单引号'
		\" : 双引号"
		\t : 缩进
		\b : 空格
	字符串拼接： 数字相加，字符相连	
boolean：
	参与运算时，true==1 ，false==0	
undedined: 未定义具体类型
	与字符相连：  
		var age;
		console.log(age + 'a') // undefineda
	与数字相连：
		var age = 100；
		console.log(age + 12)// NaN
NULL：空值 ---> 是object类型
	与字符相连：  
		var age = null;
		console.log(age + 'a') // nulla
	与数字相连：
		var age = null；
		console.log(age + 12)//  12			
类型转换：
	1. 转换为字符串
		* 值.toString（）
		* String(参数)
		* 利用+号拼接字符串
	2. 转换为数字型
		* parseInt（参数）-->整数
		* parseFloat（参数）-->浮点型
		* Number（参数）
		* 利用 - * /号进行隐式转换
转换为boolean（）函数
	Boolean（' '）-->false
	Boolean（0）-->false
	Boolean（NaN）-->false
	Boolean（null）-->false
	Boolean（undefined）-->false
	其他全为true

预算符

逻辑中断：
	console.log(22 && 254) // 254		
运算符优先级：

三元表达式

条件表达式 ？ 表达式1 ： 表达式2  条件表达式为true 执行表达式1，条件表达式为false，执行表达式2.
var age = 18;
var result = age === 18 ? console.log(true) : console.log(false);

switch表达式

switch(表达式){//表达式输出value时，调用第一个case，不然直接调用defalut.
	case value：
		执行语句；
		break;
	......
	defalut:
		执行最后的语句；
}

数组

创建数组：
	数组里的数值可以是不同的类型
	方式一：var arr = new Array();
	方式二：var arr = [];
访问数组元素：
	arr【索引】 
遍历数组：
	方式一：for循环	
追加数组：
	arr【索引】= 值 //如果索引占用了，则替换原来的数组元素	
空数组：长度为5的数组，只有三个值，剩下的两个空元素值为：undefined

函数

形参默认值为：undefined。		
函数没有return，返回undefined。

arguments

argunments可以接收所有传递进来的参数。
function fn(){
	console.log(arguments)//[1,2,3,4...]
}
fn(1,2,3,4)

js作用域

全局作用域：
	全局变量
局部作用域：
	局部变量：只能在函数内部使用，如果没有声明，则会自动升级成全局变量。
	function fun（）{
		var num = 10；
		num1  = 20；
	}
	console.log(num);//undefined
	console.log(num1); //20;

作用域链

一个函数套一个函数
var num = 10;
function fun（）{
		var num = 20；
		fun1（）；
		function fun1（）{
			console.log(num);//20; 就近原则
		}
}
fun() //20	

js运行规则

/*
            js引擎在执行代码时分为两步：1.预解析，2.代码执行
            1. 预解析：将所有var 和 function 提升到当前作用域的最前面
                1.1：变量提升：将所有变量声明提升到当前作用域的最前面，不进行赋值操作
                2.2: 函数提升：将所有函数声明提升到当前作用域的最前面，不调用函数
        */
        console.log(num); //undefined;
        var num = 10
        /* 实际执行的代码
            var num;
            console.log(num);
            num = 10;
        * */

        fun();//报错 fun is not a function
        var fun = function() {//函数表达式
            console.log('老子是函数');
        }
        /*实际执行的代码
        * var fun
        * fun();
        * fun = function(){
        *   console.log('老子不是函数');
        * }
        * */
		//经典例子
        f1();
        console.log(c);
        console.log(b);
        console.log(a);

        function f1() {
            var a = b = c = 9;//相当于 var a = 9;b =9;c=9;
            //如果是集体声明应该是：var a=9,b=9,c=9;
            console.log(a);
            console.log(b);
            console.log(c);
        }
        /*实际执行的代码
            var b = 9;
            var c =9;
          function f1(){
                var a=9;
                console.log(a);//9
                console.log(b);//9
                console.log(c);//9
         }
         f1();
            console.log(c);//9
            console.log(b);//9
            console.log(a);//报错：undefined
        */

对象

创建对象：
	var obj = new Object();
	var obj = {}；
	var obj【key】 = value;
调用对象：
	obj【‘key’】
	obj.key	
构造函数：
	function 构造函数名（）{
		this.属性 = 值；
		this.方法 = function（）{}
	}
new 关键字的执行过程：
	1. new 构造函数可以在内存中创建一个空的对象
	2. this就会指向刚才创建的空对象
	3. 执行构造函数的代码
	4. 返回这个新对象（所以构造函数不需要return）
遍历对象：
	for...in..遍历对象
	for（变量 in 对象）{
		执行语句
	}

如何查阅文档

1. 查阅该方法的功能
2. 查看里面参数的意义和类型
3. 查看返回值的类型
4. 使用一个demo进行验证和练习

内置对象

Math对象
	Math.abs:取绝对值
	Math.floor: 往下取整
	Math.ceil: 往上取整
	Math.round: 四舍五入
	Math.random:返回一个0到1之间的随机浮点数
		如何获取随机整数？
		Math.floor(Math.random() * 3)//0-2 之间的整数，包括0和2
		Math.floor(Math.random() * (max - min + 1)) + min //包括最大值和最小值
Date对象
	date.getFullYear(): 获取年
	date.getMonth(): 获取月份
	date.getDate(): 获取几号
	date.getDay(): 获取星期
	date.getHoures(): 获取小时
	date.getMinutes(): 获取分钟
	date.getSeconds(): 获取秒
	获取时间戳
		1. date.valueOf(): 现在距离 1970.1.1总的毫秒数
		2. date.getTime()
		3. var date1 = +new Date(): 返回的就是总的毫秒数
		4. var date2 = +new Date(参数)：返回的是用户输入时间总的毫秒数
		5. Date.now()
	时间错转日期对象 new Date（时间戳） 
Array对象
	检测是否为数组：
		1. 参数 instanceof 类型 //返回boolean类型
		2. Array.isArray(参数) //返回boolean类型
	添加删除数组：
		push（参数）：将传入的参数添加在数组的末尾	//返回的是新数组长度
		unshift（参数）：将传入的参数添加在数组的前面  //返回的是新数组长度
		pop（）：无参数，删除数组最后一个元素 //返回的是删除的元素，一次只能删除一个元素
		shift（）：无参数，删除数组的第一个元素//返回的是删除的元素，一次只能删除一个元素
	排序数组：	
		reverse（）：无参数，翻转数组
		sort()：无参数，冒泡排序
			arr.sort(function(a,b){
				return a-b; //升序
				return b-a；//降序
			})
	返回数组索引号：
		indexOf（数组元素）;
			//返回第一个满足条件的索引号
			//如果找不到元素，则返回 -1
		lastIndexOf（数组元素）
			//返回最后一个满足条件的索引号
			//如果找不到元素，则返回 -1	
	数组转化为字符串：
		toString（），无参数，将数组转化为字符串
		join（分隔符），使用分隔符对数组进行分割，数组元素分隔符数组元素	
	数组的合并，截取和删除：
		var arr3 = arr1.concat（arr2）；将arr1和arr2合并为arr3，不改变arr1和arr2

/*
            slice()返回一个新数组，不改变原数组
            当参数只有一个时：参数不代表数组的索引，而是那个数组元素，如：第三个元素，第1个元素
                如：
                    arr.slice(1)//指第一个数组元素，返回除第一个数组元素之外的其他元素组成的新数组
                    arr.slice(2)//指第二个数组元素，返回除第一个数组元素和第二个数组元素之外的其他元素组成的新数组
            当参数有两个时：参数代表数组的索引，第二个索引的元素不会包含在新数组中
                如：
                    arr.slice(2,4)//指由arr[2]到arr[3]元素组成的新数组
                    arr.slice(3,5)//指由arr[3]到arr[4]元素组成的新数组
         */
        var arr = [1,2,3,5,6,7,8];
        console.log(arr.slice(1));//2,3,5,6,7,8
        console.log(arr.slice(2,4));//3,5

        console.log('---------------')
        /*
            splice()不会返回新数组，会改变原数组
            splice()的参数有三个：
                参数一：参数不代表数组的索引，而是那个数组元素，如：第三个元素，第1个元素
                参数二：删除几个元素
                参数三：添加的元素，参数三以后的参数都与参数三一样
            例：
                arr.splice(3,1);
                此处参数有两个，
                    3代表第三个数组元素，即arr[2],
                    1代表删除1个arr[2]之后的数组元素，即删除arr[3]
                arr.splice(2,0,'aaa');
                此处参数有三个，
                    2代表第2个数组元素，即arr[1],
                    0代表删除0个arr[1]之后的数组元素
                    'aaa'代表在arr[1]之后添加的数组元素
                arr.splice(2,1,'bbb');
                此处参数有三个，
                    2代表第2个数组元素，即arr[1],
                    1代表删除1个arr[1]之后的数组元素，即删除arr[2]
                    'bbb'代表在arr[1]之后添加的数组元素,即arr[2] = bbb
        */
        //arr.splice(2,0,'aaa');
        //console.log(arr);//1,2,aaa,3,5,6,7,8
       // arr.splice(2,0,'aaa','bbb');
        //console.log(arr);//1,2,aaa,bbb,3,5,6,7,8
        // arr.splice(3,1);
        // console.log(arr);//1,2,3,6,7,8
        arr.splice(2,1,'bbb');
        console.log(arr);//1,2,bbb,5,6,7,8

字符串

字符串不可变性：
	var str ='aaa';
	console.log(str)//aaa
	str = 'bbb';
	console.log(str)//bbb 此时上去str的值改变了，但实际上只是内存地址的指向改变了，原来aaa开辟的内存空间并没有消失，还是存在的。这种特性被称为字符串的不可变性
查找特定字符：
	indexOf(参数，起始位置) 
		* 参数一：查找的值
		* 参数二：从哪个位置开始找，默认0
		* 如果找不到则返回-1
		* 返回参数的位置
	lastindexOf（参数）
		* 从最后开始找，找不到返回-1
根据位置查找字符： 
	charAt（索引值） //返回字符
	charCodeAt（索引值）//返回相应索引号的字符的ASCII值
	str[索引值] //获取指定位置处字符			
字符串操作
	concat（str1，str2）//等效于+号

 /*
            substring(参数1，参数2)
            参数1：表示从哪个字符开始
            参数2：表示从参数一开始截取几个字符，不包括最后的字符
            参数不能为负数
        */
        var str1 = '各个村税费吹翻落地各'//
        var str2 = str1.substring(1,3);
        console.log(str2);//个村
        /*
            slice(参数1，参数2)
            参数1：表示从哪个字符开始
            参数2：表示在哪个字符结束，不包括最后的字符
                如果参数2为负数，那么实际的值为： 字符串长度+参数2。
                即：str.length = 7
                    slice(1,-2)-->slice(1,5);
        */
        var str3 = str1.slice(2,4);
        console.log(str3);//村税
        var str4 = str1.slice(2,-4);
        console.log(str4);//村税费

        /*
            replace(参数一，参数二)
            参数一：需要替换的字符
            参数二：替换的字符
            此方法会替换第一个查找到的字符，后面的不进行替换
            此方法会改变源字符串
            返回替换后的字符串
            替换全部的字符：replaceAll(参数一，参数二)
        */
        console.log(str1.replaceAll('各','替'))
        /*
            split('分隔符')
            根据分割符来将字符串转化为数组
         */
        var strNew = 'red,blue,pink';
        var strArr = strNew.split(',');//通过 ， 来将字符串转化为数组
        console.log(strArr);
        /*
            转化字符大小写
            toUpperCase()//全部转化为大写，返回一个新字符串
            toLowerCase()//全部转化为小写，返回一个新字符串
         */