JavaScript内置对象

内置对象

• JavaScript对象有3种，自定义、内置、浏览器
• 自定义和内置属于ECMAScript，第3种js独有
• 内置对象有Math、Date、Array、String等

文档查阅： MDN

Math

内置对象	方法
Math	PI、Max([value1,[value2,…]])……

方法：

Math.PI //圆周率
Math.floor(0) //向下（小）取整
Math.ceil(0) //向上（大）取整
Math.round(0) //四舍五入 就近取整 注意 -3.5 结果是 -3
Math.abs(0) //绝对值 去负号 放入字符串返回NaN
Math.max(1,2) //最大值
Math.min(1,2) //最小值
Math.random() //没有参数，随机返回[0,1)之间的浮点数：0.47456839376946336

注意1：

Math.Max(1,2,3,"4") // 有字符串会返回：NaN
Math.Max() // 返回-infinity，负无穷，正无穷是最大的数；
typeof Infinity // "number"
typeof 100 // "number"

注意2：

Math.round(-0.5) // -0
if(-0===0){1}else{2} // 1

得到两数之间随机整数，包括两数，可以用0和2代入min、max看看算法；

function getRandomIntInclusive(min,max){
	return Math.floor(Math.random()*(Math.floor(max)-Math.ceil(min)+1))+min
}
getRandomIntInclusive(1,100)

var random=getRandomIntInclusive(1,10);
var d=5;
for(var i=1;i<=d;i++){//死循环
	var num=prompt('猜数字，1~10')
	if(num>random){
		alert('你猜大了');
	}else if(num<random){
		alert('你猜小了');
	}else{
		alert('你好帅哦，猜对了');
		break; //退出while循环
	}
	alert('你还有'+(d-i)+'次机会啦~')
}

Date

new Date() // Wed May 19 2021 16:21:00 GMT+0800 (中国标准时间)
var d=new Date();
console.log(date.getfullYear()); //返回当前日期的年份 2021

方法名	说明	结果
getFullYear()	当年	2021
getMonth()	当月（0-11）	4
getDate()	当天日期	19
getDay()	星期几（周日0到周六6）	3
getHours()	小时	16
getMinutes()	分	57
getSeconds()	秒	12

时间戳【距离1970年1月1日0点过去的毫秒数】

方法	结果
new Date().valueOf()	1621415392577
new Date().getTime()	1621415392578
Date().now()（H5新增方法）	1621415392578
+new Date()	1621439044038

注意1：

Date() // "Wed May 19 2021 17:21:45 GMT+0800 (中国标准时间)"
new Date() //Wed May 19 2021 17:21:52 GMT+0800 (中国标准时间)
typeof new Date()// "object"
typeof Date()// "string"

倒计时：

function countDown(time){
	var times=(+new Date(time)-+new Date())/1000; //times时剩余时间的总毫秒数
	var t = [parseInt(times/3600/24),parseInt(times/3600%24),parseInt(times/60%60),parseInt(times%60)]; //天、时、分、秒
	for(i in t){if(t[i]<10){t[i]='0'+t[i]}};
	return t[0]+'天'+t[1]+'时'+t[2]+'分'+t[3]+'秒';
}
console.log(countDown('2021-5-25 12:57'))

数组

new Array(); // []
new Array(2); // [empty × 2]
new Array(2,3); // [2,3]

反转数组

function reverse(arr){
	if(arr instanceof Array){
		var newArr=[];
		for(var i=arr.length-1;i>=0;i--){
			newArr[newArr.length]=arr[i];
		}
		return newArr;
	}else{
		return '这个参数要求必须是数组格式~'
	}
}
console.log(reverse([1,2,3]));
console.log(reverse(1,2,3));

检测是否为数组

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

对数组增减元素：

• unshift([a,[b…]])/push([a,[b…]])从数组前/后增加0~n个元素；
• 增加后返回新数组.length；
• pop()和shift()删除1个元素，并返回删除的元素；

var arr=[];
console.log(arr.push(13,'harry'));
console.log(arr.unshift('harry',13));
console.log(arr.pop());
console.log(arr.shift());
for(var i=0;i<6;i++){arr.push(i)};
console.log(arr);
// 结果：2、4、harry、harry、[13, 13, 0, 1, 2, 3, 4, 5]

数组自带函数
sort

['a','b','c'].reverse(); // 翻转数组
[9,3,5].sort(); // 排序

var arr=[1,13,6,66,234,16.5];
// 冒泡排序
function mppx(arr){
	var a=0;
	for(var i=arr.length-1;i>0;i--){
		for(var j=0;j<i;j++){
			if(arr[j]>arr[j+1]){
				a=arr[j];
				arr[j]=arr[j+1];
				arr[j+1]=a;
			}
		}
	}return arr;}
console.log(mppx(arr));
// sort排序正确用法
console.log(arr.sort(function(a,b){return a-b})); //前-后：升序
console.log(arr.sort(function(a,b){return b-a})); //后-前：降序
console.log(arr.sort((a,b)=>b-a))

indexOf

// 返回数组元素索引号方法：indexOf([a,[b..]])；
// 如果数组中有多个元素，只返回第一个的索引；
// 如果找到不，则返回-1；
// lastIndexOf([a,[b..]])则是从后开始查找；
var arr=[1,2,3,1];
console.log(arr.indexOf(1));
console.log(arr.indexOf(4));
console.log(arr.lastIndexOf(1));

除重

var a=[1,2,1]
function unique(arr){
	var brr=[];
	for(var i=0;i<arr.length;i++){
		brr.indexOf(arr[i])==-1 ? brr.push(arr[i]) : 0
	}
	return brr
}
console.log(unique(a))

转字符串

方法名	说明	返回值
concat()	连接两个或多个数组，不影响原数组	合并后的新数组
slice()	数组截取slice(start,end)，[begin,end)是左开右闭的，不影响原数组	被截取项目组成的新数组
splice()	数组删除splice(start,deleteCount,…items)，注意：这个会影响元数组	返回被删除项目组成的新数组

var a=[1,2,3],b=[3,3,3],c=[];
console.log(c.concat(a,b)); // [1, 2, 3, 3, 3, 3]
console.log(c); // []

var r=3;for(var i=0;i<r;i++){for(j=0;j<r;j++){console.log(a.slice(i,j))}};
// []、[1]、[1, 2]、[]、[]、[2]、[]、[]、[]

var a=[1,2,3];console.log(a.splice(2,1));console.log(a);
// [3]、[1,2]

字符串

基本包装类型

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

字符串的不可变
因为字符串的不可变，不要大量的拼接字符串

var a='harry';console.log(a);a='footy';

源理：

1. 变量a 指向 值为harry的内存A
2. a=‘footy’时，内存A中’harry’这个值并没有改成’footy’
3. 而是让变量a指向新开辟的内存B，B的值为’footy’
4. 不断新建字符串会占用较多内存；

返回字符串位置

// arr.indexOf(searchElement,?fromIndex)
var a='床前明月光，疑是地上霜，举头望明月';
console.log(a.indexOf('月')) // 3
console.log(a.indexOf('月',4)) // 16

查找字符串’abcoefoxyozzopp’中所有o出现的位置以及次数

var s='abcoefoxyozzopp',e='o'
function findStr01(s,e){
	var i=s.indexOf(e),arr=[];
	while(i !== -1){
		arr.push(i)
		i=s.indexOf(e,i+1)
	}
	return arr
}
findStr01(s,e)

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

方法名	说明	使用
charAt(index)	返回指定位置的字符(index 字符串的索引号)	str.charAt(0)
charCodeAt(index)	获取指定位置处字符的ASCII码(index索引号)	str.charCodeAt(0)
str[index]	获取指定位置处字符	HTML5，IE8+支持 和charAt()等效

判断一个字符串’abcoefoxyozzopp’中出现次数最多的字符，并统计其次数

function CountStr(s){
	var o={},e,max=0,arr=[]
	for(var i=0;i<s.length;i++){
		e=s.charAt(i);
		o[e] ? o[e]++ : o[e]=1;
	}
	for(k in o){
		o[k]>max ? max=o[k] : 0
	}
	for(k in o){
		o[k]==max ? arr.push(k) : 0
	}
	return [arr,max]
}
CountStr('abcoefoxyozzopppp')

方法名	说明
concat(str1,str2…)	concat()方法用于连接两个~多个字符串，等效于+，+更常用
substr(start,length)	从开始位置截取字符串，length是个数(从截取的位置开始算第一个)
slice(start,end)	从start位置开始，截取到end位置，end取不到
substring(start,end)	从start位置开始，截取到end位置，end取不到，基本和slice相同，但是不接受负值

替换字符串

var s='andyandy';
s.replace('a','b');
function replaceAll(s,e,f){
	while(s.indexOf(e)!==-1){
		s=s.replace(e,f)
	}
	return s
}
replaceAll(s,'a','h');

分割字符串

var s='a,b,c';console.log(s.split(','));
console.log('a&b&c'.split('&'));
s.toUpperCase()

英文字母转换大小写

"A,B,C".toLowerCase() //"a,b,c"
"a,b,c".toUpperCase() //"A,B,C"

简单类型与复杂类型

简单类型又叫做基本数据类型或者值类型，复杂类型又叫做引用类型。

• 值类型：简单数据类型/基本数据类型，在存储时变量中存储的是值本身，因此叫做值类型
  string,number,boolean,underfined,null(数据类型是object)
• 引用类型：复杂数据类型，在存储时变量中存储的仅仅是地址（引用），因此奇偶奥做引用数据类型，通过new关键字创建的对象（系统对象、自定义对象），如Object，Array，Date等

和字符串数据不同，数字类型的数据，不需要开辟新的内存空间，直接找到原地址修改值；

函数的形参也可以说看作是一个变量，当我们把引用类型变量传给形参时，其实是把变量在栈空间里保存的堆地址复制给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象。