JavaScript内置对象

我是素萌萌哒
273 阅读8分钟

Object

静态属性、方法名注释

6️⃣ assign

6️⃣ is

1.修正NaN和±0

🍀 create

1.create(proto[, propertiesObject])

🍀 defineProperty

🍀 defineProperties

1.configurable | enumerable | value | writable | get | set

6️⃣ entries

6️⃣ values

6️⃣ keys

6️⃣ fromEntries

1.Map或者二维数组转对象

🍀 freeze

🍀 isFrozen

1.已冻结的对象不能添加新属性

2.不能删除已有属性

3.不能修改已有属性的可枚举/可配置性/可写性/值

4.原型也不能修改

🍀 seal

🍀 isSealed

1.封存对象，阻止添加新属性

2.将现有所有属性标记为不可配置

3.当前的值之前如果可写就可以改变

🍀 preventExtensions

🍀 isExtensible

1.对象不可扩展，永远不能再添加新属性

6️⃣ getOwnPropertyDescriptor

6️⃣ getOwnPropertyDescriptors

1.返回对象自有属性的属性描述符

🍀 getOwnPropertyNames

1.返回自身属性包括不可枚举属性组成的数组

2.不包括Symbol属性

6️⃣ getOwnPropertySymbols

1.只返回自身所有Symbol属性组成的数组

6️⃣ getPrototypeOf

6️⃣ setPrototypeOf

🍀 prototype

原型属性、方法名注释

🍀 __proto__

🍀 valueOf

🍀 constructor

🚯 __defineGetter__

🚯 __defineSetter__

1.obj.__defineGetter__(prop, func)

2.当对象的属性被读写时，后面的函数会被调用

3.函数上下文为该对象

🚯 __lookupGetter__

🚯 __lookupSetter__

1.obj.__lookupGetter__(sprop)

2.返回对象某个属性的访问器函数

🍀 hasOwnProperty

🍀 isPrototypeOf

1.测试一个对象是否存在于另一个对象的原型链上

2.区别于instanceof,object 的原型链是针对 AFunction.prototype 进行检查的，而不是针对 AFunction 本身

🍀 propertyIsEnumerable

🍀 toLocaleString

🍀 toString

1.返回对象字符串[object object]

Function

静态属性、方法名注释

🍀 arguments

🍀 caller

🍀 length

1.返回调用该函数的函数

2.返回函数形参个数

🍀 length

1.返回调用该函数的函数

🍀 name

1.foo: 普通函数 | 推断函数

2.anonymous: 构造函数

3.bound foo | set foo | get foo : bind | set | get

4.logs Foo: class

原型属性、方法名注释

🍀 apply

🍀 bind

6️⃣ toString

1.toString()方法返回函数代码本身，以前会省略注释和空格。

Array

静态属性、方法名注释

6️⃣ from

1.Array.from(arrayLike[, mapFn[, thisArg]])

2.类数组和迭代器[map方法 [map方法的this]]

3.从一个类似数组或可迭代对象创建一个新的，浅拷贝的数组实例

6️⃣ isArray

6️⃣ of

1.一个整数参数则返回[num], Array返回[ <7 empty items> ] of返回[ 7 ]

🍀 Symbol.species

1.返回Array的构造函数

2.Array[Symbol.species] === Array

原型属性、方法名注释

🍀 concat

1.不改变原数组，返回新数组

🍀 join

🍀 reverse

🍀 slice

🍀 splice

1.array.splice(start[, deleteCount[, item1[, item2[, ...]]]])

🍀 sort

1.1变换位置，0和-1不动

🍀 pop

🍀 shift

1.返回删除的元素

🍀 push

🍀 unshift

1.返回数组的长度

🍀 indexOf

🍀 lastIndexOf

6️⃣ includes

1.arr.includes(valueToFind[, fromIndex])

2.与indexOf区别，NaN相等 ±0不等

6️⃣ copyWithin

1.arr.copyWithin(target[, start[, end]])

2.target: 开始复制到的位置, start|end 开始结束需要复制的位置

3.浅复制数组的一部分到同一数组中的另一个位置，并返回它，会改变原数组

6️⃣ entries

6️⃣ values

6️⃣ keys

1.返回一个新的Array Iterator对象，该对象包含数组中每个索引的键/值对

🍀 every

🍀 some

🍀 filter

🍀 map

🍀 forEach

🍀 reduce

🍀 reduceRight

6️⃣ fill

1.arr.fill(value[, start[, end]])

2.返回修改后的数组，会改变原数组

6️⃣ find

6️⃣ findIndex

1.返回符合条件的第一个元素/下标

6️⃣ flatMap

1.参数类似map的回调函数

2.将类似map的返回数组铺平

🍀 toString

🍀 toLocaleString

1.返回逗号分隔的字符串

🍀 Symbol.iterator

1.返回一个生成器函数，调用返回vaules的迭代器

🍀 Symbol.unscopables

1.ES6新增的属性在with上面未绑定被包含在该属性中

String

静态属性、方法名注释

🍀 fromCharCode

6️⃣ fromCodePoint

1.识别大于0xFFFF的码点

6️⃣ raw

1.斜杠被转义

2.用于模板字符的处理

原型属性、方法名注释

🍀 charAt

🍀 charCodeAt

6️⃣ codePointAt

🍀 normalize

1.charAt不支持负数，超出0~len-1返回空字符串

🍀 concat

6️⃣ includes

🍀 slice

6️⃣ startsWith

6️⃣ endsWith

1.string.startsWith(searchvalue, start)

2.start不支持负数

🍀 indexOf

🍀 lastIndexOf

1.string.indexOf(searchvalue,start)

6️⃣ padStart

6️⃣ padEnd

🍀 trim

🍀 trimLeft

🍀 trimRight

6️⃣ trimStart

6️⃣ trimEnd

🍀 search

1.同indexOf

2.返回匹配到的子字符串的起始位置

3.不存在返回-1

🍀 replace

1.第二个参数为函数，入参为（匹配到的子串，...正则括号匹配到的，偏移量）

🍀 match

6️⃣ matchAll

1.match返回匹配结果数组或者null

2.matchAll返回匹配到结果及其分组捕获组的迭代器

🍀 localeCompare

🍀 repeat

🍀 split

🚯 subStr

🍀 subString

🍀 toLocaleLowerCase

🍀 toLowerCase

🍀 toLocaleUpperCase

🍀 toUpperCase

🍀 length

🍀 Symbol.iterator

1.返回迭代器数组

Boolean

  • toString 'true' | 'false'
  • valueOf true | false

Number

静态属性、方法名注释

6️⃣ EPSILON

1.等于2^-52

2.表示两个数是否相等Math.abs(x - y) < Number.EPSILON

🍀 MAX_SAFE_INTEGER

🍀 MIN_SAFE_INTEGER

🍀 MAX_VALUE

🍀 MIN_VALUE

1.安全数范围[-2^53+1, 2^53-1]

2.js所能表示的最大和最小值 待研究

🍀 NEGATIVE_INFINITY

🍀 POSITIVE_INFINITY

🍀 NaN

1.-Infinity | Infinity | NaN

6️⃣ isFinite

6️⃣ isInteger

6️⃣ isNaN

6️⃣ isSafeInteger

1.是否有穷

2.是整数

3.是否为NaN

4.是安全整数

6️⃣ parseFloat

6️⃣ parseInt

1.字符串解析为数

2.解析不了返回NaN

原型属性、方法名注释

🍀 toExponential

1.指数形式表示数

🍀 toFixed

1.小数点后数字的个数；介于 0 到 20 （包括）之间

🍀 toPrecision

1.以指定的精度返回该数值对象的字符串表示

🍀 toString

🍀 toLocaleString

🍀 valueOf

Symbol

静态属性、方法名注释

6️⃣ asyncIterator

1.异步迭代对象调用的方法

2.for await ...of

6️⃣ hasInstance

1.instanceof 调用的内部方法

6️⃣ isConcatSpreadable

1.控制数组的concat方法是否展开

6️⃣ iterator

1.为对象定义迭代器方法

6️⃣ match

6️⃣ matchAll

6️⃣ replace

6️⃣ search

6️⃣ split

1.调用字符串的这些方法，会获取对应内置函数的返回值

6️⃣ species

1.更改衍生对象的构造器函数

6️⃣ toPrimitive

1.对象被转为基本类型的时候会获取该方法的返回值，入参number/string/default

6️⃣ toStringTag

1.指定Object.prototype.toString的返回值第二个内容 [object Array]

6️⃣ unscopables

1.指向一个对象，该对象的属性里包含被with排除的属性

6️⃣ for

1.有key直接用没有则注册表创建

6️⃣ keyFor

1.返回Symbol的key

原型属性、方法名注释

6️⃣ description

1.同keyFor

6️⃣ toString

1.Symbol('key')

6️⃣ valueOf

6️⃣ toPrimitive

Proxy | Reflect

静态属性、方法名注释

6️⃣ apply

1.Reflect.apply(target, thisArgument, argumentsList)

2.new Proxy(target, {apply(target, object, args){}})

3.函数，this, 参数

6️⃣ constructor

1.Reflect.construct(target, argumentsList[, newTarget])

2.new Proxy(target, {construct(target, args){}})

3.构造函数，参数, 调用构造函数的this

6️⃣ defineProperty

1.Reflect.defineProperty(target, propertyKey, attributes)

2.new Proxy(target, {defineProperty(target, propKey, propDesc){}})

3.对象，属性, 属性描述符

6️⃣ deleteProperty

1.Reflect.deleteProperty(target, propertyKey)

2.new Proxy(target, {deleteProperty(target, propKey){}})

3.，返回bool表示是否成功

6️⃣ get

1.Reflect.get(target, propertyKey[, receiver])

2.new Proxy(target, {get(target, propKey, receiver){}})

3.对象，属性，调用的this

4.获取对象的属性值，

6️⃣ set

1.Reflect.set(target, propertyKey, value[, receiver])

2.new Proxy(target, {set(target, propKey, value, receiver){}})

3.设置对象的属性值，返回bool表示是否成功

6️⃣ has

1.Reflect.has(target, propertyKey)

2.new Proxy(target, {has(target, propKey){}})

3.同in操作符

6️⃣ getOwnPropertyDescriptor

1.Reflect.getOwnPropertyDescriptor(target, propertyKey)

2.new Proxy(target, { getOwnPropertyDescriptor(target, propKey){}})

6️⃣ getPropertyOf

1.Reflect.getPrototypeOf(target)

2.new Proxy(target, { getPrototypeOf(target){}})

6️⃣ setPrototypeOf

1.Reflect.setPrototypeOf(target, prototype)

2.new Proxy(target, { setPrototypeOf(target, proto){}})

3.返回bool表示是否设置成功

6️⃣ isExtensible

1.Reflect.isExtensible(target)

2.new Proxy(target, { isExtensible(target){}})

3.返回bool

6️⃣ preventExtensions

1.Reflect.preventExtensions(target)

2.new Proxy(target, { preventExtensions(target){}})

3.返回bool表示是否阻止成功

6️⃣ ownKeys

1.Reflect.ownKeys(target)

2.new Proxy(target, { ownKeys(target){}})

3.等同于Object.getOwnPropertyNames(target).concat(Object.getOwnPropertySymbol

RegExp

es6-

修饰符： i(大小写不敏感) m(多行匹配) g(执行全局匹配)

模式： [abc] [^abc] [0-9] (x | y)

量词： n+ n* n? n{x,y} n$ ^n ?=n ?!n

方法：

  • exec(str) 返回找到的子字符串或null
  • test(str)是否匹配到,返回bool
  • global | ignoreCase | multiline 是否设置修饰符g | i | m
  • lastIndex返回下次开始匹配的位置

元字符

元字符 描述 元字符 描述
. 除换行和行结束符外任意字符 \w 查找单词字符
\W 查找非单词字符 \d 查找数字
\D 查找非数字 \s 查找空白字符
\S 查找非空白字符 \b 匹配单词边界
\B 匹配非单词边界 \0 查找NUll字符
\n 查找换行符 \f 查找换页符
\r 查找回车符 \t 查找制表符
\v 查找垂直制表符 \xxx 查找以八进制数 xxx 规定的字符
\xdd 查找以十六进制数 dd 规定的字符 \uxxxx 查找以十六进制数 xxxx 规定的 Unicode 字符

es6

  • u修饰符正确识别大码点
/^\uD83D/u.test('\uD83D\uDC2A') //false
/^\uD83D/.test('\uD83D\uDC2A') //true

var s = '𠮷'
/^.$/u.test(s) //true
/^.$/.test(s) //true
  • unicode判断是否有u修饰符
const r1 = /hello/u
r1.unicode //true
  • unicode字符匹配用花括号u{}
/u{61}/.test('a') //true
  • y黏连修饰符和g一样但是每次都从下一次的地方匹配
const s = 'a_aa_xaaa_'
const r1 = /a+_/g
const r2 = /a+_/y

let match1 = ''
while(match1 = r1.exec(s)){
    l(match1)
}
//[ 'a_', index: 0, input: 'a_aa_xaaa_', groups: undefined ]
//[ 'aa_', index: 2, input: 'a_aa_xaaa_', groups: undefined ]
//[ 'aaa_', index: 6, input: 'a_aa_xaaa_', groups: undefined ]

let match2 = ''
while(match2 = r2.exec(s)){
    l(match2)
}
//[ 'a_', index: 0, input: 'a_aa_xaaa_', groups: undefined ]
//[ 'aa_', index: 2, input: 'a_aa_xaaa_', groups: undefined ]
  • sticky判断正则是否有y修饰符
  • flags返回正则修饰符
r2.flags //y
l(r2.source) //a+_
  • s修饰符可以让.匹配所有字符
const s = 'foo\nbar'
const r1 = /foo.bar/
const r2 = /foo.bar/s

l(r1.test(s))//false
l(r2.test(s))//true
  • dotAll判断正则是否有s修饰符
  • 断言
const s = '1-￥2-3-4￥'

//先行断言 /x(?=y)/ 只有x在y前面才匹配y
const r1 = /\d+(?=￥)/g
l(s.match(r1)) // ['4']

//先行否定断言 /x(?!y)/ 只有x不在y前面全部匹
const r2 = /\d+(?!￥)/g
l(s.match(r2)) // [’1‘, '2', '3']

//后行断言 /(?<=y)x/ 只有x在y后面才匹配
const r3 = /(?<=￥)\d+/g
l(s.match(r3)) // ['2']

//后行否定断言 /(?<!y)x/ 只有x不在y后面才匹配
const r4 = /(?<!￥)\d+/g
l(s.match(r4)) // ['1', '3', '4']
  • 具名组匹配 对于匹配到的值分配key (?<组名>)
const re_data1 = /(\d{4})-(\d{2})-(\d{2})/
const match_obj1 = re_data1.exec('2020-02-21')
l(match_obj1.groups)
//undefined

const re_data2 = /(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})/
const match_obj2 = re_data2.exec('2020-02-21')
l(match_obj2.groups)
//{ year: '2020', month: '02', day: '21' }

//可以解构
let {groups: {year, month, day}} = re_data2.exec('2020-02-21')
l(year, month, day)
// 2020 02 21
  • 正则引用具名组 \k<组名> \1也行,正则匹配到的直接在记下来匹配引用
const r = /^(?<word>[a-z]+)!\k<word>$/
const str1 = 'abc!abc'
const str2 = 'abc!ab'
l(r.test(str1)) //true
l(r.test(str2)) //false

const r = /^(?<word>[a-z]+)!\1$/
const str1 = 'abc!abc'
const str2 = 'abc!ab'
l(r.test(str1)) //true
l(r.test(str2)) //false

Date

方法 描述 方法 描述
getDate 月(1-31) getDay 周(0-6)
getFullYear 四位数年 getHours 小时(0-23)
getMilliseconds 毫秒(0-999) getMinutes 分(0-59)
getMonth 月(0-11) getSeconds 秒(0-59)
getTime等同于Date.now() 1970/1/1到今毫秒 valueOf 返回Date对象的原始值
其他方法

Error

  • message | name
var e = new Error("Malformed input"); // e.name默认是"Error"

e.name = "ParseError";                // 修改之后,e.toString()会成为下面这样的字符串
throw e;                              // "ParseError: Malformed input"
  • EvalError | InternalError | RangeError | ReferenceError | SyntaxError | TypeError | URIError

Set、WeakSet和Map、WeakMap

Set

  1. 接受iterator接口
  2. NaN视为相等
  3. add,size,delete,clear
  4. for...of keys values entries forEach map filter

WeakSet

  1. WeakSet 中的对象都是弱引用，即垃圾回收机制不考虑 WeakSet 对该对象的引用，也就是说，如果其他对象都不再引用该对象，那么垃圾回收机制会自动回收该对象所占用的内存，不考虑该对象还存在于 WeakSet 之中,这是因为垃圾回收机制依赖引用计数，如果一个值的引用次数不为0，垃圾回收机制就不会释放这块内存。结束使用该值之后，有时会忘记取消引用，导致内存无法释放，进而可能会引发内存泄漏。WeakSet 里面的引用，都不计入垃圾回收机制，所以就不存在这个问题。因此，WeakSet 适合临时存放一组对象，以及存放跟对象绑定的信息。只要这些对象在外部消失，它在 WeakSet 里面的引用就会自动消失。
  2. 只能放置对象
  3. 只有has delete add方法

Map

  1. set,get,delete,has,clear,size
  2. for...of keys values entries forEach map filter

WeakMap

  1. 同WeakSet都是弱引用，对象不再被引用则键值消失
  2. 只接受对象作为key
  3. get set has delete方法

其他

1 2 3 4 5
ArrayBuffer AsyncFunction Atomics BigInt BigInt64Array
BigUint64Array DataView Float32Array Float64Array Generator
GeneratorFunction Infinity Int16Array Int32Array Intl
JSON NaN Promise SharedArrayBuffer TypedArray
Uint32Array Uint8Array Uint8ClampedArray WebAssembly decodeURI()
decodeURIComponent() encodeURI() encodeURIComponent() eval() isFinite()
isNaN() null parseFloat parseInt undefined
avatar
文章
阅读
粉丝