11、JavaScript内置对象

内置对象基础：

Js中对象分为三大类：

1、自定义的对象：可以利用对象封装自己的数学对象

2、浏览器对象

3、内置对象：常用的方法，定义好的对象

查阅文档：

查阅文档MDN、W3C

先查阅对象的功能

Math

不是不是构造函数 所以不需要用new来调用直接使用即可

Math.PI //圆周率

Math.floor() //向下取整

Math.ceil() //向上取整

Math.round() //四舍五入 ，就近取整

Math.abs() //绝对值

Math.max()/Math.min() //最大和最小值

random（）取到随机整数

//我们想要得到两个数之间的随机整数，并且包含着首尾的2个整数 
Math.floor(math.random() * (max - min + 1))+min;  

function getRandom(min , max){
	return Math.floor(math.random()*(max-min +1))+min; 
}

​ string.length 获取字符串的长度 返回值为数值型

new Date().getDay() //获取星期 返回值(0-6)

Date

Date()方法的使用:构造函数:

1、获取当前时间必须实例化

var now = new Date(); console.log(now);

2、Date()构造函数的参数

如果括号里有时间，就返回参数里面的时间。

例如日期格式字符串为’2019-5-1’，可以写成new Date(‘2019-5-1’),或者new Date(‘2019/5/1’)

日期格式化：

dObj.getFullYear() //获取当年

dObj.getMonth() //获取当月(0-11)

dObj.getDate() //获取当天日期

dObj.getDay() //获取星期几（周日0 到周六6）

dObj.getHours() //获取当前小时

dObj.getMinutes() //获取当前分钟

dObj.getSeconds() //获取当前秒钟

dObj.getTime() //返回当前毫秒数

时间补0：h = h>10 ? ‘0’+h :h

时间戳:

​ valueOf()

​ getTime()

​ //获得Date的总毫秒数（时间戳） 不是当前的时间毫秒数，而是距离1970-1-1号过了多少毫秒

1、通过valueOf() getTime()

var date = new Date();
console.log(date.valueOf());  
//就是我们现在时间距离1970-1-1号过了多少毫秒 console.log(date.getTime());

2、简单的写法（最常用的写法）

var date1 = +new Date(); 
//+new Date()  返回的就是总的毫秒数 console.log(date1);

3、H5新增的 获得总的毫秒数

console.log(Date.now());

倒计时

//倒计时 
//1、核心算法：输入的时间减去现在的时间就是剩余的时间，即倒计时，但是不能拿着时分秒相减，比如05分减去25分，结果会是负数的 
//2、用时间戳来做，用户输入时间总的毫秒数减去现在时间的总的毫秒数，得到的就是剩余时间的毫秒是 
//3、把剩余时间的毫秒数转换为天、时、分、秒（时间戳转换为时分秒）

//转换公式如下 d = parseInt(总秒数 /60 /60 /24);   
//计算天数 h = parseInt(总秒数 /60 /60 %24);   
//计算小时 m = parseInt(总秒数 /60 %60);   
//计算分钟 s = parseInt(总秒数 %60);   
//计算当前秒数

Array

检测是否为数组

(1)instanceof检测是否为数组

var arr = []; 
var obj = {}; 
console.log(arr instanceof Array) 
console.log(obj instanceof Array)

(2)Array.isArray(参数); H5新增的方法 ，ie9以上版本支持

console.log(Array.isArray(arr)) 
console.log(Array.isArray(obj))

​

添加/删除数组方法

push(参数1…) 末尾增加一个或多个元素，返回值：返回新的长度

unshift(参数1…)向数组开头添加一个或多个元素，返回值：返回新的长度

pop()删除数组最后一个元素，数字长度减1，返回值：删除它元素的值

shift()删除数组第一个元素，数字长度减1，返回值：返回第一个元素的值

push（）：数组末尾添加一个或多个数字元素

//添加删除数组元素方法
//1、push()在我们数组的末尾 添加一个或者多个数组元素 push推 
var arr = [1, 2 , 3]; //
arr.push(4, 'pink'); 
console.log(arr.push(4,'pink')); 
console.log(arr); 
//1、push是可以给数组追加新的元素 
//2、push()参数直接写新数组元素就可以了 
//3、push完毕之后，返回的结果是，新数组的长度 
//4、原数组也会发生变化

​

unshift：数组前面增加元素

console.log(arr.unshift('red' , 'purple'));
console.log(arr); 
//1、unshift是可以给数组前面追加新的元素 
//2、unshift()参数直接写，数组元素就可以个 
//3、unshift完毕之后，返回的结果是新数组的长度 
//4、原数组也会发生变化

pop：删除数组最后一个元素

console.log(arr.pop());
console.log(arr); 
//1、pop是可以删除数组最后一个元素，一次只能删除一个 
//2、pop()没有参数 
//3、pop完毕之后，返回的结果是 删除的那个元素 
//4、原数组也会发生变化

​

shift：删除数组第一个元素

console.log(arr.shift()); 
console.log(arr); 
//1、shift是可以删除数组第一个元素，一次只能删除一个 
//2、shift()没有参数 
//3、shift完毕之后，返回的结果是 删除的那个元素 
//4、原数组也会发生变化

翻转数组

reverse() ,颠倒数组中元素的顺序，无参数，该方法会改变原来的数组，返回新数组

var arr = [1 , 2 , 3]; 
arr.reverse(); 
console.log(arr);

数组排序

sort（）:数组排序

sort(),对数组的元素进行排序，该方法会改变原来的数组，返回新数组

//个位数排序 var arr = [1 , 2 , 3]; 
//数组排序（冒泡排序） 
arr.sort(); 
console.log(arr); 

//多位排序 
var arr1 = [13 , 4 , 77 , 1 , 7]; 
arr1.sort(function(a,b){
	//return a-b; 升序的顺序排列  return b-a; 降序的顺序排列 
}); 
console.log(arr1);

​

数组索引方法

indexOf() 数组中查找给定元素的第一个索引 ，存在返回索引号，不存在，返回-1

arr.indexOf('a')

lastIndexOf() 在数字中的最后一个索引 ，存在返回索引号，不存在，返回-1

arr.lastindexOf('a')

数组去重案例

算法：遍历旧数组，拿着旧数组元素查询新数组，没有添加，否则不添加 
数组去重['c','a','z','a','x','a','x','c','b']要求去除数组中重复的元素 
1、目标：把旧数组里面不重复的元素选取出来放到新的数组中，重复的元素只保留一个，放到新数组中去重 
2、核心算法：遍历旧数组，拿着旧数组元素去查询新数组，如果该元素在新数组没出现过，我们就添加，否则不添加 
3、我们怎么知道该元素没有存在？利用新数组.indexOf(数组元素)，如果返回时-1，就说明数组里面没有该元素 
封装一个 去重的函数unique 独一无二的 

function unqier(arr){  
    var newArr = [];  
    for(var i = 0 ;i <arr.length ;i++){    
        if(newArr.indexOf(arr[i]) === -1){      
            newArr.push(arr[i]);    
        }  
    }  
    return newArr; 
} 

var demo = unique();

数组转换为字符串：

1、toString():将我们数组转换为字符串，逗号分隔每一项 ，返回一个字符串

var arr = [1 ,2 ,3]; console.log(arr.toString()); //1,2,3

2、join(‘分隔符’)：把数组中所有元素转换为一个字符串，返回一个字符串

var arr = [1,2,3]; console.log(arr.join());  //1,2,3 
console.log(arr.join('-')); //1-2-3 
console.log(arr.join('&')); //1&2&3

​

数组连接/截取/splice：

concat()： 连接两个或多个数组， 不影响原数组，返回一个新的数组

slice() ：数组截取 slice(begin,end) ,返回被截取项目的新数组

splice()： 数组删除splice(第几个开始，要删除的个数) ，返回被删除项目的新数组，这个会影响原数组

String

字符串对象：

基本包装类型：：就是把简单数据类型包装成为了复杂数据类型

var str = 'andy'; 
console.log(str.length); 
//对象才有属性和方法 ，复杂数据类型才有属性和方法 
//简单数据类型为什么会有length属性呢？ 
//1、把简单数据类型包装为复杂数据类型 var temp = new String('andy'); 
//2、把临时变量的值给str str =temp; 
//3、销毁这个临时变量 temp = null;

**一共有三种基本包装类型 ：**String、Boolean、Number

​

**字符串不可变：**看似变化了，实际上是地址变了

//值得里面的值不可变，看上去是改变了内容，实际是地址改变了，开辟了新的空间 
var str = 'abc'; 
str = 'hello'; //当重新给str赋值时候，常量abc不会被修改，仍然在内存中 
//重新给字符串赋值，会在内存中重新开辟空间，这个特点就是字符串的不可变 
//由于字符串的不可变，在大量拼接字符串时候会有效率问题 
//例子： 
var str = ''; for(
    var i = 0 ;i < 1000000 ; i++){
    	str += i; 
} console.log(str);  //这个结果需要花费大量时间，因为需要不断开辟新的空间

​

根据字符返回位置

indexOf(‘要查找的字符’, 开始的位置)

//返回指定内容在原字符串的位置，如果找不到就返回-1 ，开始的位置是index索引号

lastIndexOf

//从后往前找，只找第一个匹配的

//字符串对象 根据字符返回位置 
str.indexOf('要查找的字符'，[起始的位置]) 
var str = '改革春风吹满地，春天来了' 
console.log(str.indexOf('春'));

​

根据位置返回字符（重点）

charAt(index)

//返回指定位置的字符（index 字符串的索引号） 使用：str.charAt(0)

​ arCodeAt(index)**

//获取指定位置处字符ASCII码（index索引号） 使用：str.charCodeAt(0)

str[index]

//获取指定位置处字符 H5，IE8+ 和charAt()等效

根据位置返回字符

//1、charAt(index) 根据位置返回字符

var str = 'andy';

console.log(str.charAt(3));

//遍历所有字符

for(var i = 0 ;i<str.length ;i++){

console.log(str.charAt(i));

}


//2、charCodeAt(index)返回相应索引号字符ASCII值 目的：判断用户按下了那个键

console.log(str.charCodeAt(0));//97


//3、str[index] H5新增

console.log(str[0]); //a

字符串操作方法js

concat(str1,str2,str3…) //用于连接两个或多个字符串

substr(start,length) //从start位置开始(索引号)，length取得个数，重点记住这个

slice(start,end) //从start位置开始，截取到end位置，end取不到(他俩都是索引号)

substring(start,end) //从start位置开始，截取到end位置，end取不到，基本和slice相同，但不接受负值

**replace(‘被替换的字符’,‘替换为的字符’)：**字符转为数组

split(‘分隔符’)

toUpperCase（）转化大写

toLowerCase（）转换小写

字符串操作方法：

concat(str1,str2,str3…)

//concat('字符串1','字符串2') 
var str = 'andy' 
console.log(str.concat('red'));

substr(start,length)

//substr('截取的起始位置开始','截取几个字符') 
var str = 'andy' 
console.log(str.substr(2,2));
//第一个2，是索引的2，第二个2 ，是取2个字符

replace(‘被替换的字符’,‘替换为的字符’)

//替换字符replace('被替换的字符','替换为的字符') 它只会替换第一个字符 
var str = 'andyandy' 
console.log(str.replace('a' , 'b')); 
//有一个字符串，'abcoefoxyozzopp' 要求把里面所有o替换为* 
var str = 'abcoefoxyozzopp'; 
while(ste1.indexOf('o' !==-1) ){ 
    str1 = str1.replace('o','*')
}
console.log(str1);

split(‘分隔符’)转换为数组

2、字符转为数组 split('分隔符') 前面学过join 把数组转换为字符串 

var str2 = 'red,pink,blue'; 
console.log(str2.split(',')); 
var str3 = 'red,pink,blue'; 
console.log(str2.split('&'));

简单数据类型/复杂类型：

简单类型又叫做基本数据类型或值类型，

复杂类型又叫做引用类型

**值类型：**简单数据类型/基本数据类型，在存储时变量中存储的是值本事，因此叫做值类型

string ，number ，boolean，undefined，null

**引用类型：**复杂数据类型，在存储变量时变量中存储的仅仅是地址（引用）因此叫做引用数据类型

通过new关键字创建的对象（系统对象、自定义对象）如object 、array、Date等

​

堆和栈

堆栈空间分配区别：

1、栈:由操作系统自动分配释放存放函数的参数值，局部变量的值等，其操作方式类似于数据结构中的栈

简单数据类型存放带栈里面

2、堆，存放复杂数据类型，一般由程序员分配释放，若程序员不是放，由垃圾回收机制回收

复杂数据类型存放到堆里面

​

简单数据类型和复杂数据类型传参

简单数据类型传参：直接赋值，不会影响

复杂数据类型传参：

复杂类型的内存分配：

**引用类型（复杂数据类型）：**通过new关键字创建的对象（系统对象，自定义对象）如

Object、array、Date等

引用类型变量（栈空间）里存放的是地址，真实的对象存放在堆空间里

​

复杂类型传参：传递的是地址

函数的形参也可看作是一个变量，当我们把引用类型变量传给形参时，

其实是把栈空间里保存的地址复制给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象

//复杂类型传参 
function Person(name){  
    this.name = name; 
} function f1(x){ 
    //x = p  console.log(x.name); //这个输出什么,刘德华  
    x.name = '张学友'  
    console.log(x.name);//这个输出什么,刘德华 
} 
var p = new Person("刘德华") 
console.log(p.name);//这个输出什么,张学友 
f1(p); 
console.log(p.name);//这个输出什么,张学友