内置对象的属性方法

全局对象的属性
全局对象的方法
Object
Function
Number
Math
Symbol
Date
string
Array
RegExp
Set and Map
WeakSet and WeakMap
Promise
Generator
Proxy
Reflect
JSON

全局对象的属性

undefined;
null;

Infinity; // 移到 Number.POSITIVE_INFINITY
NaN; // 移到 Number.NaN     自身不相等

全局对象的方法

eval()
uneval()  // 未标准化

encodeURI()  // 不会对属于URI的特殊字符编码，如空格换成%20
// 如下不编码    A-Z a-z 0-9 ; , / ? : @ & = + $ - _ . ! ~ * ' ( )
decodeURI()  // 用于整个 URI
encodeURIComponent()  // 对任何非标准字符进行编码
decodeURIComponent()  // 用于 URI 的某一段


// 以下 es6 挂载在 Number 方法中
isFinite()      Number.isFinite = v => (typeof v === 'number' && isFinite(v));
isNaN()         isNaN = v => Number.isNaN(Number(v));
parseFloat()    parseFloat === Number.parseFloat
parseInt()      parseInt === Number.parseInt
// 以上 es6 挂载在 Number 方法中

Object

Properties

Object.prototype;

Object.prototype.__proto__;
Object.prototype.constructor;

Methods

Object.is(value1, value2); // 比 === 好在：正负零不等，NaN相等

Object.keys(obj);
Object.values(obj);
Object.entries(obj);

Object.assign(target, ...sources); // 通过复制一个或多个对象来创建一个新的对象
Object.create(proto, [propertiesObject]); // 指定原型对象和属性来创建一个新的对象

Object.getPrototypeOf(obj); // 获取原型
Object.setPrototypeOf(obj, prototype);

Object.getOwnPropertyNames(obj); // 返回自身的可枚举和不可枚举属性的名称
Object.getOwnPropertySymbols(obj);

Object.getOwnPropertyDescriptor(obj, prop); // 返回自有属性的属性描述符
Object.getOwnPropertyDescriptors(obj);
Object.defineProperty(obj, prop, descriptor);
Object.defineProperties(obj, props);

Object.preventExtensions(obj); // 不可扩展（在它上面添加新的属性），可更改已存在属性值
Object.seal(obj); // 对象不可扩展，属性不可配置（non-configurble），可修改属性值
Object.freeze(obj); // 对象不可扩展，属性不可配置，数据属性不可写（non-writable）

Object.isExtensible(obj);
Object.isSealed(obj);
Object.isFrozen(obj);

Object.prototype.hasOwnProperty(); // 表示某个对象是否含有指定的属性，并且此属性是非原型链继承的
Object.prototype.isPrototypeOf();
Object.prototype.propertyIsEnumerable(prop);

Object.prototype.toString(); // 用来判断对象类型
Object.prototype.valueOf(); // 返回对象原始值，很少用

Function

Properties

arguments; // arguments.length 表示函数调用时传入函数的实参数量
Function.length; // 表示该函数有多少个必须要传入的参数，那些已定义了默认值的参数不算在内
Function.name;
Function.prototype;

Methods

Function.prototype.apply(thisArg, [argsArray])
Function.prototype.call(thisArg, arg1, arg2, ...)
Function.prototype.bind(thisArg[, arg1[, arg2[, ...]]])  // 返回由指定的this值和初始化参数改造的原函数拷贝

Function.prototype.toString()

Number

Properties

Number.MAX_SAFE_INTEGER; // 最大的安全整数  2^53 - 1
Number.MIN_SAFE_INTEGER; // 最小的安全整数  -(2^53 - 1)

Number.MAX_VALUE; // 能表示的最大正数  1.79e+308
Number.MIN_VALUE; // 能表示的最小正数  5e-324

Number.POSITIVE_INFINITY; // 负无穷大值
Number.NEGATIVE_INFINITY; // 正无穷大值

Number.EPSILON;
Number.NaN;

Methods

Number.isNaN()
Number.isFinite()

Number.isInteger()
Number.isSafeInteger()

Number.parseInt(string[, radix])
Number.parseFloat(string)

Number.prototype.toExponential([fractionDigits])  // 参数控制小数位数
Number.prototype.toFixed([digits])                // 参数控制小数位数
Number.prototype.toPrecision([precision])         // 参数有效数字个数

Number.prototype.toLocaleString([locales [, options]])  // 特定语言环境下的表示字符串

Number.prototype.toString()
Number.prototype.valueOf()

Math

Properties

Math.E; // 2.718
Math.PI; // 3.14

Math.LN2; // 0.693
Math.LN10; // 2.303
Math.LOG2E; // 1.443
Math.LOG10E; // 0.434

Math.SQRT2; // 1.414
Math.SQRT1_2; // 0.707

Methods

Math.random() // [0, 1)
Math.abs()    // 绝对值
Math.sign()   // 正负判断（5种返回值：±0 ±1 NaN）
Math.ceil()   // 向上取整
Math.floor()  // 向下取整
Math.round()  // 四舍五入
Math.trunc()  // 取整

Math.max([x[, y[, …]]])
Math.min([x[, y[, …]]])

Math.pow(x, y)  // x^y
Math.sqrt()     // 平方根(square root)
Math.cbrt()     // 立方根(cube root)
Math.log()      // lnx
Math.exp()      // e^x

Math.log2()
Math.log10()

Math.clz32()               // 32位无符号整形的二进制，前导零个数 (CountLeadingZeroes32) (负数为0，小数抛弃)
Math.hypot([x[, y[, …]]])  // 平方和的平方根
Math.imul(x, y)            // 两个参数的类C的32位整数乘法运算的运算结果
Math.fround()              // 离它最近的单精度浮点数形式的数字

// 三角函数返回弧度值
Math.sin()
Math.cos()
Math.tan()

Math.asin()
Math.acos()
Math.atan()
Math.atan2(y, x)

// 双曲函数
Math.sinh()
Math.cosh()
Math.tanh()

Math.asinh()
Math.acosh()
Math.atanh()

Symbol

重要的符号标识

主要用作函数值属性

Symbol.iterator   // Used by for...of

Symbol.match      // Used by String.prototype.match()
Symbol.replace    // Used by String.prototype.replace()
Symbol.search     // Used by String.prototype.search()
Symbol.split      // String.prototype.split()

Symbol.hasInstance  // Used by instanceof
Symbol.toStringTag  // Used by Object.prototype.toString()
Symbol.isConcatSpreadable  // Array.prototype.concat()

Symbol.species      // 允许子类覆盖对象的默认构造函数
Symbol.toPrimitive  // 将被调用的指定函数值的属性转换为相对应的原始值
Symbol.unscopables  // 用于排除属性名称并与 with 环境绑定在一起作为词法变量公开

Methods

Symbol.for(key);
Symbol.keyFor(sym);

Symbol.prototype.toString();
Symbol.prototype.valueOf();

Date

Syntax

new Date();
new Date(value);  // value 代表自1970年1月1日00:00:00 (世界标准时间) 起经过的毫秒数
new Date(dateString);
new Date(year, monthIndex [, day [, hours [, minutes [, seconds [, milliseconds]]]]]);

Methods

Date.now()    // 返回自1970年1月1日00:00:00 (世界标准时间) 起经过的毫秒数
Date.parse()  // 天数从1开始，其他从0
Date.UTC(year,month[,date[,hrs[,min[,sec[,ms]]]]])  // 返回一个时间数值，不是日期对象


// 下面为对应的7项，都有 [getUTC+xx] [set+xx]  [setUTC+xx]
Date.prototype.getFullYear()
Date.prototype.getMonth()
Date.prototype.getDate()
Date.prototype.getHours()
Date.prototype.getMinutes()
Date.prototype.getSeconds()
Date.prototype.getMilliseconds()
// 上面7项


Date.prototype.getDay()             // 星期几
Date.prototype.getUTCDay()          // 星期几
Date.prototype.getTimezoneOffset()  // 返回当前时区的时区偏移（分钟 -480）
Date.prototype.getTime()            // 返回自1970的毫秒数
Date.prototype.setTime()            // 设置自1970的毫秒数

Date.prototype.toJSON()

Date.prototype.toDateString()
Date.prototype.toISOString()
Date.prototype.toTimeString()
Date.prototype.toUTCString()
Date.prototype.toLocaleDateString()
Date.prototype.toLocaleString()
Date.prototype.toLocaleTimeString()

Date.prototype.toString()
Date.prototype.valueOf()

string

Syntax

模板字面量 hello ${who}

转义字符

\0 \n \r \v \t \b \f '\' \'' \\ \uXXXX \xXX \u{XXXXXX}

Methods

String.fromCharCode()   // 从码点返回对应字符（）
String.fromCodePoint()  // 可以识别大于0xFFFF的字符
String.raw(callSite, ...substitutions)  // 任意个可选的参数，表示任意个内插表达式对应的值

String.prototype.charAt()        // 返回特定位置的字符
String.prototype.charCodeAt()    // 返回表示给定索引的字符的Unicode的值
String.prototype.codePointAt()   // 对应 fromCodePoint

String.prototype.indexOf(searchValue[, fromIndex])
String.prototype.lastIndexOf(searchValue[, fromIndex])
String.prototype.startsWith(searchString [, position])
String.prototype.endsWith(searchString [, position])  // position 默认 str.length
String.prototype.includes(searchString[, position])

String.prototype.padStart(targetLength [, padString])
String.prototype.padEnd(targetLength [, padString])
String.prototype.concat()
String.prototype.repeat(count)

String.prototype.search(regexp)
String.prototype.match(regexp)
String.prototype.replace(regexp|substr, newSubStr|func)

String.prototype.split([separator[, limit]])   // 字符串分割成字符串数组
String.prototype.slice(beginSlice[, endSlice])  // 提取

String.prototype.substr(start[, length])
String.prototype.substring(indexStart[, indexEnd])

String.prototype.trim()      // 去空白
String.prototype.trimLeft()
String.prototype.trimRight()
String.prototype.toUpperCase()
String.prototype.toLowerCase()
String.prototype.toLocaleUpperCase()
String.prototype.toLocaleLowerCase()
String.prototype.normalize([form])  // NFC NFD NFKC NFKD

String.prototype.localeCompare(compareString[, locales[, options]])

String.prototype.toString()
String.prototype.valueOf()

Array

Syntax

[element0, element1, ..., elementN]
new Array(element0, element1[, ...[, elementN]])
new Array(arrayLength)

Methods

Array.from(arrayLike[, mapFn[, thisArg]])          // 迭代对象创建为数组实例
Array.isArray(obj)                                 // 判断是否为数组
Array.of(element0[, element1[, ...[, elementN]]])  // 创建具有可变数量参数的新数组实例，不考虑参数的数量或类型

// 存取器方法(Mutator methods) -- 改变自身
Array.prototype.pop()      // 尾删，返回该元素
Array.prototype.push()     // 尾添，返回新长度
Array.prototype.shift()    // 首删，返回改元素
Array.prototype.unshift()  // 首添，返回新长度

Array.prototype.sort(compareFunction(a,b))
Array.prototype.reverse()
Array.prototype.splice(start, deleteCount, item1, item2, ...)
Array.prototype.fill(value, start, end)
Array.prototype.copyWithin(target, start, end)  // 浅复制数组的一部分到同一数组中的另一个位置，不修改其大小

// 访问器方法(Accessor methods) -- 不改变调用对象的值
Array.prototype.join(separator)    // 拼接成的字符串
Array.prototype.concat()
Array.prototype.includes(searchElement, fromIndex)  // 返回 boolean
Array.prototype.indexOf(searchElement[, fromIndex = 0])
Array.prototype.lastIndexOf(searchElement[, fromIndex = arr.length - 1])

Array.prototype.slice([begin, end))
Array.prototype.toString()
Array.prototype.toLocaleString()

// 迭代方法(Iteration methods) -- 回调函数执行前，数组长度已被缓存，所以尽量不要删改原数组某个元素
Array.prototype.keys()
Array.prototype.values()
Array.prototype.entries()  // for…of 循环

// 使用箭头函数时， thisArg 被忽略
Array.prototype.forEach(callback(currentValue, index, array){}[, thisArg])  // 遍历函数
Array.prototype.some()         // 测试函数，有通过的项就返回 true
Array.prototype.every()        // 测试函数，所有都通过返回 true
Array.prototype.filter()       // 筛选函数，返回通过测试的元素的集合的数组
Array.prototype.find()         // 寻找函数，返回第一个满足测试的元素值
Array.prototype.findIndex()    // 寻找函数，返回第一个满足测试的元素索引
Array.prototype.map()          // 映射函数，返回处理后的新数组

Array.prototype.reduce(callback(accumulator, currentValue, currentIndex, array){}[, initialValue])
Array.prototype.reduceRight()  //initialValue 默认为数组第一项

RegExp

Syntax

/pattern/flags
new RegExp(pattern[, flags])
RegExp(pattern[, flags])

flags: g i m u y

Properties

RegExp.$1-$9
RegExp.input ($_)
RegExp.lastMatch ($&)
RegExp.lastParen ($+)
RegExp.leftContext ($`)
RegExp.rightContext ($')

RegExp.prototype.source     // 返回正则对象的模式文本字符串，不包括flags和斜杠
RegExp.prototype.flags      // 返回一个字符串，由gimuy组成
RegExp.prototype.lastIndex  // g 才生效

// 返回布尔值
RegExp.prototype.global      // g
RegExp.prototype.ignoreCase  // i
RegExp.prototype.multiline   // m (影响 ^ 和 $ 的行为)
RegExp.prototype.unicode     // u
RegExp.prototype.sticky      // y

Methods

RegExp.prototype.exec(str); // 成功返回数组，失败返回 null
RegExp.prototype.test(str); // 测试检索，匹配返回 true，失败返回 false

RegExp.prototype.toString();

Set and Map

Properties

Set(Map).prototype.size;

Methods

// 同样的部分
Set(Map).prototype.keys()
Set(Map).prototype.values()
Set(Map).prototype.entries()
Set(Map).prototype.forEach(callbackFn[, thisArg])

Set(Map).prototype.has(value)     // 指定的值存在返回true，否则返回 false
Set(Map).prototype.delete(value)  // 成功删除返回 true，否则返回 false
Set(Map).prototype.clear()

// 不一样的地方
Set.prototype.add(value)      // 尾部添加一个元素，返回该 Set 对象
Map.prototype.get(key)        // 返回与指定键相关联的值
Map.prototype.set(key, value) // 返回添加键值对的新 Map 对象

WeakSet and WeakMap

和 Set(Map) 区别

WeakSet(WeakMap) 对象中只能存放对象值，不能存放原始值，而 Set(Map) 对象都可以。
WeakSet(WeakMap) 对象中存储的对象值都是被弱引用的，如果没有其他的变量或属性引用这个对象值，则这个对象值会被当成垃圾回收掉。正因为这样，WeakSet(WeakMap) 对象是无法被枚举的，没有办法拿到它包含的所有元素。

Methods

WeakSet(WeakMap).prototype.delete();
WeakSet(WeakMap).prototype.has();

WeakSet.prototype.add(value);
WeakMap.prototype.get(key);
WeakMap.prototype.set(key, value);

Promise

Syntax

new Promise( /* executor */ function(resolve, reject) { ... } );

Methods

Promise.resolve(value);
Promise.reject(reason);
Promise.all(iterable);
Promise.race(iterable);

Promise.prototype.then(onFulfilled, onRejected);
Promise.prototype.catch(onRejected);
Promise.prototype.finally(onFinally);

Promise.try();

Generator

Methods

Generator.prototype.next();
Generator.prototype.return();
Generator.prototype.throw();

Proxy

Syntax

var p = new Proxy(target, handler);

Methods

Proxy.revocable(target, handler);

handler.getPrototypeOf(target);
handler.setPrototypeOf(target, proto);

handler.isExtensible(target);
handler.preventExtensions(target);

handler.getOwnPropertyDescriptor(target, propKey);
handler.defineProperty(target, propKey, propDesc);

handler.get(target, propKey, receiver);
handler.set(target, propKey, value, receiver);
handler.has(target, propKey);
handler.deleteProperty(target, propKey);

handler.ownKeys(target);
handler.apply(target, object, args);
handler.construct(target, args);

Reflect

将 Object 对象的一些明显属于语言内部的方法，放到 Reflect 对象上。
修改某些 Object 方法的返回结果，让其变得更合理。
让 Object 操作都变成函数行为。
Reflect 对象的方法与 Proxy 对象的方法一一对应，只要是 Proxy 对象的方法，就能在 Reflect 对象上找到对应的方法。

Methods

Reflect.apply(target, thisArg, args);
Reflect.construct(target, args);
Reflect.get(target, name, receiver);
Reflect.set(target, name, value, receiver);
Reflect.defineProperty(target, name, desc);
Reflect.deleteProperty(target, name);
Reflect.has(target, name);
Reflect.ownKeys(target);
Reflect.isExtensible(target);
Reflect.preventExtensions(target);
Reflect.getOwnPropertyDescriptor(target, name);
Reflect.getPrototypeOf(target);
Reflect.setPrototypeOf(target, prototype);

JSON

类型要求

简单类型的值只有四种：字符串、数值（必须以十进制表示）、布尔值和 null（不能使用 NaN, Infinity, -Infinity 和 undefined）。
复合类型的值只能是数组或对象，不能是函数、正则表达式对象、日期对象。
字符串必须使用双引号表示，不能使用单引号。
对象的键名必须放在双引号里面。
数组或对象最后一个成员的后面，不能加逗号。

JSON.stringify(value[, replacer[, space]])

用于将一个值转为字符串。该字符串符合 JSON 格式。
对象有自定义的 toJSON 方法时，会使用这个方法的返回值作为参数，而忽略原对象的其他属性。
对于原始类型的字符串，转换结果会带双引号。
成员的值是 undefined、函数或 XML 对象，会被过滤。
数组的成员是 undefined、函数或 XML 对象，则这些值被转成 null。
正则对象会被转成空对象。
会忽略对象的不可遍历属性。
第二个参数
1. 为数组时：白名单功能
2. 第二个参数为函数时，递归处理 json 对象；f(key,value){}处理函数返回 undefined 或没有返回值，则该属性会被忽略。
第三个参数
1. 为数字时：前面空格数
2. 为字符串时：添加到前面

JSON.parse(text[, reviver])

将 JSON 字符串转化成对象。
第二个参数为处理函数，和 JSON.stringify 一样。

Files

内置对象的属性方法.md

Latest commit

History

内置对象的属性方法.md

File metadata and controls

内置对象的属性方法

全局对象的属性

全局对象的方法

Object

Properties

Methods

Function

Properties

Methods

Number

Properties

Methods

Math

Properties

Methods

Symbol

重要的符号标识

Methods

Date

Syntax

Methods

string

Syntax

转义字符

Methods

Array

Syntax

Methods

RegExp

Syntax

Properties

Methods

Set and Map

Properties

Methods

WeakSet and WeakMap

和 Set(Map) 区别

Methods

Promise

Syntax

Methods

Generator

Methods

Proxy

Syntax

Methods

Reflect

Methods

JSON

类型要求

JSON.stringify(value[, replacer[, space]])

JSON.parse(text[, reviver])