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';
源理：
- 变量a 指向 值为harry的内存A
- a=‘footy’时，内存A中’harry’这个值并没有改成’footy’
- 而是让变量a指向新开辟的内存B，B的值为’footy’
- 不断新建字符串会占用较多内存；
返回字符串位置
// 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等
和字符串数据不同，数字类型的数据，不需要开辟新的内存空间，直接找到原地址修改值；
函数的形参也可以说看作是一个变量，当我们把引用类型变量传给形参时，其实是把变量在栈空间里保存的堆地址复制给了形参，形参和实参其实保存的是同一个堆地址，所以操作的是同一个对象。