JS标准库
# 一、Object对象
# 1.概述
Object本身是一个函数,可以当作工具方法使用,将任意值转为对象。这个方法常用于保证某个值一定是对象。
obj instanceof Object //instanceof验证一个对象是否为指定的构造函数的实例
value === Object(value); //判断变量是否为对象
1
2
2
Object构造函数可以接受一个参数,如果该参数是一个对象,则直接返回这个对象;如果是一个原始类型的值,则返回该值对应的包装对象
# 2.Object 的静态方法
Object.keys(obj) //返回可枚举属性的数组
Object.getOwnPropertyNames(obj) //返回对象属性的数组(包含不可枚举)
1
2
2
(1)对象属性模型的相关方法
Object.getOwnPropertyDescriptor() //获取某个属性的描述对象。
Object.defineProperty(object, propertyName, attributesObject) //通过描述对象,定义某个属性。
Object.defineProperties() //通过描述对象,定义多个属性。
1
2
3
2
3
(2)控制对象状态的方法
Object.preventExtensions(obj) //防止对象扩展。
Object.isExtensible(obj) //判断对象是否可扩展。
Object.seal(obj) //禁止对象配置。
Object.isSealed(obj) //判断一个对象是否可配置。
Object.freeze(obj) //冻结一个对象。
Object.isFrozen(obj) //判断一个对象是否被冻结。
1
2
3
4
5
6
2
3
4
5
6
(3)原型链相关方法
Object.create() //该方法可以指定原型对象和属性,返回一个新的对象。
Object.setPrototypeOf(obj) //取代_proto_对原型的处理【写】
Object.getPrototypeOf(obj) // 取代_proto_对原型的处理【读】
1
2
3
2
3
# 3.Object 的实例方法
Object.prototype.valueOf() //返回当前对象对应的值。
Object.prototype.toString() //返回当前对象对应的字符串形式。
Object.prototype.toLocaleString() //返回当前对象对应的本地字符串形式。
Object.prototype.hasOwnProperty() //判断某个属性是否为当前对象自身的属性,还是继承自原型对象的属性。
Object.prototype.isPrototypeOf() //判断当前对象是否为另一个对象的原型。
Object.prototype.propertyIsEnumerable() //判断某个属性是否可枚举。
Object.prototype.toString.call(value) //可用于判断数据类型
1
2
3
4
5
6
7
2
3
4
5
6
7
# 属性描述对象
JavaScript 提供了一个内部数据结构,用来描述对象的属性,控制它的行为,比如该属性是否可写、可遍历等等。这个内部数据结构称为“属性描述对象”(attributes object)。每个属性都有自己对应的属性描述对象,保存该属性的一些元信息。
{ //属性描述对象提供6个元属性
value: 123, //该属性的属性值,默认为undefined
writable: false, //属性值value是否可改变,默认为true
enumerable: true, //该属性是否可遍历,默认为true
configurable: false, //可配置性,默认为true
get: undefined, //属性的取值函数(getter),默认为undefined
set: undefined //属性的存值函数(setter),默认为undefined
}
1
2
3
4
5
6
7
8
2
3
4
5
6
7
8
# 4.ES6对象扩展
Object.is(x,y) //用来比较两个值是否严格相等。
Object.assign(target,source1,source2.......) //合并源对象的所有可枚举属性到目标对象
Object.keys(obj) //返回可枚举属性的数组
Object.values(obj) //遍历对象可枚举的属性的键值,返回数组
Object.entries(obj) //遍历对象可枚举的属性的键值对,返回数组;
1
2
3
4
5
2
3
4
5
# 二、Array对象
# 1.ES5数组方法
Array.isArray(arr) //判断是否为数组
arr.valueOf() //返回数组本身
arr.toString() //返回数组的字符串形式
arr.push() //数组的末端添加元素,并返回添加新元素后的数组长度(会改变原数组)
arr.pop() //删除数组的最后一个元素,并返回该元素(会改变原数组)
arr.shift() //删除数组的第一个元素,并返回该元素(会改变原数组)
arr.unshift() //在数组的第一个位置添加元素,并返回添加新元素后的数组长度(会改变原数组)
arr.join() //以指定参数作为分隔符,将所有数组成员连接为一个字符串返回
arr.concat() //多个数组的合并
arr.reverse() //颠倒排列数组元素,返回改变后的数组(会改变原数组)
arr.slice(start, end) //提取目标数组的一部分,返回一个新数组(原数组不变)
arr.splice(start, count, addElement1, addElement2, ...); //删除原数组的一部分成员,并可以在删除的位置添加新的数组成员,返回值是被删除的元素(会改变原数组)
arr.sort() //对数组成员进行排序,默认是按照字典顺序排序(会改变原数组)
arr.map((elem, index, arr)=>{ ...}) //将数组的所有成员依次传入参数函数,然后把每一次的执行结果组成一个新数组返回 (三个参数:当前成员、当前位置和数组本身。)
arr.forEach((elem, index, arr)=>{ ...}) //与map类似,不返回值
arr.filter((elem, index, arr)=>{ ...}) //过滤数组成员,满足条件的成员组成一个新数组返回
arr.some((elem, index, arr)=>{ ...}) //判断数组成员是否部分符合某种条件
arr.every((elem, index, arr)=>{ ...}) //判断数组成员是否全部符合某种条件
arr.reduce((a,b, index, arr)=>{ ...}) //从左到右处理数组的每个成员并累计为一个值
arr.reduceRight((a,b, index, arr)=>{ ...}) //从右到左处理数组的每个成员并累计为一个值
arr.indexOf() //返回给定元素在数组中第一次出现的位置(可第二个参数:搜索的开始位置)
arr.lastIndexOf() //返回给定元素在数组中最后一次出现的位置,没有返回-1.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
# 2.ES6数组扩展
Array.of(1,2,3) //将参数中所有值作为元素形成数组。输出[1,2,3]
Array.from(arrayLike[, mapFn[, thisArg]]) //将类数组对象或可迭代对象转化为数组。
arr.find(item => item > 2) //查找数组中符合条件的元素,若有多个符合条件的元素,则返回第一个元素。
arr.findIndex(item => item = 1) //查找数组中符合条件的元素索引,若有多个符合条件的元素,则返回第一个元素索引。
arr.fill(target[,startIndex,endIndex]) //将一定范围索引的数组元素内容填充为单个指定的值。
arr.copyWithin(target, start = 0, end = this.length)//将一定范围索引的数组元素修改为此数组另一指定范围索引的元素。
arr.entries() //返回一个键值对的迭代器
arr.keys() //返回一个键名的迭代器
arr.values() //返回一个键值的迭代器
arr.includes(target,start=0) //数组是否包含指定值
arr.flat(num=1) //数组扁平化,返回一个数组。默认拉平一层,参数Infinity将转为一维数组。
arr.flatMap(x => [[x * 2]) //先对数组中每个元素进行了的处理,再对数组执行 flat() 方法。
1
2
3
4
5
6
7
8
9
10
11
12
13
2
3
4
5
6
7
8
9
10
11
12
13
# 三、Boolean对象
Number、String、Boolean这三个原生对象可以把原始类型的值变成(包装成)对象。
valueOf()方法返回包装对象实例对应的原始类型的值。
toString()方法返回对应的字符串形式。
Boolean对象除了可以作为构造函数,还可以单独使用,将任意值转为布尔值。
# 四、Number对象
Number对象是数值对应的包装对象,可以作为构造函数使用,也可以作为工具函数使用。
# 1.静态属性和方法
Number.POSITIVE_INFINITY //正的无限,指向Infinity。
Number.NEGATIVE_INFINITY //负的无限,指向-Infinity。
Number.NaN //表示非数值,指向NaN。
Number.MIN_VALUE //表示最小的正数(即最接近0的正数,在64位浮点数体系中为5e-324),相应的,最接近0的负数为-Number.MIN_VALUE。
Number.MAX_SAFE_INTEGER //表示能够精确表示的最大整数,即9007199254740991。
Number.MIN_SAFE_INTEGER //表示能够精确表示的最小整数,即-9007199254740991。
Number.prototype.toString() //将一个数转为字符串形式
Number.prototype.toFixed() //将一个数转为指定位数的小数,然后返回这个小数对应的字符串
Number.prototype.toExponential() //将一个数转为科学计数法形式
Number.prototype.toPrecision() //将一个数转为指定位数的有效数字
1
2
3
4
5
6
7
8
9
10
11
2
3
4
5
6
7
8
9
10
11
# 2.ES6数值扩展
Number.EPSILON //表示 1 与大于 1 的最小浮点数之间的差。它的值接近于 2.2204460492503130808472633361816E-16,或者 2-52。
Number.isFinite(value) //用于检查一个数值是否为有限的( finite ),即不是 Infinity
Number.parseInt(value) //用于将给定字符串转化为指定进制的整数。
Number.parseFloat(value) //用于将给定字符串转化为指定进制的浮点数。
Number.isInteger(value) //用于判断给定的参数是否为整数。
Number.isNaN(value) // 用来检查一个值是否为NaN。
Number.isSafeInteger(value) //用于判断数值是否在安全范围内。
1
2
3
4
5
6
7
2
3
4
5
6
7
# 五、Math对象
# 1.静态属性和方法
Math.E //常数e。
Math.LN2 //2 的自然对数。
Math.LN10 //10 的自然对数。
Math.LOG2E //以 2 为底的e的对数。
Math.LOG10E //以 10 为底的e的对数。
Math.PI //常数π。
Math.SQRT1_2 //0.5 的平方根。
Math.SQRT2 //2 的平方根。
Math.abs() //绝对值
Math.ceil() //向上取整
Math.floor() //向下取整
Math.max() //最大值
Math.min() //最小值
Math.pow() //指数运算
Math.sqrt() //平方根
Math.log() //自然对数
Math.exp() //e的指数
Math.round() //四舍五入
Math.random() //随机数
//三角函数方法
Math.sin() //返回参数的正弦(参数为弧度值)
Math.cos() //返回参数的余弦(参数为弧度值)
Math.tan() //返回参数的正切(参数为弧度值)
Math.asin() //返回参数的反正弦(返回值为弧度值)
Math.acos() //返回参数的反余弦(返回值为弧度值)
Math.atan() //返回参数的反正切(返回值为弧度值)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
# 2.ES6扩展
Math.cbrt(x) //立方根
Math.imul(val1,val2) //两个数以 32 位带符号整数形式相乘的结果,返回的也是一个 32 位的带符号整数。
Math.hypot(..values) //用于计算所有参数的平方和的平方根。
Math.clz32(x) //用于返回数字的32 位无符号整数形式的前导0的个数。
Math.trunc(x) //用于返回数字的整数部分。
Math.fround(x) //用于获取数字的32位单精度浮点数形式。
Math.sign(x) //判断数字的符号(正、负、0)。
Math.expm1(x) //用于计算 e 的 x 次方减 1 的结果,即 Math.exp(x) - 1 。
Math.log1p(x) //用于计算1 + x 的自然对数,即 Math.log(1 + x) 。
Math.log10(x) //用于计算以 10 为底的 x 的对数。
Math.log2(x) //用于计算 2 为底的 x 的对数。
Math.sinh(x) //用于计算双曲正弦。
Math.cosh(x) //用于计算双曲余弦。
Math.tanh(x) //用于计算双曲正切。
Math.asinh(x) //用于计算反双曲正弦。
Math.acosh(x) //用于计算反双曲余弦。
Math.atanh(x) //用于计算反双曲正切。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
# 六、String对象
# 1.属性和方法
String.fromCharCode() //根据一到多个Unicode码点,返回这些码点组成的字符串。
str.length //返回字符串的长度
str.charAt(i) //返回指定位置的字符
str.charCodeAt(i) //返回字符串指定位置的 Unicode 码点
str.concat(str2) //连接两个字符串,返回一个新字符串,不改变原字符串
str.slice(start,end) //从原字符串取出子字符串并返回,不改变原字符串
str.substring(start,end) //从原字符串取出子字符串并返回,不改变原字符串
str.substr(start,end) //从原字符串取出子字符串并返回,不改变原字符串,跟slice和substring方法的作用相同。
str.indexOf(str2) //str2在str中第一次出现的位置 可以接受第二个参数:开始匹配的起始位置
str.lastIndexOf(str2) //str2在str中最后一次出现的位置 可以接受第二个参数:开始匹配的起始位置
str.trim() //去除字符串两端的空格
str.toLowerCase() //将字符串转为小写
str.toUpperCase() //将字符串转为大写
str.match(str2) //原字符串是否匹配某个子字符串,返回一个数组[可用于正则表达式]
str.search() //等同于match方法,返回值为匹配的第一个位置[可用于正则表达式]
str.replace(str2,str3) //用于替换匹配的子字符串[可用于正则表达式]
str.split(str2) //分割字符串,组成数组(接受第二个参数,限定返回数组的最大成员数)
str.localeCompare(str2) //比较两个字符串
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 2.ES6扩展
str.includes(str2[,start=0]) //返回布尔值,判断是否找到参数字符串。
str.startsWith(str2[,start=0]) //返回布尔值,判断参数字符串是否在原字符串的头部。
str.endsWith(str2[,start=0]) //返回布尔值,判断参数字符串是否在原字符串的尾部。
str.repeat(str2) //返回新的字符串,表示将字符串重复指定次数返回。
str.padStart(str2) //返回新的字符串,表示用参数字符串从头部(左侧)补全原字符串。
str.padEnd(str2) //返回新的字符串,表示用参数字符串从尾部(右侧)补全原字符串。
str.trimStart(str2) //返回新的字符串,消除字符串头部的空格。
str.trimEnd(str2) //返回新的字符串,消除字符串尾部的空格。
str.matchAll(regex) //返回一个迭代器:正则表达式在当前字符串的所有匹配。
1
2
3
4
5
6
7
8
9
2
3
4
5
6
7
8
9
# 七、Date对象
两个日期实例对象进行减法运算时,返回的是它们间隔的毫秒数;进行加法运算时,返回的是两个字符串连接而成的新字符串。
# 1.构造函数
new Date(1378218728000) // 参数为时间零点开始计算的毫秒数
new Date('January 6, 2013'); // 参数为日期字符串
new Date(2013, 0, 1, 0, 0, 0, 0) // 参数为多个整数,// 代表年、月、日、小时、分钟、秒、毫秒
1
2
3
2
3
# 2.方法
Date.now() //返回当前时间距离时间零点(1970年1月1日 00:00:00 UTC)的毫秒数
Date.parse(str) //用来解析日期字符串,返回该时间距离时间零点的毫秒数。
Date.UTC() //接受年、月、日等变量作为参数,返回该时间距离时间零点的毫秒数。
var d = new Date();
d.valueOf() //返回实例对象距离时间零点对应的毫秒数
d.toString() //返回一个完整的日期字符串。
d.toUTCString() //返回对应的 UTC 时间
d.toISOString() //返回对应时间的 ISO8601 写法。
d.toJSON() //返回一个符合 JSON 格式的 ISO 日期字符串,与toISOString方法的返回结果完全相同
d.toDateString() //返回日期字符串(不含小时、分和秒)
d.toTimeString() //返回时间字符串(不含年月日)
d.toLocaleString() //完整的本地时间。
d.toLocaleDateString() //本地日期(不含小时、分和秒)。
d.toLocaleTimeString() //本地时间(不含年月日)。
d.getTime() //返回实例距离1970年1月1日00:00:00的毫秒数,等同于valueOf方法。
d.getDate() //返回实例对象对应每个月的几号(从1开始)
d.getDay() //返回星期几,星期日为0,星期一为1,以此类推。
d.getFullYear() //返回四位的年份。
d.getMonth() //返回月份(0表示1月,11表示12月)。
d.getHours() //返回小时(0-23)。
d.getMilliseconds() //返回毫秒(0-999)。
d.getMinutes() //返回分钟(0-59)。
d.getSeconds() //返回秒(0-59)。
d.getTimezoneOffset() //返回当前时间与 UTC 的时区差异
d.setDate(date) //设置实例对象对应的每个月的几号(1-31),返回改变后毫秒时间戳。
d.setFullYear(year [, month, date]) //设置四位年份。
d.setHours(hour [, min, sec, ms]) //设置小时(0-23)。
d.setMilliseconds() //设置毫秒(0-999)。
d.setMinutes(min [, sec, ms]) //设置分钟(0-59)。
d.setMonth(month [, date]) //设置月份(0-11)。
d.setSeconds(sec [, ms]) //设置秒(0-59)。
d.setTime(milliseconds) //设置毫秒时间戳。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
# 八、RegExp对象
var regex = new RegExp('xyz', 'i'); //等价于 /xyz/i;
1
# 1.实例属性与方法
RegExp.prototype.ignoreCase //返回一个布尔值,表示是否设置了i修饰符。
RegExp.prototype.global //返回一个布尔值,表示是否设置了g修饰符。
RegExp.prototype.multiline //返回一个布尔值,表示是否设置了m修饰符。
RegExp.prototype.flags //返回一个字符串,包含了已经设置的所有修饰符,按字母排序。
RegExp.prototype.test(str) //返回一个布尔值,表示当前模式是否能匹配参数字符串
RegExp.prototype.exec(str) //返回匹配成功的子字符串的数组
String.prototype.match(RegExp) //返回一个数组,成员是所有匹配的子字符串。
String.prototype.search(RegExp) //按照给定的正则表达式进行搜索,返回一个整数,表示匹配开始的位置。
String.prototype.replace(RegExp) //按照给定的正则表达式进行替换,返回替换后的字符串。
String.prototype.split(RegExp) //按照给定规则进行字符串分割,返回一个数组,包含分割后的各个成员。
1
2
3
4
5
6
7
8
9
10
11
12
2
3
4
5
6
7
8
9
10
11
12
# 2.ES6新增
RegExp.prototype.unicode //返回一个布尔值,表示是否设置了u修饰符。
RegExp.prototype.sticky //返回一个布尔值,表示是否设置了y修饰符。
RegExp.prototype.flags //返回正则表达式的修饰符。
String.prototype.matchAll(regex) //返回一个迭代器:正则表达式在当前字符串的所有匹配。
1
2
3
4
2
3
4
上次更新: 2020/09/27, 13:09:00