JavaScript学习笔记：内置API

本文更新于2022-06-16。

说明：下文中，大写为自定义变量（个别大写的类型除外），根据实际情况填写。使用<>引起表示内容可选，|表示使用左侧或右侧内容，...表示重复之前内容。

本文只说明简要的使用，更详细的使用可参阅MDN文档：https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects

目录

全局对象以字典序进行排序。全局对象的属性先以此方式进行排序：静态属性（如Number.MAX_VALUE）、实例属性（如ARRAY.length）、静态方法（如Date.now）、prototype方法（如Array.prototype.concat）；同一类别属性再以字典序进行排序。

本文阐述的API标准为：ECMAScript 5。

以下接口已弃用：

  • escape
  • unescape

arguments

arguments所在函数的实参，为类数组对象，只定义在函数体内。

arguments.callee

arguments所在的函数。

arguments.length

arguments所在函数的实参个数。

Array

数组类型。

var ARRAY = new Array();
var ARRAY = new Array(LENGTH);
var ARRAY = new Array(ELEMENT <, ...>);

ARRAY.length

数组元素个数。可写属性。

Array.prototype.concat

拼接数组。

var NEW_ARRAY = ARRAY.concat(ELEMENT <, ...>);

Array.prototype.every

判断是否所有元素都满足断言。

var OK = ARRAY.every(
	function(ELEMENT, I, ARRAY) {
		return true;
	}
	<, THIS>
);

THIS为调用断言函数时this的指向，下同。

Array.prototype.filter

使用通过断言的元素生产新数组。

var NEW_ARRAY = ARRAY.filter(
	function(ELEMENT, I, ARRAY) {
		return true;
	}
	<, THIS>
);

Array.prototype.forEach

为每个元素调用一个函数。

ARRAY.forEach(
	function(ELEMENT, I, ARRAY) {
	}
	<, THIS>
);

Array.prototype.indexOf

正向查找元素。使用===判断相等，如不存在，则返回-1。

var INDEX = ARRAY.indexOf(VALUE <, START_INDEX>);

Array.prototype.join

将数组拼接为字符串。

var STR = ARRAY.join(<SEPARATOR>);

SEPARATOR缺省为","。

Array.prototype.lastIndexOf

反向查找元素。使用===判断相等，如不存在，则返回-1。

var INDEX = ARRAY.lastIndexOf(VALUE, <, START_INDEX>);

Array.prototype.map

计算出新数组。

var NEW_ARRAY = ARRAY.map({
	function(ELEMENT, I, ARRAY) {
		return VALUE;
	}
	<, THIS>
});

Array.prototype.pop

移除并返回最后一个元素。

var ELEMENT = ARRAY.pop();

Array.prototype.push

向数组尾部追加元素。

var LENGTH = ARRAY.push(ELEMENT <, ...>);

Array.prototype.reduce

从数组正向计算出一个值。

var VALUE = ARRAY.reduce(
	function(RESULT1, ELEMENT, I, ARRAY) {
		return RESULT2;
	}
	<, INITIAL>
);

如指定INITIAL，则函数参数第一次调用时传入INITIAL和数组第一个元素；否则，函数参数第一次调用时传入第一和第二个元素。

Array.prototype.reduceRight

从数组反向计算出一个值。

var VALUE = ARRAY.reduceRight(
	function(RESULT1, ELEMENT, I, ARRAY) {
		return RESULT2;
	}
	<, INITIAL>
);

如指定INITIAL，则函数参数第一次调用时传入INITIAL和数组最后一个元素；否则，函数参数第一次调用时传入最后一个和倒数第二个元素。

Array.prototype.reverse

颠倒数组元素。

ARRAY.reverse();

Array.prototype.shift

移除并返回第一个元素。

var ELEMENT = ARRAY.shift();

Array.prototype.slice

使用数组的一部分生成新数组。

var NEW_ARRAY = ARRAY.slice(<START_INDEX <, END_INDEX>>);

新数组对应ARRAY的区间为[START_INDEX, END_INDEX)。START_INDEX和END_INDEX均可为负数，表示从尾部数起，-1为最后一个元素。

Array.prototype.some

判断是否有元素满足断言。

var OK = ARRAY.some(
	function(ELEMENT, I, ARRAY) {
		return true;
	}
	<, THIS>
);

Array.prototype.sort

对数组进行排序。

var ARRAY = ARRAY.sort(
	<function(ELEMENT1, ELEMENT2) {
		return INT;
	}>
);

如不使用函数参数，则将数组元素转换成字符串后的值按字典序进行排序。如函数参数返回值小于0，表示ELEMENT1<ELEMENT2；等于0，表示ELEMENT1==ELEMENT2；大于0，表示ELEMENT1>ELEMENT2。

Array.prototype.splice

可用于插入、删除或替换数组元素。

var DELETE_ARRAY = ARRAY.splice(
	START_INDEX,
	DELETE_COUNT
	<, ELEMENT <, ...>>
);

先删除START_INDEX（含）起的DELETE_COUNT个元素，再在START_INDEX处插入指定的元素，并返回被删除的元素数组。

Array.prototype.toLocaleString

转换成本地化字符串。

var STR = ARRAY.toLocaleString();

Array.prototype.toString

转换成字符串。

var STR = ARRAY.toString();

返回值与ARRAY.join()一样。

Array.prototype.unshift

往数组头部添加元素。

var LENGTH = ARRAY.unshift(ELEMENT <, ...>);

Boolean

布尔类型。

var BOOLEAN = new Boolean(VALUE);
var BOOLEAN = Boolean(VALUE);

Boolean.prototype.toString

转换成字符串。

var STR = BOOLEAN.toString();

返回"true"或"false"。

Boolean.prototype.valueOf

返回原始布尔值。

var BOOL = BOOLEAN.valueOf();

Date

日期时间类型。

var DATE = new Date(MILLISECONDS);
var DATE = new Date();
var DATE = new Date(STR);
var DATE = new Date(YEAR, MONTH <, DATE_IN_MONTH <, HOUR <, MINUTE <, SECOND <, MILLISECOND>>>>>);
var STR = Date();

当传入MILLISECONDS时，为UTC时间从1970年1月1日零点经过指定毫秒数后对应的本地时间。其他调用，均为参数指定的本地时间。

STR最完整的格式为：2006-01-02T15:04:05.000Z。

MONTH为0至11，DATEINMONTH为1至31，HOUR为0至23，MINUTE为0至59，SECOND为0至59，MILLISECOND为0至999。

以下接口已弃用：

  • Date.prototype.getYear
  • Date.prototype.setYear
  • Date.prototype.toGMTString

Date.now

返回UTC从1970年1月1日零点到现在UTC时间经过的毫秒数。

var MILLISECONDS = Date.now();

Date.parse

从字符串解析日期时间。

var DATE = Date.parse(STR);

STRING最完整的格式为：2006-01-02T15:04:05.000Z。

Date.UTC

返回参数指定的UTC时间从1970年1月1日零点到现在UTC时间经过的毫秒数。

var MILLISECONDS = Date.UTC(YEAR, MONTH <, DATE_IN_MONTH <, HOUR <, MINUTE <, SECOND <, MILLISECOND>>>>>)

Date.prototype.getDate

返回本地时间的日。

var DATE_IN_MONTH = DATE.getDate();

Date.prototype.getDay

返回本地时间的星期。

var DAY = DATE.getDay();

返回值为0（周日）至6（周六）。

Date.prototype.getFullYear

返回本地时间的年。

var YEAR = DATE.getFullYear();

Date.prototype.getHours

返回本地时间的时。

var HOUR = DATE.getHours();

Date.prototype.getMilliseconds

返回本地时间的毫秒。

VAR MILLISECOND = DATE.getMilliseconds();

Date.prototype.getMinutes

返回本地时间的分。

var MINUTE = DATE.getMinutes();

Date.prototype.getMonth

返回本地时间的月。

var MONTH = DATE.getMonth();

Date.prototype.getSeconds

返回本地时间的秒。

var SECOND = DATE.getSeconds();

Date.prototype.getTime

返回对应的UTC时间从UTC时间1970年1月1日零点经过的毫秒数。

var MILLISECONDS = DATE.getTime();

Date.prototype.getTimezoneOffset

返回本地时区与UTC时区的时差，以分钟表示。

var MINUTES = DATE.getTimezoneOffset();

Date.prototype.getUTCDate

返回UTC时间的日。

var DATE_IN_MONTH = DATE.getUTCDate();

Date.prototype.getUTCDay

返回UTC时间的星期。

var DAY = DATE.getUTCDay();

返回值为0（周日）至6（周六）。

Date.prototype.getUTCFullYear

返回UTC时间的年。

var YEAR = DATE.getUTCFullYear();

Date.prototype.getUTCHours

返回UTC时间的时。

var HOUR = DATE.getUTCHours();

Date.prototype.getUTCMilliseconds

返回UTC时间的毫秒。

VAR MILLISECOND = DATE.getUTCMilliseconds();

Date.prototype.getUTCMinutes

返回UTC时间的分。

var MINUTE = DATE.getUTCMinutes();

Date.prototype.getUTCMonth

返回UTC时间的月。

var MONTH = DATE.getUTCMonth();

Date.prototype.getUTCSeconds

返回UTC时间的秒。

var SECOND = DATE.getUTCSeconds();

Date.prtotype.setDate

设置本地时间的日。

var MILLISECONDS = DATE.setDate(DATE_IN_MONTH);

返回设置后的UTC时间从UTC时间1970年1月1日零点经过的毫秒数。下同。

Date.prototype.setFullYear

设置本地时间的年、月、日。

var MILLISECONDS = DATE.setFullYear(YEAR <, MONTH <, DATE_IN_MONTH>>);

Date.prototype.setHours

设置本地时间的时、分、秒、毫秒。

var MILLISECONDS = DATE.setHours(HOUR <, MINUTE <, SECOND <, MILLISECOND>>>);

Date.prototype.setMilliseconds

设置本地时间的毫秒。

var MILLISECONDS = DATE.setMilliseconds(MILLISECOND);

Date.prototype.setMinutes

设置本地时间的分、秒、毫秒。

var MILLISECONDS = DATE.setMinutes(MINUTE <, SECOND <, MILLISECOND>>);

Date.prototype.setMonth

设置本地时间的月、日。

var MILLISECONDS = DATE.setMonth(MONTH <, DATE_IN_MONTH>);

Date.prototype.setSeconds

设置本地时间的秒、毫秒。

var MILLISECONDS = DATE.setSeconds(SECOND <, MILLISECOND>);

Date.prototype.setTime

设置时间为UTC时间从1970年1月1日零点经过指定的毫秒数。

var MILLISECONDS = DATE.setTime(MILLISECONDS);

Date.prtotype.setUTCDate

设置UTC时间的日。

var MILLISECONDS = DATE.setUTCDate(DATE_IN_MONTH);

返回设置后的UTC时间从UTC时间1970年1月1日零点经过的毫秒数。下同。

Date.prototype.setUTCFullYear

设置UTC时间的年、月、日。

var MILLISECONDS = DATE.setUTCFullYear(YEAR <, MONTH <, DATE_IN_MONTH>>);

Date.prototype.setUTCHours

设置UTC时间的时、分、秒、毫秒。

var MILLISECONDS = DATE.setUTCHours(HOUR <, MINUTE <, SECOND <, MILLISECOND>>>);

Date.prototype.setUTCMilliseconds

设置UTC时间的毫秒。

var MILLISECONDS = DATE.setUTCMilliseconds(MILLISECOND);

Date.prototype.setUTCMinutes

设置UTC时间的分、秒、毫秒。

var MILLISECONDS = DATE.setUTCMinutes(MINUTE <, SECOND <, MILLISECOND>>);

Date.prototype.setUTCMonth

设置UTC时间的月、日。

var MILLISECONDS = DATE.setUTCMonth(MONTH <, DATE_IN_MONTH>);

Date.prototype.setUTCSeconds

设置UTC时间的秒、毫秒。

var MILLISECONDS = DATE.setUTCSeconds(SECOND <, MILLISECOND>);

Date.prototype.toDateString

返回本地时间的日期字符串，与实现有关，如：Tue Jul 07 2020。

var STR = DATE.toDateString();

Date.prototype.toISOString

返回UTC时间的日期时间字符串，使用ISO-8601标准，如：2020-07-07T15:56:14.306Z。

var STR = DATE.toISOString();

Date.prototype.toJSON

返回UTC时间的日期时间字符串，使用ISO-8601标准，如：2020-07-07T15:56:14.306Z。

var STR = DATE.toJSON(<KEY>);

参数KEY会被忽略。

Date.prototype.toLocaleDateString

返回本地时间本地习惯的日期字符串，与实现有关，如：2020/7/7。

var STR = DATE.toLocaleDateString();

Date.prototype.toLocaleString

返回本地时间本地习惯的日期时间字符串，与实现有关，如：2020/7/7 下午11:56:14。

var STR = DATE.toLocaleString();

Date.prototype.toLocaleTimeString

返回本地时间本地习惯的时间字符串，与实现有关，如：下午11:56:14。

var STR = DATE.toLocaleTimeString();

Date.prototype.toString

返回本地时间的日期时间字符串，与实现有关，如：Tue Jul 07 2020 23:56:14 GMT+0800 (中国标准时间)。

var STR = DATE.toString();

Date.prototype.toTimeString

返回本地时间的时间字符串，与实现有关，如：23:56:14 GMT+0800 (中国标准时间)。

var STR = DATE.toTimeString();

Date.prototype.toUTCString

返回UTC时间的日期时间字符串，与实现有关，如：Tue, 07 Jul 2020 15:56:14 GMT。

var STR = DATE.toUTCString();

Date.prototype.valueOf

返回对应的UTC时间从UTC时间1970年1月1日零点经过的毫秒数。

var MILLISECONDS = DATE.valueOf();

decodeURI

解码URI，将%开头的16进制转义序列解码为其代表的字符。encodeURI的逆操作。

var URI_DECODED = decodeURI(URI);

decodeURIComponent

解码URI的组件，将%开头的16进制转义序列解码为其代表的字符。encodeURIComponent的逆操作。

var COMPONENT_DECODED = decodeURIComponent(COMPONENT);

encodeURI

编码URI。将字母、数字、-_.!~*'()和;/?😡&=+$,#以外的字符编码为%开头的16进制转义序列，不会对那些用于分隔URI组件的字符进行转义。

var URI_ENCODED = encodeURI(URI);

encodeURIComponent

编码URI组件。将字母、数字和-_.!~*'()以外的字符编码为%开头的16进制转义序列，会对那些用于分隔URI组件的字符进行转义。

var COMPONENT_ENCODED = encodeURIComponent(COMPONENT);

Error

错误类型。

var ERROR = new Error(<MESSAGE>);

ERROR.message

错误消息。

ERROR.name

创建错误实例的构造函数名字。

Error.prototype.toString

转换成字符串。

var STR = ERROR.toString();

eval

执行JavaScript代码，并返回执行代码的求值结果。

var RETURN = eval(STR);

EvalError

执行代码错误的错误类型。

var EVALERROR = new EvalError(<MESSAGE>);

EVALERROR.message

错误消息。

EVALERROR.name

创建错误实例的构造函数名字，即：EvalError。

Function

函数类型。

var FUNCTION = new Function(STR_PARAM_NAME <, ...> STR_BODY);

以下接口已弃用：

  • FUNCTION.arguments
  • FUNCTION.caller

FUNCTION.length

形参的个数。

FUNCTION.prototype

原型对象，当FUNCTION作为构造函数使用时，创建的对象都会继承原型对象的属性和方法。

Function.prototype.apply

将函数作为一个对象的方法调用。

var RETURN = FUNCTION.apply(THIS <, PARAM_ARRAY>);

Function.prototype.bind

将函数作为一个对象的方法绑定生成一个新函数。

var FUNCTION_BOUND = FUNCTION.bind(THIS <, PARAM <, ...>>);

Function.prototype.call

将函数作为一个对象的方法调用。

var RETURN = FUNCTION.call(THIS <, PARAM <, ...>>);

Function.prototype.toString

转换成字符串。

var STR = FUNCTION.toString();

Infinity

无穷大。

isFinite

是否是有限数。

var OK = isFinite(NUM);

isNaN

是否非数值。

var OK = isNaN(VALUE);

JSON

JSON序列化与反序列化对象。

JSON.parse

将字符串反序列化为原始值。

var DATA = JSON.parse(
	STR
	<, function(KEY_OR_INDEX, VALUE) {
		return undefined|RESULT_VALUE;
	}>
);

函数参数的返回值如为undefined，则去除属性KEY_OR_INDEX。

JSON.stringify

将原始值序列化为字符串。

var STR = JSON.stringify(
	DATA
	<, KEY_ARRAYAY|function(KEY_OR_INDEX, VALUE) {
		return undefined|RESULT_STR;
	}
	<, INDENT|N>
	>
);

函数参数的返回值如为undefined，则不对属性KEY_OR_INDEX进行序列化。

每行缩进只取INDENT前10个字符，或当1<=N<=10时使用N个空格作为缩进。

Math

数学对象。

Math.E

e，近似值为2.71828。

Math.LN10

ln(10)，近似值为2.30259。

Math.LN2

ln(2)，近似值为0.69315。

Math.LOG10E

lg(e)，近似值为0.43429。

Math.LOG2E

log2(e)，近似值为1.44270。

Math.PI

π，近似值为3.14159。

Math.SQRT1_2

1/√2，近似值为0.70711。

Math.SQRT2

√2，近似值为1.41421。

Math.abs

绝对值。

var RESULT = Math.abs(VALUE);

Math.acos

反余弦值，结果为弧度。

var RESULT = Math.acos(VALUE);

Math.asin

反正弦值，结果为弧度。

var RESULT = Math.asin(VALUE);

Math.atan

反正切值，结果为弧度。

var RESULT = Math.atan(VALUE);

Math.atan2

从x轴到指定点的弧度。

var RESULT = Math.atan2(Y, X);

等同于Math.atan(Y/X)。

Math.ceil

向上取整。

var RESULT = Math.ceil(VALUE);

Math.cos

余弦值，参数为弧度。

var RESULT = Math.cos(VALUE);

Math.exp

e的VALUE次方。

var RESULT = Math.exp(VALUE);

Math.floor

向下取整。

var RESULT = Math.floor(VALUE);

Math.log

ln(VALUE)。

var RESULT = Math.log(VALUE);

Math.max

最大值。

var RESULT = Math.max(VALUE <, ...>);

Math.min

最小值。

var RESULT = Math.min(VALUE <, ...>);

Math.pow

X的Y次方。

var RESULT = Math.pow(X, Y);

Math.random

伪随机数值，区间范围为[0.0, 1.0)。

var RESULT = Math.random();

Math.round

四舍五入值。

var RESULT = Math.round(VALUE);

Math.sin

正弦值，参数为弧度。

var RESULT = Math.sin(VALUE);

Math.sqrt

平方根值。

var RESULT = Math.sqrt(VALUE);

Math.tan

正切值，参数为弧度。

var RESULT = Math.tan(VALUE);

NaN

非数值。

Number

数值类型。

var NUMBER = new Number(NUM);
var NUMBER = Number(NUM);

Number.MAX_VALUE

最大的数值，近似值为1.79e+308。

Number.MIN_VALUE

最小的数值，近似值为5e-324。

Number.NaN

非数值，等同于NaN。

Number.NEGATIVE_INFINITY

负无穷大，等同于-Infinity。

Number.POSITIVE_INFINITY

正无穷大，等同于Infinity。

Number.prototype.toExponential

返回指数记数法表示的字符串。

var STR = NUMBER.toExponential(<N_FRACTION_DIGITS>);

Number.prototype.toFixed

返回定点记数法表示的字符串。

var STR = NUMBER.toFixed(<N_FRACTION_DIGITS>);

Number.prototype.toLocaleString

返回本地格式表示的字符串。

var STR = NUMBER.toLocaleString();

Number.prototype.toPrecision

返回有效数字为指定精度的字符串。

var STR = NUMBER.toPrecision(<N_PRECISION>);

Number.prototype.toString

返回指定进制表示的字符串。

var STR = NUMBER.toString(<RADIX>);

Number.prototype.valueOf

返回原始数字值。

var NUM = NUMBER.valueOf();

Object

对象类型。

var OBJECT = new Object(<VALUE>);

OBJECT.constructor

对象的构造函数。

Object.create

使用指定的原型和属性创建对象。

var OBJECT = Object.create(
	PROTO
	<, {
		KEY: {
			<value: VALUE>
			<, writable: BOOL>
			<, enumerable: BOOL>
			<, configurable: BOOL>
			<, get function() {return VALUE;}>
			<, set function(VALUE) {}>
		}
		<, ...>
	}>
);

属性描述对象各字段的含义如下（下同）：

  • value：属性值。数据属性有此字段。
  • writable：属性是否是可写的。数据属性有此字段。
  • enumerable：属性是否是可枚举的。数据属性和存取器属性都有此字段。
  • configurable：属性是否是可配置的，即是否可对属性的描述对象进行配置，以及属性是否可删除。数据属性和存取器属性都有此字段。
  • get：属性存取器getter。存取器属性有此字段。
  • set：属性存取其setter。存取器属性有此字段。

Object.defineProperties

定义对象的多个属性。

var OBJECT = Object.defineProperties(
	OBJECT
	<, {
		KEY: {
			<value: VALUE>
			<, writable: BOOL>
			<, enumerable: BOOL>
			<, configurable: BOOL>
			<, get function() {return VALUE;}>
			<, set function(VALUE) {}>
		}
		<, ...>
	}>
);

Object.defineProperty

定义对象的一个属性。

var OBJECT = Object.defineProperty(
	OBJECT
	, KEY
	<, {
		<value: VALUE>
		<, writable: BOOL>
		<, enumerable: BOOL>
		<, configurable: BOOL>
		<, get function() {return VALUE;}>
		<, set function(VALUE) {}>
	}>
);

Object.freeze

冻结对象。即将对象设为封闭的（就像Object.seal那样），且所有非继承属性都设置为只读（writable为false），但不影响存取器setter属性和继承属性。这是永久不可逆操作。

var OBJECT = Object.freeze(OBJECT);

Object.getOwnPropertyDescriptor

返回一个非继承属性的描述对象。

/*
{
	<value: VALUE>
	<, writable: BOOL>
	, enumerable: BOOL
	, configurable: BOOL
	<, get function() {return VALUE;}>
	<, set function(VALUE) {}>
}
*/
var DESCRIPTOR = Object.getOwnPropertyDescriptor(OBJECT, KEY);

Object.getOwnPropertyNames

返回对象所有非继承属性的名字，包括不可枚举的属性。

var KEY_ARRAY = Object.getOwnPropertyNames(OBJECT);

Object.getPrototypeOf

返回对象的原型。

var PROTO = Object.getPrototypeOf(OBJECT);

Object.isExtensible

检查对象是否是可扩展的。可扩展的即可添加新的非继承属性。

var OK = Object.isExtensible(OBJECT);

Object.isFrozen

检查对象是否是冻结的。冻结的即封闭的，且所有非继承属性都为只读（writable为false）。

var OK = Object.isFrozen(OBJECT);

Object.isSealed

检查对象是否是封闭的。封闭的即不可添加新的非继承属性（不可扩展的），且已有的非继承属性不可配置（configurable为false）。

var OK = Object.isSealed(OBJECT);

Object.keys

返回对象所有非继承可枚举的属性名。

var KEY_ARRAY = Object.keys(OBJECT);

Object.preventExtensions

将对象设置为不可扩展的。即不可以添加新的非继承属性，但不影响继承属性。这是永久不可逆操作。

var OBJECT = Object.preventExtensions(OBJECT);

Object.seal

封闭对象。即不可添加新的非继承属性（不可扩展的），且已有的非继承属性设为不可配置（configurable为false），但不影响继承属性。这是永久不可逆操作。

var OBJECT = Object.seal(OBJECT);

Object.prototype.hasOwnProperty

检查属性是否是非继承的。

var OK = OBJECT.hasOwnProperty(KEY);

Object.prototype.isPrototypeOf

检查当前对象是否是另一对象的原型。

var OK = OBJECT.isPrototypeOf(OTHER_OBJECT);

Object.prototype.propertyIsEnumerable

检查属性是否是非继承可枚举的。

var OK = OBJECT.propertyIsEnumerable(KEY);

Object.prototype.toLocaleString

返回本地格式表示的字符串。

var STR = OBJECT.toLocaleString();

Object.prototype.toString

转换成字符串。

var STR = OBJECT.toString();

Object.prototype.valueOf

返回对象原始值。如果没有，则返回对象本身。

var VALUE = OBJECT.valueOf();

parseFloat

将字符串解析为浮点数。当遇到不是组成浮点数的有效字符时，解析将终止并返回解析值，可能返回NaN。

var FLOAT = parseFloat(STR);

parseInt

将字符串解析为整数。当遇到不是组成整数的有效字符时，解析将终止并返回解析值，可能返回NaN。

var INT = parseInt(STRING <, RADIX>);

STRING可以用0x或0X的格式表示16进制。

RangeError

数值超出合法范围的错误类型，包括数组下标越界。

var RANGEERROR = new RangeError(<MESSAGE>);

RANGEERROR.message

错误消息。

RANGEERROR.name

创建错误实例的构造函数名字，即：RangeError。

ReferenceError

引用不存在的变量的错误类型。

var REFERENCEERROR = new ReferenceError(<MESSAGE>);

REFERENCEERROR.message

错误消息。

REFERENCEERROR.name

创建错误实例的构造函数名字，即：ReferenceError。

RegExp

正则表达式类型。

var REGEXP = new RegExp(PATTERN <, ATTRIBUTES>);

返回值对应的字面量为/PATTERN/ATTRIBUTES。ATTRIBUTES可为g（全局匹配，即找到所有匹配，而不是找到第一个就停止）、i（忽略大小写匹配）、m（多行匹配，即^不只匹配字符串开头也匹配行首，$不只匹配字符串结尾也匹配行尾）的任意组合。

REGEXP.global

是否是全局匹配，即是否有g修饰符。

REGEXP.ignoreCase

是否忽略大小写匹配，即是否有i修饰符。

REGEXP.lastIndex

字符串下一次匹配时的开始下标。

用于全局匹配。当REGEXP.exec或REGEXP.test没有找到匹配项时，会自动将该值设为0；当找到匹配项时，会将该值设为匹配项之后第一个字符的下标，以允许重复调用来遍历所有匹配项。如找到匹配项后需重新搜索一个新的字符串是否匹配，需显式将该值设为0。

REGEXP.multiline

是否是多行匹配，即是否有m修饰符。

REGEXP.source

对应的源文本，即PATTERN。

RegExp.prototype.exec

通用的模式匹配。

/*
[
	MATCHED_STR
	<, MATCHED_STR_OF_GROUP <, ...>>,
	index: BEGIN_INDEX_OF_MATCHED_STR,
	input: STR
]
*/
var ARRAY = REGEXP.exec(STR);

如找到匹配项，则返回一个数组：第一个元素MATCHED_STR是STR中与正则表达式匹配的字符串，其后的元素MATCHED_STR_OF_GROUP是MATCHED_STR与正则表达式各个分组（使用“()”引起）匹配的字符串，index为MATCHED_STR第一个字符在STR中的下标，input为REGEXP.exec的参数即STR。如找不到匹配项，则返回null。

RegExp.prototype.test

测试字符串是否匹配。

var OK = REGEXP.test(STR);

RegExp.prototype.toString

转换成字符串。

var STR = REGEXP.toString();

返回的字符串跟字面量的形式/PATTERN/ATTRIBUTES一样，可能带有转义字符。

String

字符串类型。

var STRING = new String(STR);

以下接口已弃用：

  • String.prototype.substr

STRING.length

字符串字符个数。只读属性。

String.fromCharCode

使用Unicode编码创建字符串。

var STR = String.fromCharCode(CODE <, ...>);

String.prototype.charAt

返回第N个字符。如下标越界，则返回空字符串。

var STR = STRING.charAt(N);

String.prototype.charCodeAt

返回第N个字符的Unicode编码，为16位的整数。如下标越界，则返回NaN。

var CODE = STRING.charCodeAt(N);

String.prototype.concat

拼接字符串。

var NEW_STR = STRING.concat(STR <, ...>);

String.prototype.indexOf

正向查找字符串。返回子字符串第一个字符在原字符串中的下标，如不存在，则返回-1。

var INDEX = STRING.indexOf(SUB_STR <, START_INDEX>);

String.prototype.lastIndexOf

反向查找字符串。返回子字符串第一个字符在原字符串中的下标，如不存在，则返回-1。

var INDEX = STRING.lastIndexOf(SUB_STR <, START_INDEX>);

String.prototype.localeCompare

使用本地规则比较字符串。该函数利用操作系统提供的排序。

var RESULT = STRING.localeCompare(OTHER_STR);

如返回值小于0，表示STRING<OTHER_STR；等于0，表示STRING==OTHER_STR或无法区分；大于0，表示STRING>OTHER_STR。

String.prototype.match

搜索匹配的子字符串。

// 当REGEXP为全局匹配时：
/*
[MATCHED_STR <, ...>]
*/
// 当REGEXP不为全局匹配时：
/*
[
	MATCHED_STR
	<, MATCHED_STR_OF_GROUP <, ...>>,
	index: BEGIN_INDEX_OF_MATCHED_STR,
	input: STRING
]
*/
var ARRAY = STRING.match(REGEXP);

当REGEXP为全局匹配时，如找到匹配项，则返回一个数组：各个元素MATCHED_STR是STRING中与正则表达式匹配的字符串。如找不到匹配项，则返回null。

当REGEXP不为全局匹配时，如找到匹配项，则返回一个数组：第一个元素MATCHED_STR是STRING中与正则表达式匹配的字符串，其后的元素MATCHED_STR_OF_GROUP是MATCHED_STR与正则表达式各个分组（使用“()”引起）匹配的字符串，index为MATCHED_STR第一个字符在STRING中的下标，input即STRING。如找不到匹配项，则返回null。

String.prototype.replace

替换匹配的子字符串。

var STR_REPLACED = STRING.replace(
	STR|REGEXP,
	REPLACEMENT_STR|function(MATCHED_STR <, MATCHED_STR_OF_GROUP <, ...>>, BEGIN_INDEX_OF_MATCHED_STR, STRING) {
		return REPLACEMENT_STR;
	}
);

当REGEXP为全局匹配时，替换所有匹配的子字符串。否则，只替换第一个匹配的子字符串。

REPLACEMENT_STR中的“$”有特殊含义：

  • $N：匹配的子字符串中与正则表达式第N个分组（使用“()”引起）匹配的字符串。
  • $&：匹配的子字符串。
  • $`：匹配的子字符串左边的字符串。
  • $'：匹配的子字符串右边的字符串。
  • $$：$符号自身。

函数参数的参数中，第一个参数MATCHED_STR是STRING中与正则表达式匹配的字符串，其后的参数MATCHED_STR_OF_GROUP是MATCHED_STR与正则表达式各个分组（使用“()”引起）匹配的字符串，BEGIN_INDEX_OF_MATCHED_STR为MATCHED_STR第一个字符在STRING中的下标，STRING即String对象自身。

String.prototype.search

查找匹配的子字符串。

var INDEX = STRING.search(REGEXP);

返回第一个匹配的子字符串的第一个字符在STRING中的下标，如不存在，则返回-1。总是从头开始搜索，不进行全局匹配，即忽略g修饰符和lastIndex属性。

String.prototype.slice

使用字符串的一部分生成新字符串。

var NEW_STR = STRING.slice(START_INDEX <, END_INDEX>);

新字符串对应STRING的区间为[START_INDEX, END_INDEX)。START_INDEX和END_INDEX均可为负数，表示从尾部数起，-1为最后一个元素。

String.prototype.split

将字符串切割成数组。

var ARRAY = STRING.split(<DELIMITER|REGEXP <, LIMIT>>);

如果不指定分隔规则，则返回只包含字符串自身一个元素的数组。

如果分隔规则为空字符串，则返回的数组将字符串每个字符作为一个元素。

如果分隔规则匹配字符串开头的内容，则第一个元素是空字符串；如果分隔规则匹配字符串结尾的内容，则最后一个元素是空字符串。（分隔规则为空字符串的时候除外。）

如果分隔规则为带有分组（使用“()”引起）的正则表达式，则匹配分组的子字符串也会包含在数组中。

String.prototype.substring

返回子字符串。

var NEW_STR = STRING.substring(START_INDEX <, END_INDEX>);

新字符串对应STRING的区间为[START_INDEX, END_INDEX)。START_INDEX和END_INDEX均不可为负数。

String.prototype.toLocaleLowerCase

转换成本地格式小写的字符串。

var NEW_STR = STRING.toLocaleLowerCase();

String.prototype.toLocaleUpperCase

转换成本地格式大写的字符串。

var NEW_STR = STRING.toLocaleUpperCase();

String.prototype.toLowerCase

转换成小写字符串。

var NEW_STR = STRING.toLowerCase();

String.prototype.toString

返回原始字符串值。

var STR = STRING.toString();

String.prototype.toUpperCase

转换成大写字符串。

var NEW_STR = STRING.toUpperCase();

String.prototype.trim

去除开头和结尾的空白字符。

var NEW_STR = STRING.trim();

String.prototype.valueOf

返回原始字符串值。

var STR = STRING.valueOf();

SyntaxError

语法错误的错误类型。

var SYNTAXERROR = new SyntaxError(<MESSAGE>);

SYNTAXERROR.message

错误消息。

SYNTAXERROR.name

创建错误实例的构造函数名字，即：SyntaxError。

TypeError

值类型错误的错误类型。

var TYPEERROR = new TypeError(<MESSAGE>);

TypeError.message

错误消息。

TypeError.name

创建错误实例的构造函数名字，即：TypeError。

undefined

未定义值。

undefined不是常量，可以设置为其他值，但必须非常谨慎。

URIError

URI编码或解码错误的错误类型。

var URIERROR = new URIError(<MESSAGE>);

URIError.message

错误消息。

URIError.name

创建错误实例的构造函数名字，即：URIError。

posted @ 2020-09-01 20:22  garvenc  阅读(365)  评论(0)  编辑  收藏  举报