Javascript 对象二(Number、String、Boolean、Array、Date、Math、RegExp)
- Number 数字 对象
- String 字符串 对象
- Boolean 布尔 对象
- Array 数组 对象
- Date 日期 对象
- Math 算数 对象
- RegExp 正则表达式 对象
Number 数字 对象
- JavaScript中 数字不分为整数类型和浮点型类型,所有的数字都是由 浮点型类型。
- 有 JavaScript 数字均为 64 位
- 精度:整数最多为 15 位,小数的最大位数是 17
- 八进制:前缀为 0。绝不要在数字前面写零,除非您需要进行八进制转换。
- 十六进制: 前缀为 0 和 “x”
- 输出16进制、8进制、2进制的方法:使用 toString() 方法
var myNumber=128;
myNumber.toString(16); // 返回 80
myNumber.toString(8); // 返回 200
myNumber.toString(2); // 返回 10000000
- 无穷大(Infinity):正无穷大(Infinity),负无穷大(-Infinity)
- NaN 非数字值:用于指示某个值不是数字
- 判断一个值是否是 NaN 值: 使用 isNaN() 全局函数来判断
- 数字可以是数字或者对象。数字对象:
String 字符串 对象
字符串语法:
var str = 'hello';
var str = "hello";
var str = "'hello I'm Lotus" //字符串引号与内容引号不同
var str = 'hello I\'m Lotus' //转义字符
var str = "hello \" Lotus\""
// 特殊字符:
\' 单引号
\" 双引号
\\ 反斜杠
\n 换行
\r 回车
\t tab制表符
\b 退格符
\f 换页符
字符串属性和方法:
length: 计算返回字符串长度
var str = "Lotus";
var str1 = ' hello "小微"'
document.write(str.length); // 5
document.write(str1.length); // 11
chartAt(): 返回指定索引位置的字符
chartCodeAt(): 返回指定所以位置的Unicode值
concat() : 字符串连接,返回连接后的字符串
indexOf() :返回查找指定字符第一次出现的位置
lastIndexOf() : 返回查找指定字符最后一次出现的位置
match() :找到一个或者多个正则表达式的匹配
replace() :替换与正则表达式匹配的子串
search() :检索与正则表达式相匹配的值
slice():返回提取的字符串片段
split() :把字符串分隔为子字符串数组
substr() :从起始索引提取字符串中指定数目的字符
substring():提取字符串两个指定的索引之间的字符
toLowerCase():把字符串转为小写
toUpperCase() :把字符串转为大写
toString() :返回字符串对象值
trim() :移除字符串首尾空白
valueOf() :返回某个字符串对象的原始值
let str = "hello lotus";
document.write(str.charAt(1)); // e
document.write(str.charCodeAt(1)); // 101let str1 = 'hello wang';
document.write(str.concat(str1)); //hello lotushello wang
document.write(str.concat(str1, 'abc', '123')); // hello lotushello wangabc123
document.write(str); // hello lotus
Boolean 布尔 对象
Boolean 对象用于转换一个不是 Boolean 类型的值转换为 Boolean 类型值 (true 或者false).
var myvar = new Boolean(1);
myvar.constructor; // function Boolean() { [native code] }var bool = new Boolean(0);
var myvar = bool.valueOf(); // false
布尔对象无初始值或者其值为: 0 -0 null “” false undefined NaN,对象的值为 false
Array 数组 对象
- 数组: 使用单独的变量名来存储一系列的值
- 创建数组:
1) 字面量
let array = [];
let arr = ['hello', 'world'];2)构造函数
let arr = new Array(0;
arr[0] = 'hello'
简写:let arr = new Array('hello', 'world');3) ES6新增的Array.of()方法
var arr=Array.of()
var arr=Array.of(1,2,3)
- 访问数组:及索引访问数组的特定元素,第一个元素索引是[0],第二个是[1], 最后一个是 arr.length - 1
- 数组检测: isArray() 、instanceof、.costructor、Object.prototype.toString.call([])==="[object Array]"、
let arr = [];
arr.isArray() // true
arr instanceof Array // true
arr.constructor == array //true
Object.prototype.toString.call(arr)==="[object Array]" //true
- 数组的属性和方法:
lenght
:返回数组的长度,也可以用来截断数组
var arr=[1,2,3,4,5];
console.log(arr.length); //5 ,返回数组的元素个数
arr.length=3; //截断数组
console.log(arr); //1,2,3
push()
:向数组的尾部添加一项或多项;参数为单个值或者数组 ;
//返回添加元素后数组的长度;会改变原数组
var arr=[1,2,3];
console.log(arr.push('a')); //4 (4) [1, 2, 3, "a"]
console.log(arr.push(['a','b','c'])); //5 (5) [1, 2, 3, "a", Array(3)]
pop()
:删除数组最后一项;无参数;返回删除的那一项;会改变原数组
var arr=['a','b','c'];
var tmp=arr.pop();
console.log(tmp); //c (1)['a','b']
unshift()
: 向数组开头添加一项或多项;参数为单个值或者数组 ;
//返回添加元素后数组的长度;会改变原数组
var arr=[1,2,3];
console.log(arr.unshift()('a'));//4 (4) ["a",1, 2, 3]
console.log(arr.unshift()(['a','b','c']));//5 (5) [Array(3),"a",1, 2, 3]
shift()
:向数组开头删除一项;无参数;返回删除的那一项;会改变原数组
var arr=['a','b','c'];
var tmp=arr.shift();
console.log(tmp); //c (1)['b','c']
splice()
: 删除、插入、替换数组项;有参数;返回删除项组成的数组;会改变原数组
var arr=['a','b','c','d','e','f'];
var tmp1=arr.splice(0,1);//删除一项
console.log(arr,tmp1);//["b", "c", "d", "e", "f"], ["a"]
var tmp2=arr.splice(1,1,'aaa');//替换一项
console.log(arr,tmp2);// ["b", "aaa", "d", "e", "f"], ["c"]
var tmp3=arr.splice(1,3,'bbb');//插入、替换多项
console.log(arr,tmp3);// ["b", "bbb", "f"], ["aaa", "d", "e"]
copyWithin()
:ES6新增,将数组指定位置(start to end)的元素复制到当前数组的其他位置(target)
这种复制会替换原位置的元素;返回替换之后的数组;改变原数组
var arr=['a','b','c','d','e','f'];
var tmp1=arr.copyWithin(3);//用索引0~4范围内的元素,替换索引3~4范围内的元素
console.log(arr,tmp1);//["a", "b", "c", "a", "b", "c"],["a", "b", "c", "a", "b", "c"]
var temp2 = arr.copyWithin(3, 2);//用索引2~4范围内的元素,替换索引3~4范围内的元素
console.log(arr, temp2); // ["a", "b", "c", "c", "a", "b"],["a", "b", "c", "c", "a", "b"]
reverse()
: 翻转原数组;无参数;返回翻转后的数组;会改变原数组
var arr = [1, 2, 3];
var temp = arr.reverse();
console.log(arr, temp); // [ 3, 2, 1 ] [ 3, 2, 1 ]
sort()
:数组排序;参数compareFunction(compareFunction返回值>0时调换当前顺序,否则顺序不变)
返回排序后的数组;会改变原数组//从小到大排序
var arr = [1, 4, 6, 7, 8, 3, 2];
var tmp = arr.sort();//从小到大排序
console.log(arr,tmp); //[1, 2, 3, 4, 6, 7, 8],[1, 2, 3, 4, 6, 7, 8]
var tmp2=arr.sort().reverse();//从大到小排序
console.log(arr, tmp2); // [8, 7, 6, 4, 3, 2, 1],[8, 7, 6, 4, 3, 2, 1] var tmp1 = arr.sort((a, b) => { //从小到大排序return a - b;
})
console.log(arr, temp1); // [ 1, 2, 3, 4, 6, 7, 8 ] [ 1, 2, 3, 4, 6, 7, 8 ]
var tmp1 = arr.sort((a, b) => { //从大到小排序return b - a;
})
console.log(arr, temp1); // [ 1, 2, 3, 4, 6, 7, 8 ] [ 1, 2, 3, 4, 6, 7, 8 ]
concat()
:拼接数组;参数类型可以是任意类型;返回拼接后的数组;原数组不发生改变
var arr=[1,2,3];
var arr1=arr.concat(); //复制
console.log(arr,arr1); //[1, 2, 3],[1, 2, 3]
slice()
: 基于当前数组的一项或者多项创建一个数组;不会改变原数组
let arr = [0, 1, 2, 3, 4];
let temp = arr.slice(1,3); // 返回从索引1(包括)位置到索引3(不包括)位置之前的元素
console.log(arr, temp); // [0, 1, 2, 3, 4] [1, 2]
let arr = [0, 1, 2, 3, 4]; //用于复制数组
let temp = arr.slice(0); // 返回从索引0(包括)位置到数组结尾的所有元素
console.log(arr, temp); // [0, 1, 2, 3, 4] [0, 1, 2, 3, 4]
indexOf()
: 从数组开头查找元素在数组中的索引位置;返回在数组中的索引,没找到则返回-1
var arr=['a','b','c'];
var tmp=arr.indexOf('b');
console.log(arr,tmp); //["a", "b", "c"] , 1
-
lastIndexOf() :从数组结尾查找元素在数组中的索引位置
-
遍历数组的方法:
-
传统方法:
for循环、for...in循环、for...of循环
for:
for(let i=0;i<arr.length;i++){console.log(arr[i]); // a b c 1 2 3
}for...in
for(var i in arr){console.log(i); // 0 1 2 3 4 5console.log(arr[i]); //a b c 1 2 3
}for...of
for(var item of arr){console.log(item); //a b c 1 2 3 undefined
}for… in 、 for… of 的区别:1、推荐在循环对象属性的时候,使用for in,在遍历数组的时候推荐使用for of2、for…in 循环出来的是key, for…of循环出来的是value3、for…in 是ES5 标准,for …of 是ES6标准,兼容性可能存在些问题,请注意使用4、for...in 循环除了遍历数组元素外,还会遍历自定义属性,for...of只可以循环可迭代的可迭代属性,不可迭代属性在循环中被忽略了
forEach() 、 map() 、 filter() 、every() 、 some()
forEach方法
:被传递给foreach的函数会在数组的每个元素上执行一次;元素作为参数传递给该函数。
!* 未赋值的值是不会在foreach循环迭代的,但是手动赋值为undefined的元素是会被列出的
var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];
arr.forEach( function( element, index ) { //ES5console.log( index, element ); //0:"a" , 1:"b" , 2:"c" , 3:1 , 4:2 , 5:3
})
arr.forEach( ( element, index ) => { //ES6console.log( index, element ); //0:"a" , 1:"b" , 2:"c" , 3:1 , 4:2 , 5:3
})
map方法
:通过callback对数组元素进行操作;并将所有操作结果放入数组中并返回该数组。
var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];var arr1 = arr.map( function( item ) { //ES5return item + "*";
})var arr1 = arr.map( item => { //ES6return item + "*";
})console.log(arr1);
//["a*", "b*", "c*", undefined × 1, "undefined*", "1*", "2*", "3*"]
3)filter方法
:返回一个包含所有在回调函数上返回为true的元素新数组,
回调函数在此担任的是过滤器的角色,当元素符和条件,过滤器就返回true,而filter则会返回所有符合过滤条件的元素
var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];var arr1 = arr.filter( function ( item ) { //ES5if ( typeof item == 'number' ){return item;}
})
var arr1 = arr.filter( item => { //ES6if ( typeof item == 'number' ) return item;
})
console.log(arr1); //[1,2,3]
4)every方法
: 当数组中的每一个元素在callback上被返回true时就返回true
(注意:要求每一个单元项都返回true时才为true)
var arr=['a', 'b', 'c', , undefined, 1, 2, 3,];var resault = arr.every( function ( item ) { //ES5console.log( item );//a ,b ,c ;到1判断为假结束遍历,返回falseif ( typeof item == 'string' ) return item;
})
var resault = arr.every( item =>{ //ES6if ( typeof item == 'string' ) return item;
})console.log(resault); //false
every()与filter()的区别是:
后者会返回所有符合过滤条件的元素;
前者会判断是不是数组中的所有元素都符合条件,并且返回的是布尔值
some方法
:只要数组中有一项在callback上就返回true
every()与some()的区别是:前者要求所有元素都符合条件才返回true,
后者要求只要有符合条件的就返回true
Date 日期 对象
- 创建 Date 对象:
new Date()
let d = new Date(); //Thu May 14 2020 14:27:45 GMT+0800 (中国标准时间)let d = new Date(millisecond); //
- Date 对象的方法:
Math 算数 对象
执行常见的算数任务。
toFixed()
: 把 Number 四舍五入为指定小数位数的数字。
var num =2.446242342;
num = num.toFixed(2); // 输出结果为 2.45
round(参数)
: 四舍五入。舍入与数字最接近的整数
Math.round(1); // 1
Math.round(2.4); // 2
Math.round(2.5); // 5
//不能真正的四舍五入,有精度问题
可以通过以下方式来确保精度是正确的:
var num =2.446242342;
num = Math.round((num + Number.EPSILON) * 100) / 100; // 输出结果为 2.45
random()
:返回 0 到 1 之间的随机数max(参数1,参数2)
:返回两者的最大者min(参数1,参数2)
:返回两个给定的数中的较小的数
let a = 1, b = 2;
let arr = [1,2,4,0]
Math.max(a, b) // 2
Math.min(a, b) // 1
Math.max(...arr); // 4
abs(参数)
:返回数的绝对值ceil(参数)
: 向上取舍floor(参数)
: 向下取舍toSource()
:返回对象的各个属性值
Math.abs(-2) // 2
Math.abs(2) // 2Math.ceil(2.123) // 3
Math.floor(2.123) // 2