/////////////////////////////
/// ECMAScript APIs
/////////////////////////////
declare let NaN: number;
declare let Infinity: number;
/**
* 评估 JavaScript 代码并执行它。
* @param x 包含有效 JavaScript 代码的字符串值。
*/
declare function eval(x: string): any;
/**
* 将字符串转换为整数。
* @param string 要转换为数字的字符串。
* @param radix 指定字符串中数字的基数，介于 2 和 36 之间的值。
* 如果未提供此参数，则以 '0x' 为前缀的字符串被视为十六进制。
* 所有其他字符串被视为十进制。
*/
declare function parseInt(string: string, radix?: number): number;
/**
* 将字符串转换为浮点数。
* @param string 包含浮点数的字符串。
*/
declare function parseFloat(string: string): number;
/**
* 返回一个布尔值，指示一个值是否为保留值 NaN（非数字）。
* @param number 数值。
*/
declare function isNaN(number: number): boolean;
/**
* 确定提供的数字是否为有限数。
* @param number 任意数值。
*/
declare function isFinite(number: number): boolean;
/**
* 获取编码的统一资源标识符 (URI) 的未编码版本。
* @param encodedURI 表示编码 URI 的值。
*/
declare function decodeURI(encodedURI: string): string;
/**
* 获取编码的统一资源标识符 (URI) 组件的未编码版本。
* @param encodedURIComponent 表示编码 URI 组件的值。
*/
declare function decodeURIComponent(encodedURIComponent: string): string;
/**
* 将文本字符串编码为有效的统一资源标识符 (URI)。
* @param uri 表示未编码 URI 的值。
*/
declare function encodeURI(uri: string): string;
/**
* 将文本字符串编码为有效的统一资源标识符 (URI) 组件。
* @param uriComponent 表示未编码 URI 组件的值。
*/
declare function encodeURIComponent(uriComponent: string | number | boolean): string;
/**
* 计算一个新字符串，其中某些字符已被十六进制转义序列替换。
* @deprecated 为了浏览器兼容性的遗留功能
* @param string 字符串值
*/
declare function escape(string: string): string;
/**
* 计算一个新字符串，其中的十六进制转义序列被替换为它所代表的字符。
* @deprecated 为了浏览器兼容性的遗留功能
* @param string 字符串值
*/
declare function unescape(string: string): string;
interface Symbol {
/** 返回对象的字符串表示形式。 */
toString(): string;
/** 返回指定对象的原始值。 */
valueOf(): symbol;
}
declare type PropertyKey = string | number | symbol;
interface PropertyDescriptor {
configurable?: boolean;
enumerable?: boolean;
value?: any;
writable?: boolean;
get?(): any;
set?(v: any): void;
}
interface PropertyDescriptorMap {
[key: PropertyKey]: PropertyDescriptor;
}
interface Object {
/** Object.prototype.constructor 的初始值是标准内置的 Object 构造函数。 */
constructor: Function;
/** 返回对象的字符串表示形式。 */
toString(): string;
/** 使用当前区域设置将日期转换为字符串。 */
toLocaleString(): string;
/** 返回指定对象的原始值。 */
valueOf(): Object;
/**
* 确定对象是否具有指定名称的属性。
* @param v 属性名称。
*/
hasOwnProperty(v: PropertyKey): boolean;
/**
* 确定对象是否存在于另一个对象的原型链中。
* @param v 另一个对象，其原型链将被检查。
*/
isPrototypeOf(v: Object): boolean;
/**
* 确定指定的属性是否可枚举。
* @param v 属性名称。
*/
propertyIsEnumerable(v: PropertyKey): boolean;
}
interface ObjectConstructor {
new(value?: any): Object;
(): any;
(value: any): any;
/** 对象类的原型的引用。 */
readonly prototype: Object;
/**
* 返回对象的原型。
* @param o 引用原型的对象。
*/
getPrototypeOf(o: any): any;
/**
* 获取指定对象的自有属性描述符。
* 自有属性描述符是直接在对象上定义的属性描述符，而不是从对象的原型继承的。
* @param o 包含属性的对象。
* @param p 属性名称。
*/
getOwnPropertyDescriptor(o: any, p: PropertyKey): PropertyDescriptor | undefined;
/**
* 返回对象的自有属性的名称。对象的自有属性是直接在该对象上定义的属性，
* 而不是从对象的原型继承的。对象的属性包括字段（对象）和函数。
* @param o 包含自有属性的对象。
*/
getOwnPropertyNames(o: any): string[];
/**
* 创建一个具有指定原型或 null 原型的对象。
* @param o 用作原型的对象。可以为 null。
*/
create(o: object | null): any;
/**
* 创建一个具有指定原型的对象，并且可选地包含指定的属性。
* @param o 用作原型的对象。可以为 null。
* @param properties 包含一个或多个属性描述符的 JavaScript 对象。
*/
create(o: object | null, properties: PropertyDescriptorMap & ThisType<any>): any;
/**
* 向对象添加属性，或修改现有属性的属性。
* @param o 要添加或修改属性的对象。可以是原生 JavaScript 对象（即用户定义的对象或内置对象）或 DOM 对象。
* @param p 属性名称。
* @param attributes 属性的描述符。可以是数据属性或访问器属性。
*/
defineProperty<T>(o: T, p: PropertyKey, attributes: PropertyDescriptor & ThisType<any>): T;
/**
* 向对象添加一个或多个属性，和/或修改现有属性的属性。
* @param o 要添加或修改属性的对象。可以是原生 JavaScript 对象或 DOM 对象。
* @param properties 包含一个或多个描述符对象的 JavaScript 对象。每个描述符对象描述一个数据属性或访问器属性。
*/
defineProperties<T>(o: T, properties: PropertyDescriptorMap & ThisType<any>): T;
/**
* 防止修改现有属性的属性，并防止添加新属性。
* @param o 要锁定属性的对象。
*/
seal<T>(o: T): T;
/**
* 防止修改现有属性的属性和值，并防止添加新属性。
* @param f 要锁定属性的对象。
*/
freeze<T extends Function>(f: T): T;
/**
* 防止修改现有属性的属性和值，并防止添加新属性。
* @param o 要锁定属性的对象。
*/
freeze<T extends { [idx: string]: U | null | undefined | object; }, U extends string | bigint | number | boolean | symbol>(o: T): Readonly<T>;
/**
* 防止修改现有属性的属性和值，并防止添加新属性。
* @param o 要锁定属性的对象。
*/
freeze<T>(o: T): Readonly<T>;
/**
* 防止向对象添加新属性。
* @param o 要使其不可扩展的对象。
*/
preventExtensions<T>(o: T): T;
/**
* 如果对象中的现有属性不能被修改，并且不能向对象添加新属性，则返回 true。
* @param o 要测试的对象。
*/
isSealed(o: any): boolean;
/**
* 如果对象中的现有属性和属性值不能被修改，并且不能向对象添加新属性，则返回 true。
* @param o 要测试的对象。
*/
isFrozen(o: any): boolean;
/**
* 返回一个值，指示是否可以向对象添加新属性。
* @param o 要测试的对象。
*/
isExtensible(o: any): boolean;
/**
* 返回对象的可枚举字符串属性和方法的名称。
* @param o 包含属性和方法的对象。可以是您创建的对象或现有的文档对象模型 (DOM) 对象。
*/
keys(o: object): string[];
}
/**
* 提供所有 JavaScript 对象的通用功能。
*/
declare var Object: ObjectConstructor;
/**
* 创建一个新函数。
*/
interface Function {
/**
* 调用函数，用指定的对象替换函数的 this 值，并用指定的数组替换函数的参数。
* @param thisArg 用作 this 对象的对象。
* @param argArray 要传递给函数的一组参数。
*/
apply(this: Function, thisArg: any, argArray?: any): any;
/**
* 调用对象的方法，用另一个对象替换当前对象。
* @param thisArg 用作当前对象的对象。
* @param argArray 要传递给方法的参数列表。
*/
call(this: Function, thisArg: any, ...argArray: any[]): any;
/**
* 对于给定的函数，创建一个具有与原始函数相同主体的绑定函数。
* 绑定函数的 this 对象与指定对象关联，并具有指定的初始参数。
* @param thisArg 可以在新函数内部引用的对象。
* @param argArray 要传递给新函数的参数列表。
*/
bind(this: Function, thisArg: any, ...argArray: any[]): any;
/** 返回函数的字符串表示形式。 */
toString(): string;
prototype: any;
readonly length: number;
// 非标准扩展
arguments: any;
caller: Function;
}
interface FunctionConstructor {
/**
* 创建一个新函数。
* @param args 函数接受的参数列表。
*/
new(...args: string[]): Function;
(...args: string[]): Function;
readonly prototype: Function;
}
declare var Function: FunctionConstructor;
/**
* 提取函数类型的 'this' 参数的类型，如果函数类型没有 'this' 参数，则为 'unknown'。
*/
type ThisParameterType<T> = T extends (this: infer U, ...args: never) => any ? U : unknown;
/**
* 从函数类型中删除 'this' 参数。
*/
type OmitThisParameter<T> = unknown extends ThisParameterType<T> ? T : T extends (...args: infer A) => infer R ? (...args: A) => R : T;
interface CallableFunction extends Function {
/**
* 使用指定的对象作为 this 值和指定数组的元素作为参数调用函数。
* @param thisArg 用作 this 对象的对象。
*/
apply<T, R>(this: (this: T) => R, thisArg: T): R;
/**
* 使用指定的对象作为 this 值和指定数组的元素作为参数调用函数。
* @param thisArg 用作 this 对象的对象。
* @param args 要传递给函数的参数值数组。
*/
apply<T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg: T, args: A): R;
/**
* 使用指定的对象作为 this 值和指定的剩余参数作为参数调用函数。
* @param thisArg 用作 this 对象的对象。
* @param args 要传递给函数的参数值。
*/
call<T, A extends any[], R>(this: (this: T, ...args: A) => R, thisArg: T, ...args: A): R;
/**
* 对于给定的函数，创建一个具有与原始函数相同主体的绑定函数。
* 绑定函数的 this 对象与指定对象关联，并具有指定的初始参数。
* @param thisArg 用作 this 对象的对象。
*/
bind<T>(this: T, thisArg: ThisParameterType<T>): OmitThisParameter<T>;
/**
* 对于给定的函数，创建一个具有与原始函数相同主体的绑定函数。
* 绑定函数的 this 对象与指定对象关联，并具有指定的初始参数。
* @param thisArg 用作 this 对象的对象。
* @param args 要绑定到函数参数的参数。
*/
bind<T, A extends any[], B extends any[], R>(this: (this: T, ...args: [...A, ...B]) => R, thisArg: T, ...args: A): (...args: B) => R;
}
interface NewableFunction extends Function {
/**
* 使用指定的对象作为 this 值和指定数组的元素作为参数调用函数。
* @param thisArg 用作 this 对象的对象。
*/
apply<T>(this: new () => T, thisArg: T): void;
/**
* 使用指定的对象作为 this 值和指定数组的元素作为参数调用函数。
* @param thisArg 用作 this 对象的对象。
* @param args 要传递给函数的参数值数组。
*/
apply<T, A extends any[]>(this: new (...args: A) => T, thisArg: T, args: A): void;
/**
* 使用指定的对象作为 this 值和指定的剩余参数作为参数调用函数。
* @param thisArg 用作 this 对象的对象。
* @param args 要传递给函数的参数值。
*/
call<T, A extends any[]>(this: new (...args: A) => T, thisArg: T, ...args: A): void;
/**
* 对于给定的函数，创建一个具有与原始函数相同主体的绑定函数。
* 绑定函数的 this 对象与指定对象关联，并具有指定的初始参数。
* @param thisArg 用作 this 对象的对象。
*/
bind<T>(this: T, thisArg: any): T;
/**
* 对于给定的函数，创建一个具有与原始函数相同主体的绑定函数。
* 绑定函数的 this 对象与指定对象关联，并具有指定的初始参数。
* @param thisArg 用作 this 对象的对象。
* @param args 要绑定到函数参数的参数。
*/
bind<A extends any[], B extends any[], R>(this: new (...args: [...A, ...B]) => R, thisArg: any, ...args: A): new (...args: B) => R;
}
interface IArguments {
[index: number]: any;
length: number;
callee: Function;
}
interface String {
/** 返回字符串的字符串表示形式。 */
toString(): string;
/**
* 返回指定索引处的字符。
* @param pos 所需字符的零基索引。
*/
charAt(pos: number): string;
/**
* 返回指定位置的字符的 Unicode 值。
* @param index 所需字符的零基索引。如果指定索引处没有字符，则返回 NaN。
*/
charCodeAt(index: number): number;
/**
* 返回包含两个或多个字符串连接的字符串。
* @param strings 要附加到字符串末尾的字符串。
*/
concat(...strings: string[]): string;
/**
* 返回子字符串的第一个出现位置。
* @param searchString 要在字符串中搜索的子字符串
* @param position 开始搜索 String 对象的索引。如果省略，则从字符串的开头开始搜索。
*/
indexOf(searchString: string, position?: number): number;
/**
* 返回字符串中子字符串的最后一次出现位置。
* @param searchString 要搜索的子字符串。
* @param position 开始搜索的索引。如果省略，则从字符串的末尾开始搜索。
*/
lastIndexOf(searchString: string, position?: number): number;
/**
* 确定两个字符串在当前区域设置中是否等效。
* @param that 要与目标字符串比较的字符串
*/
localeCompare(that: string): number;
/**
* 使用正则表达式匹配字符串，并返回包含该搜索结果的数组。
* @param regexp 包含正则表达式模式和标志的变量名或字符串字面量。
*/
match(regexp: string | RegExp): RegExpMatchArray | null;
/**
* 使用正则表达式或搜索字符串替换字符串中的文本。
* @param searchValue 要搜索的字符串或正则表达式。
* @param replaceValue 包含要替换的文本的字符串。当 {@linkcode searchValue} 是 `RegExp` 时，如果设置了 `g` 标志，则替换所有匹配项（如果 `y` 标志也存在，则仅替换开头的匹配项）。否则，仅替换 {@linkcode searchValue} 的第一个匹配项。
*/
replace(searchValue: string | RegExp, replaceValue: string): string;
/**
* 使用正则表达式或搜索字符串替换字符串中的文本。
* @param searchValue 要搜索的字符串。
* @param replacer 返回替换文本的函数。
*/
replace(searchValue: string | RegExp, replacer: (substring: string, ...args: any[]) => string): string;
/**
* 在正则表达式搜索中查找第一个子字符串匹配项。
* @param regexp 正则表达式模式和适用的标志。
*/
search(regexp: string | RegExp): number;
/**
* 返回字符串的一部分。
* @param start 指定部分的起始索引。
* @param end 指定部分的结束索引。子字符串包括从 start 到 end（不包括 end）之间的字符。
* 如果未指定此值，则子字符串继续到字符串的末尾。
*/
slice(start?: number, end?: number): string;
/**
* 使用指定的分隔符将字符串拆分为子字符串，并将它们作为数组返回。
* @param separator 一个字符串，用于标识用于分隔字符串的字符。如果省略，则返回包含整个字符串的单元素数组。
* @param limit 用于限制返回的元素数量的值。
*/
split(separator: string | RegExp, limit?: number): string[];
/**
* 返回字符串对象中指定位置的子字符串。
* @param start 指示子字符串开始位置的零基索引号。
* @param end 指示子字符串结束位置的零基索引号。子字符串包括从 start 到 end（不包括 end）之间的字符。
* 如果省略 end，则返回从 start 到原始字符串末尾的字符。
*/
substring(start: number, end?: number): string;
/** 将字符串中的所有字母字符转换为小写。 */
toLowerCase(): string;
/** 将所有字母字符转换为小写，考虑到主机环境的当前区域设置。 */
toLocaleLowerCase(locales?: string | string[]): string;
/** 将字符串中的所有字母字符转换为大写。 */
toUpperCase(): string;
/** 返回一个字符串，其中所有字母字符都已转换为大写，考虑到主机环境的当前区域设置。 */
toLocaleUpperCase(locales?: string | string[]): string;
/** 删除字符串开头和结尾的空白字符和行终止符字符。 */
trim(): string;
/** 返回字符串对象的长度。 */
readonly length: number;
// IE 扩展
/**
* 获取从指定位置开始并具有指定长度的子字符串。
* @deprecated 一个用于浏览器兼容性的遗留功能
* @param from 所需子字符串的起始位置。字符串中第一个字符的索引为零。
* @param length 返回的子字符串中包含的字符数。
*/
substr(from: number, length?: number): string;
/** 返回指定对象的原始值。 */
valueOf(): string;
readonly [index: number]: string;
}
interface StringConstructor {
new(value?: any): String;
(value?: any): string;
readonly prototype: String;
fromCharCode(...codes: number[]): string;
}
/**
* 允许操作和格式化文本字符串，并确定和定位字符串中的子字符串。
*/
declare var String: StringConstructor;
interface Boolean {
/** 返回指定对象的原始值。 */
valueOf(): boolean;
}
interface BooleanConstructor {
new(value?: any): Boolean;
<T>(value?: T): boolean;
readonly prototype: Boolean;
}
declare var Boolean: BooleanConstructor;
interface Number {
/**
* 返回对象的字符串表示形式。
* @param radix 指定用于将数值转换为字符串的基数。此值仅用于数字。
*/
toString(radix?: number): string;
/**
* 返回以定点表示法表示的数字的字符串。
* @param fractionDigits 小数点后的位数。必须在 0 到 20 的范围内（包括 0 和 20）。
*/
toFixed(fractionDigits?: number): string;
/**
* 返回以指数表示法表示的数字的字符串。
* @param fractionDigits 小数点后的位数。必须在 0 到 20 的范围内（包括 0 和 20）。
*/
toExponential(fractionDigits?: number): string;
/**
* 返回以指定位数表示的数字的字符串，表示为指数或定点表示法。
* @param precision 有效数字的位数。必须在 1 到 21 的范围内（包括 1 和 21）。
*/
toPrecision(precision?: number): string;
/** 返回指定对象的原始值。 */
valueOf(): number;
}
interface NumberConstructor {
new(value?: any): Number;
(value?: any): number;
readonly prototype: Number;
/** JavaScript 中可以表示的最大数字。约等于 1.79E+308。 */
readonly MAX_VALUE: number;
/** JavaScript 中可以表示的最接近零的数字。约等于 5.00E-324。 */
readonly MIN_VALUE: number;
/**
* 一个不是数字的值。
* 在相等比较中，NaN 不等于任何值，包括它本身。要测试一个值是否等于 NaN，请使用 isNaN 函数。
*/
readonly NaN: number;
/**
* 一个小于 JavaScript 中可以表示的最大负数的值。
* JavaScript 将 NEGATIVE_INFINITY 值显示为 -infinity。
*/
readonly NEGATIVE_INFINITY: number;
/**
* 一个大于 JavaScript 中可以表示的最大数字的值。
* JavaScript 将 POSITIVE_INFINITY 值显示为 infinity。
*/
readonly POSITIVE_INFINITY: number;
}
/** 表示任何类型数字的对象。所有 JavaScript 数字都是 64 位浮点数。 */
declare var Number: NumberConstructor;
interface TemplateStringsArray extends ReadonlyArray<string> {
readonly raw: readonly string[];
}
/**
* `import.meta` 的类型。
*
* 如果需要声明 `import.meta` 上存在的某个属性，可以通过接口合并来扩展此类型。
*/
interface ImportMeta {
}
/**
* `import()` 的可选第二个参数的类型。
*
* 如果主机环境支持其他选项，可以通过接口合并来扩展此类型。
*/
interface ImportCallOptions {
/** @deprecated*/ assert?: ImportAssertions;
with?: ImportAttributes;
}
/**
* `import()` 的可选第二个参数的 `assert` 属性的类型。
* @deprecated
*/
interface ImportAssertions {
[key: string]: string;
}
/**
* `import()` 的可选第二个参数的 `with` 属性的类型。
*/
interface ImportAttributes {
[key: string]: string;
}
interface Math {
/** 数学常数 e。即欧拉数，自然对数的底数。 */
readonly E: number;
/** 10 的自然对数。 */
readonly LN10: number;
/** 2 的自然对数。 */
readonly LN2: number;
/** e 的以 2 为底的对数。 */
readonly LOG2E: number;
/** e 的以 10 为底的对数。 */
readonly LOG10E: number;
/** 圆周率。即圆的周长与直径的比值。 */
readonly PI: number;
/** 0.5 的平方根，或等效地，1 除以 2 的平方根。 */
readonly SQRT1_2: number;
/** 2 的平方根。 */
readonly SQRT2: number;
/**
* 返回一个数的绝对值（不考虑其正负值）。
* 例如，-5 的绝对值与 5 的绝对值相同。
* @param x 需要绝对值的数值表达式。
*/
abs(x: number): number;
/**
* 返回一个数的反余弦（或反余弦）。
* @param x 数值表达式。
*/
acos(x: number): number;
/**
* 返回一个数的反正弦。
* @param x 数值表达式。
*/
asin(x: number): number;
/**
* 返回一个数的反正切。
* @param x 需要反正切的数值表达式。
*/
atan(x: number): number;
/**
* 返回从 X 轴到某点的角度（以弧度表示）。
* @param y 表示笛卡尔 y 坐标的数值表达式。
* @param x 表示笛卡尔 x 坐标的数值表达式。
*/
atan2(y: number, x: number): number;
/**
* 返回大于或等于其数值参数的最小整数。
* @param x 数值表达式。
*/
ceil(x: number): number;
/**
* 返回一个数的余弦值。
* @param x 包含以弧度表示的角度的数值表达式。
*/
cos(x: number): number;
/**
* 返回 e（自然对数的底数） 的幂。
* @param x 表示 e 的幂的数值表达式。
*/
exp(x: number): number;
/**
* 返回小于或等于其数值参数的最大整数。
* @param x 数值表达式。
*/
floor(x: number): number;
/**
* 返回一个数的自然对数（以 e 为底）。
* @param x 数值表达式。
*/
log(x: number): number;
/**
* 返回一组提供的数值表达式中的最大值。
* @param values 要计算的数值表达式。
*/
max(...values: number[]): number;
/**
* 返回一组提供的数值表达式中的最小值。
* @param values 要计算的数值表达式。
*/
min(...values: number[]): number;
/**
* 返回一个基数表达式的指定幂的值。
* @param x 表达式的基数值。
* @param y 表达式的指数值。
*/
pow(x: number, y: number): number;
/** 返回介于 0 和 1 之间的伪随机数。 */
random(): number;
/**
* 返回四舍五入到最接近整数的提供的数值表达式。
* @param x 要四舍五入到最接近整数的值。
*/
round(x: number): number;
/**
* 返回一个数的正弦值。
* @param x 包含以弧度表示的角度的数值表达式。
*/
sin(x: number): number;
/**
* 返回一个数的平方根。
* @param x 数值表达式。
*/
sqrt(x: number): number;
/**
* 返回一个数的正切值。
* @param x 包含以弧度表示的角度的数值表达式。
*/
tan(x: number): number;
}
/** 提供基本数学功能和常量的内置对象。 */
declare var Math: Math;
/** 启用日期和时间的基本存储和检索。 */
interface Date {
/** 返回日期的字符串表示形式。字符串的格式取决于区域设置。 */
toString(): string;
/** 以字符串形式返回日期。 */
toDateString(): string;
/** 以字符串形式返回时间。 */
toTimeString(): string;
/** 返回适合主机环境当前区域设置的字符串值。 */
toLocaleString(): string;
/** 返回适合主机环境当前区域设置的日期字符串值。 */
toLocaleDateString(): string;
/** 返回适合主机环境当前区域设置的时间字符串值。 */
toLocaleTimeString(): string;
/** 返回自 1970 年 1 月 1 日午夜以来的毫秒数。 */
valueOf(): number;
/** 返回自 1970 年 1 月 1 日午夜以来的毫秒数。 */
getTime(): number;
/** 获取年份，使用本地时间。 */
getFullYear(): number;
/** 获取年份，使用协调世界时 (UTC)。 */
getUTCFullYear(): number;
/** 获取月份，使用本地时间。 */
getMonth(): number;
/** 获取日期对象的月份，使用协调世界时 (UTC)。 */
getUTCMonth(): number;
/** 获取月份中的某一天，使用本地时间。 */
getDate(): number;
/** 获取月份中的某一天，使用协调世界时 (UTC)。 */
getUTCDate(): number;
/** 获取星期几，使用本地时间。 */
getDay(): number;
/** 获取星期几，使用协调世界时 (UTC)。 */
getUTCDay(): number;
/** 获取日期中的小时数，使用本地时间。 */
getHours(): number;
/** 获取日期对象中的小时值，使用协调世界时 (UTC)。 */
getUTCHours(): number;
/** 获取日期对象的分钟数，使用本地时间。 */
getMinutes(): number;
/** 获取日期对象的分钟数，使用协调世界时 (UTC)。 */
getUTCMinutes(): number;
/** 获取日期对象的秒数，使用本地时间。 */
getSeconds(): number;
/** 获取日期对象的秒数，使用协调世界时 (UTC)。 */
getUTCSeconds(): number;
/** 获取日期的毫秒数，使用本地时间。 */
getMilliseconds(): number;
/** 获取日期对象的毫秒数，使用协调世界时 (UTC)。 */
getUTCMilliseconds(): number;
/** 获取协调世界时 (UTC) 与本地计算机时间之间的分钟差。 */
getTimezoneOffset(): number;
/**
* 设置日期对象中的日期和时间值。
* @param time 表示自 1970 年 1 月 1 日午夜以来经过的毫秒数的数值。
*/
setTime(time: number): number;
/**
* 设置日期对象中的毫秒值，使用本地时间。
* @param ms 表示毫秒值的数值。
*/
setMilliseconds(ms: number): number;
/**
* 设置日期对象中的毫秒值，使用协调世界时 (UTC)。
* @param ms 表示毫秒值的数值。
*/
setUTCMilliseconds(ms: number): number;
/**
* 设置日期对象中的秒值，使用本地时间。
* @param sec 表示秒值的数值。
* @param ms 表示毫秒值的数值。
*/
setSeconds(sec: number, ms?: number): number;
/**
* 设置日期对象中的秒值，使用协调世界时 (UTC)。
* @param sec 表示秒值的数值。
* @param ms 表示毫秒值的数值。
*/
setUTCSeconds(sec: number, ms?: number): number;
/**
* 设置日期对象中的分钟值，使用本地时间。
* @param min 表示分钟值的数值。
* @param sec 表示秒值的数值。
* @param ms 表示毫秒值的数值。
*/
setMinutes(min: number, sec?: number, ms?: number): number;
/**
* 设置日期对象中的分钟值，使用协调世界时 (UTC)。
* @param min 表示分钟值的数值。
* @param sec 表示秒值的数值。
* @param ms 表示毫秒值的数值。
*/
setUTCMinutes(min: number, sec?: number, ms?: number): number;
/**
* 设置日期对象中的小时值，使用本地时间。
* @param hours 表示小时值的数值。
* @param min 表示分钟值的数值。
* @param sec 表示秒值的数值。
* @param ms 表示毫秒值的数值。
*/
setHours(hours: number, min?: number, sec?: number, ms?: number): number;
/**
* 设置日期对象中的小时值，使用协调世界时 (UTC)。
* @param hours 表示小时值的数值。
* @param min 表示分钟值的数值。
* @param sec 表示秒值的数值。
* @param ms 表示毫秒值的数值。
*/
setUTCHours(hours: number, min?: number, sec?: number, ms?: number): number;
/**
* 设置日期对象中的月份中的某一天，使用本地时间。
* @param date 表示月份中的某一天的数值。
*/
setDate(date: number): number;
/**
* 设置日期对象中的月份中的某一天，使用协调世界时 (UTC)。
* @param date 表示月份中的某一天的数值。
*/
setUTCDate(date: number): number;
/**
* 设置日期对象中的月份值，使用本地时间。
* @param month 表示月份的数值。1 月的值为 0，其他月份值依次递增。
* @param date 表示月份中的某一天的数值。如果未提供此值，则使用 getDate 方法的返回值。
*/
setMonth(month: number, date?: number): number;
/**
* 设置日期对象中的月份值，使用协调世界时 (UTC)。
* @param month 表示月份的数值。1 月的值为 0，其他月份值依次递增。
* @param date 表示月份中的某一天的数值。如果未提供此值，则使用 getUTCDate 方法的返回值。
*/
setUTCMonth(month: number, date?: number): number;
/**
* 设置日期对象中的年份，使用本地时间。
* @param year 表示年份的数值。
* @param month 表示月份的零基数值（0 表示 1 月，11 表示 12 月）。如果指定了 numDate，则必须指定此值。
* @param date 表示月份中的某一天的数值。
*/
setFullYear(year: number, month?: number, date?: number): number;
/**
* 设置日期对象中的年份值，使用协调世界时 (UTC)。
* @param year 表示年份的数值。
* @param month 表示月份的数值。1 月的值为 0，其他月份值依次递增。如果指定了 numDate，则必须指定此值。
* @param date 表示月份中的某一天的数值。
*/
setUTCFullYear(year: number, month?: number, date?: number): number;
/** 返回使用协调世界时 (UTC) 转换为字符串的日期。 */
toUTCString(): string;
/** 返回 ISO 格式的日期字符串值。 */
toISOString(): string;
/** 由 JSON.stringify 方法使用，以启用对象数据的转换，以进行 JavaScript 对象表示法 (JSON) 序列化。 */
toJSON(key?: any): string;
}
interface DateConstructor {
new(): Date;
new(value: number | string): Date;
/**
* 创建一个新的日期对象。
* @param year 为跨世纪日期准确性所需的完整年份。如果年份在 0 到 99 之间，则假定年份为 1900 + year。
* @param monthIndex 表示月份的数值，范围为 0 到 11（1 月到 12 月）。
* @param date 表示日期的数值，范围为 1 到 31。
* @param hours 如果提供了 minutes，则必须提供此参数。表示小时的数值，范围为 0 到 23（午夜到晚上 11 点）。
* @param minutes 如果提供了 seconds，则必须提供此参数。表示分钟的数值，范围为 0 到 59。
* @param seconds 如果提供了 milliseconds，则必须提供此参数。表示秒的数值，范围为 0 到 59。
* @param ms 表示毫秒的数值，范围为 0 到 999。
*/
new(year: number, monthIndex: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): Date;
(): string;
readonly prototype: Date;
/**
* 解析包含日期的字符串，并返回该日期与 1970 年 1 月 1 日午夜之间的毫秒数。
* @param s 日期字符串
*/
parse(s: string): number;
/**
* 返回自 1970 年 1 月 1 日午夜（协调世界时 (UTC) 或格林尼治标准时间 (GMT)）以来的毫秒数。
* @param year 为跨世纪日期准确性所需的完整年份。如果年份在 0 到 99 之间，则假定年份为 1900 + year。
* @param monthIndex 表示月份的数值，范围为 0 到 11（1 月到 12 月）。
* @param date 表示日期的数值，范围为 1 到 31。
* @param hours 如果提供了 minutes，则必须提供此参数。表示小时的数值，范围为 0 到 23（午夜到晚上 11 点）。
* @param minutes 如果提供了 seconds，则必须提供此参数。表示分钟的数值，范围为 0 到 59。
* @param seconds 如果提供了 milliseconds，则必须提供此参数。表示秒的数值，范围为 0 到 59。
* @param ms 表示毫秒的数值，范围为 0 到 999。
*/
UTC(year: number, monthIndex: number, date?: number, hours?: number, minutes?: number, seconds?: number, ms?: number): number;
/** 返回自 1970 年 1 月 1 日午夜（协调世界时 (UTC)）以来经过的毫秒数。 */
now(): number;
}
declare var Date: DateConstructor;
interface RegExpMatchArray extends Array<string> {
/**
* 搜索结果的索引。
*/
index?: number;
/**
* 搜索字符串的副本。
*/
input?: string;
/**
* 第一个匹配项。因为如果没有匹配项将返回 `null`，所以这将始终存在。
*/
0: string;
}
interface RegExpExecArray extends Array<string> {
/**
* 搜索结果的索引。
*/
index: number;
/**
* 搜索字符串的副本。
*/
input: string;
/**
* 第一个匹配项。因为如果没有匹配项将返回 `null`，所以这将始终存在。
*/
0: string;
}
interface RegExp {
/**
* 使用正则表达式模式在字符串上执行搜索，并返回包含该搜索结果的数组。
* @param string 要执行搜索的字符串对象或字符串字面量。
*/
exec(string: string): RegExpExecArray | null;
/**
* 返回一个布尔值，指示搜索的字符串中是否存在模式。
* @param string 要执行搜索的字符串。
*/
test(string: string): boolean;
/** 返回正则表达式模式的文本副本。只读。regExp 参数是一个正则表达式对象。它可以是变量名或字面量。 */
readonly source: string;
/** 返回一个布尔值，指示是否使用了正则表达式的全局标志 (g)。默认值为 false。只读。 */
readonly global: boolean;
/** 返回一个布尔值，指示是否使用了正则表达式的忽略大小写标志 (i)。默认值为 false。只读。 */
readonly ignoreCase: boolean;
/** 返回一个布尔值，指示是否使用了正则表达式的多行标志 (m)。默认值为 false。只读。 */
readonly multiline: boolean;
lastIndex: number;
// 非标准扩展
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
compile(pattern: string, flags?: string): this;
}
interface RegExpConstructor {
new(pattern: RegExp | string): RegExp;
new(pattern: string, flags?: string): RegExp;
(pattern: RegExp | string): RegExp;
(pattern: string, flags?: string): RegExp;
readonly "prototype": RegExp;
// 非标准扩展
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$1": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$2": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$3": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$4": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$5": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$6": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$7": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$8": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$9": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"input": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$_": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"lastMatch": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$&": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"lastParen": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$+": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"leftContext": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$`": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"rightContext": string;
/** @deprecated 一个用于浏览器兼容性的遗留功能 */
"$'": string;
}
declare var RegExp: RegExpConstructor;
interface Error {
name: string;
message: string;
stack?: string;
}
interface ErrorConstructor {
new(message?: string): Error;
(message?: string): Error;
readonly prototype: Error;
}
declare var Error: ErrorConstructor;
interface EvalError extends Error {
}
interface EvalErrorConstructor extends ErrorConstructor {
new(message?: string): EvalError;
(message?: string): EvalError;
readonly prototype: EvalError;
}
declare var EvalError: EvalErrorConstructor;
interface RangeError extends Error {
}
interface RangeErrorConstructor extends ErrorConstructor {
new(message?: string): RangeError;
(message?: string): RangeError;
readonly prototype: RangeError;
}
declare var RangeError: RangeErrorConstructor;
interface ReferenceError extends Error {
}
interface ReferenceErrorConstructor extends ErrorConstructor {
new(message?: string): ReferenceError;
(message?: string): ReferenceError;
readonly prototype: ReferenceError;
}
declare var ReferenceError: ReferenceErrorConstructor;
interface SyntaxError extends Error {
}
interface SyntaxErrorConstructor extends ErrorConstructor {
new(message?: string): SyntaxError;
(message?: string): SyntaxError;
readonly prototype: SyntaxError;
}
declare var SyntaxError: SyntaxErrorConstructor;
interface TypeError extends Error {
}
interface TypeErrorConstructor extends ErrorConstructor {
new(message?: string): TypeError;
(message?: string): TypeError;
readonly prototype: TypeError;
}
declare var TypeError: TypeErrorConstructor;
interface URIError extends Error {
}
interface URIErrorConstructor extends ErrorConstructor {
new(message?: string): URIError;
(message?: string): URIError;
readonly prototype: URIError;
}
declare var URIError: URIErrorConstructor;
interface JSON {
/**
* 将 JavaScript 对象表示法 (JSON) 字符串转换为对象。
* @param text 有效的 JSON 字符串。
* @param reviver 一个转换结果的函数。此函数为对象的每个成员调用。
* 如果一个成员包含嵌套对象，则在父对象之前转换嵌套对象。
*/
parse(text: string, reviver?: (this: any, key: string, value: any) => any): any;
/**
* 将 JavaScript 值转换为 JavaScript 对象表示法 (JSON) 字符串。
* @param value 要转换的 JavaScript 值，通常是对象或数组。
* @param replacer 一个转换结果的函数。
* @param space 添加缩进、空格和换行符，使返回的 JSON 文本更易读。
*/
stringify(value: any, replacer?: (this: any, key: string, value: any) => any, space?: string | number): string;
/**
* 将 JavaScript 值转换为 JavaScript 对象表示法 (JSON) 字符串。
* @param value 要转换的 JavaScript 值，通常是对象或数组。
* @param replacer 一个字符串和数字数组，作为选择要序列化的对象属性的批准列表。
* @param space 添加缩进、空格和换行符，使返回的 JSON 文本更易读。
*/
stringify(value: any, replacer?: (number | string)[] | null, space?: string | number): string;
}
/**
* 提供将 JavaScript 值与 JavaScript 对象表示法 (JSON) 格式相互转换的函数的内置对象。
*/
declare var JSON: JSON;
/////////////////////////////
/// ECMAScript 数组 API（由编译器特别处理）
/////////////////////////////
interface ReadonlyArray<T> {
/**
* 获取数组的长度。这个数字比数组中定义的最高元素大一。
*/
readonly length: number;
/**
* 返回数组的字符串表示形式。
*/
toString(): string;
/**
* 返回数组的字符串表示形式。元素使用它们的 toLocaleString 方法转换为字符串。
*/
toLocaleString(): string;
/**
* 合并两个或多个数组。
* @param items 要添加到数组末尾的其他项。
*/
concat(...items: ConcatArray<T>[]): T[];
/**
* 合并两个或多个数组。
* @param items 要添加到数组末尾的其他项。
*/
concat(...items: (T | ConcatArray<T>)[]): T[];
/**
* 将数组的所有元素添加到由指定分隔符分隔的字符串中。
* @param separator 用于分隔数组中每个元素的字符串。如果省略，数组元素用逗号分隔。
*/
join(separator?: string): string;
/**
* 返回数组的一部分。
* @param start 指定部分的开始。
* @param end 指定部分的结束。这不包括索引 'end' 处的元素。
*/
slice(start?: number, end?: number): T[];
/**
* 返回数组中第一次出现某个值的索引。
* @param searchElement 要在数组中定位的值。
* @param fromIndex 开始搜索的数组索引。如果省略，搜索从索引 0 开始。
*/
indexOf(searchElement: T, fromIndex?: number): number;
/**
* 返回数组中最后一次出现某个值的索引。
* @param searchElement 要在数组中定位的值。
* @param fromIndex 开始搜索的数组索引。如果省略，搜索从数组的最后一个索引开始。
*/
lastIndexOf(searchElement: T, fromIndex?: number): number;
/**
* 确定数组的所有成员是否满足指定的测试。
* @param predicate 一个接受最多三个参数的函数。every 方法为数组中的每个元素调用 predicate 函数，直到 predicate 返回一个可以转换为布尔值 false 的值，或者直到数组结束。
* @param thisArg 在 predicate 函数中可以引用的对象。如果省略，undefined 用作 this 值。
*/
every<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): this is readonly S[];
/**
* 确定数组的所有成员是否满足指定的测试。
* @param predicate 一个接受最多三个参数的函数。every 方法为数组中的每个元素调用 predicate 函数，直到 predicate 返回一个可以转换为布尔值 false 的值，或者直到数组结束。
* @param thisArg 在 predicate 函数中可以引用的对象。如果省略，undefined 用作 this 值。
*/
every(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
/**
* 确定指定的回调函数是否对数组的任何元素返回 true。
* @param predicate 一个接受最多三个参数的函数。some 方法为数组中的每个元素调用 predicate 函数，直到 predicate 返回一个可以转换为布尔值 true 的值，或者直到数组结束。
* @param thisArg 在 predicate 函数中可以引用的对象。如果省略，undefined 用作 this 值。
*/
some(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): boolean;
/**
* 对数组中的每个元素执行指定的操作。
* @param callbackfn 一个接受最多三个参数的函数。forEach 为数组中的每个元素调用一次 callbackfn 函数。
* @param thisArg 在 callbackfn 函数中可以引用的对象。如果省略，undefined 用作 this 值。
*/
forEach(callbackfn: (value: T, index: number, array: readonly T[]) => void, thisArg?: any): void;
/**
* 对数组的每个元素调用定义的回调函数，并返回包含结果的数组。
* @param callbackfn 一个接受最多三个参数的函数。map 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param thisArg 在 callbackfn 函数中可以引用的对象。如果省略，undefined 用作 this 值。
*/
map<U>(callbackfn: (value: T, index: number, array: readonly T[]) => U, thisArg?: any): U[];
/**
* 返回数组中满足回调函数指定条件的元素。
* @param predicate 一个接受最多三个参数的函数。filter 方法为数组中的每个元素调用一次 predicate 函数。
* @param thisArg 在 predicate 函数中可以引用的对象。如果省略，undefined 用作 this 值。
*/
filter<S extends T>(predicate: (value: T, index: number, array: readonly T[]) => value is S, thisArg?: any): S[];
/**
* 返回数组中满足回调函数指定条件的元素。
* @param predicate 一个接受最多三个参数的函数。filter 方法为数组中的每个元素调用一次 predicate 函数。
* @param thisArg 在 predicate 函数中可以引用的对象。如果省略，undefined 用作 this 值。
*/
filter(predicate: (value: T, index: number, array: readonly T[]) => unknown, thisArg?: any): T[];
/**
* 为数组中的所有元素调用指定的回调函数。回调函数的返回值是累积结果，并作为下次调用回调函数的参数提供。
* @param callbackfn 一个接受最多四个参数的函数。reduce 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param initialValue 如果指定了 initialValue，则将其用作累积的初始值。第一次调用 callbackfn 函数时，将此值作为参数提供，而不是数组值。
*/
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
/**
* 为数组中的所有元素调用指定的回调函数。回调函数的返回值是累积结果，并作为下次调用回调函数的参数提供。
* @param callbackfn 一个接受最多四个参数的函数。reduce 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param initialValue 如果指定了 initialValue，则将其用作累积的初始值。第一次调用 callbackfn 函数时，将此值作为参数提供，而不是数组值。
*/
reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
/**
* 为数组中的所有元素调用指定的回调函数，按降序排列。回调函数的返回值是累积结果，并作为下次调用回调函数的参数提供。
* @param callbackfn 一个接受最多四个参数的函数。reduceRight 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param initialValue 如果指定了 initialValue，则将其用作累积的初始值。第一次调用 callbackfn 函数时，将此值作为参数提供，而不是数组值。
*/
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T): T;
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: readonly T[]) => T, initialValue: T): T;
/**
* 为数组中的所有元素调用指定的回调函数，按降序排列。回调函数的返回值是累积结果，并作为下次调用回调函数的参数提供。
* @param callbackfn 一个接受最多四个参数的函数。reduceRight 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param initialValue 如果指定了 initialValue，则将其用作累积的初始值。第一次调用 callbackfn 函数时，将此值作为参数提供，而不是数组值。
*/
reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: readonly T[]) => U, initialValue: U): U;
readonly [n: number]: T;
}
interface ConcatArray<T> {
readonly length: number;
readonly [n: number]: T;
join(separator?: string): string;
slice(start?: number, end?: number): T[];
}
interface Array<T> {
/**
* 获取或设置数组的长度。这个数字比数组中最高索引大一。
*/
length: number;
/**
* 返回数组的字符串表示形式。
*/
toString(): string;
/**
* 返回数组的字符串表示形式。元素使用它们的 toLocaleString 方法转换为字符串。
*/
toLocaleString(): string;
/**
* 删除数组的最后一个元素并返回它。
* 如果数组为空，则返回 undefined，并且数组不被修改。
*/
pop(): T | undefined;
/**
* 将新元素追加到数组的末尾，并返回数组的新长度。
* @param items 要添加到数组的新元素。
*/
push(...items: T[]): number;
/**
* 合并两个或多个数组。
* 此方法返回一个新数组，而不修改任何现有数组。
* @param items 要添加到数组末尾的其他数组和/或项。
*/
concat(...items: ConcatArray<T>[]): T[];
/**
* 合并两个或多个数组。
* 此方法返回一个新数组，而不修改任何现有数组。
* @param items 要添加到数组末尾的其他数组和/或项。
*/
concat(...items: (T | ConcatArray<T>)[]): T[];
/**
* 将数组的所有元素添加到由指定分隔符分隔的字符串中。
* @param separator 用于分隔数组中每个元素的字符串。如果省略，数组元素用逗号分隔。
*/
join(separator?: string): string;
/**
* 就地反转数组中的元素。
* 此方法会改变数组，并返回对同一数组的引用。
*/
reverse(): T[];
/**
* 删除数组的第一个元素并返回它。
* 如果数组为空，则返回 undefined，并且数组不被修改。
*/
shift(): T | undefined;
/**
* 返回数组的一部分的副本。
* 对于 start 和 end，负索引可用于指示从数组末尾的偏移量。
* 例如，-2 表示数组的倒数第二个元素。
* @param start 指定部分的开始索引。
* 如果 start 未定义，则从索引 0 开始。
* @param end 指定部分的结束索引。这不包括索引 'end' 处的元素。
* 如果 end 未定义，则切片扩展到数组的末尾。
*/
slice(start?: number, end?: number): T[];
/**
* 就地对数组进行排序。
* 此方法会改变数组，并返回对同一数组的引用。
* @param compareFn 用于确定元素顺序的函数。预期返回一个负值，如果第一个参数小于第二个参数，则返回零，如果它们相等，则返回正值，否则返回正值。如果省略，元素按升序排序，ASCII 字符顺序。
* ```ts
* [11,2,22,1].sort((a, b) => a - b)
* ```
*/
sort(compareFn?: (a: T, b: T) => number): this;
/**
* 删除数组中的元素，并在必要时插入新元素，返回被删除的元素。
* @param start 要开始删除元素的数组中的零基位置。
* @param deleteCount 要删除的元素数量。
* @returns 包含被删除元素的数组。
*/
splice(start: number, deleteCount?: number): T[];
/**
* 删除数组中的元素，并在必要时插入新元素，返回被删除的元素。
* @param start 要开始删除元素的数组中的零基位置。
* @param deleteCount 要删除的元素数量。
* @param items 要插入到数组中的元素，以替换被删除的元素。
* @returns 包含被删除元素的数组。
*/
splice(start: number, deleteCount: number, ...items: T[]): T[];
/**
* 在数组的开头插入新元素，并返回数组的新长度。
* @param items 要插入到数组开头的元素。
*/
unshift(...items: T[]): number;
/**
* 返回数组中第一次出现某个值的索引，或 -1（如果不存在）。
* @param searchElement 要在数组中定位的值。
* @param fromIndex 开始搜索的数组索引。如果省略，搜索从索引 0 开始。
*/
indexOf(searchElement: T, fromIndex?: number): number;
/**
* 返回数组中最后一次出现某个值的索引，或 -1（如果不存在）。
* @param searchElement 要在数组中定位的值。
* @param fromIndex 开始向后搜索的数组索引。如果省略，搜索从数组的最后一个索引开始。
*/
lastIndexOf(searchElement: T, fromIndex?: number): number;
/**
* 确定数组的所有成员是否满足指定的测试。
* @param predicate 一个接受最多三个参数的函数。every 方法为数组中的每个元素调用 predicate 函数，直到 predicate 返回一个可以转换为布尔值 false 的值，或者直到数组结束。
* @param thisArg 在 predicate 函数中可以引用的对象。如果省略，undefined 用作 this 值。
*/
every<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): this is S[];
/**
* 确定数组的所有成员是否满足指定的测试。
* @param predicate 一个接受最多三个参数的函数。every 方法为数组中的每个元素调用 predicate 函数，直到 predicate 返回一个可以转换为布尔值 false 的值，或者直到数组结束。
* @param thisArg 一个对象，可以在 predicate 函数中引用 this 关键字。如果省略此参数，则使用 undefined 作为 this 值。
*/
every(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
/**
* 确定指定的回调函数是否对数组中的任何元素返回 true。
* @param predicate 一个接受最多三个参数的函数。some 方法为数组中的每个元素调用 predicate 函数，直到 predicate 返回一个可以转换为布尔值 true 的值，或者直到数组结束。
* @param thisArg 一个对象，可以在 predicate 函数中引用 this 关键字。如果省略此参数，则使用 undefined 作为 this 值。
*/
some(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): boolean;
/**
* 对数组中的每个元素执行指定的操作。
* @param callbackfn 一个接受最多三个参数的函数。forEach 为数组中的每个元素调用一次 callbackfn 函数。
* @param thisArg 一个对象，可以在 callbackfn 函数中引用 this 关键字。如果省略此参数，则使用 undefined 作为 this 值。
*/
forEach(callbackfn: (value: T, index: number, array: T[]) => void, thisArg?: any): void;
/**
* 对数组的每个元素调用定义的回调函数，并返回包含结果的数组。
* @param callbackfn 一个接受最多三个参数的函数。map 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param thisArg 一个对象，可以在 callbackfn 函数中引用 this 关键字。如果省略此参数，则使用 undefined 作为 this 值。
*/
map<U>(callbackfn: (value: T, index: number, array: T[]) => U, thisArg?: any): U[];
/**
* 返回数组中满足回调函数指定条件的元素。
* @param predicate 一个接受最多三个参数的函数。filter 方法为数组中的每个元素调用一次 predicate 函数。
* @param thisArg 一个对象，可以在 predicate 函数中引用 this 关键字。如果省略此参数，则使用 undefined 作为 this 值。
*/
filter<S extends T>(predicate: (value: T, index: number, array: T[]) => value is S, thisArg?: any): S[];
/**
* 返回数组中满足回调函数指定条件的元素。
* @param predicate 一个接受最多三个参数的函数。filter 方法为数组中的每个元素调用一次 predicate 函数。
* @param thisArg 一个对象，可以在 predicate 函数中引用 this 关键字。如果省略此参数，则使用 undefined 作为 this 值。
*/
filter(predicate: (value: T, index: number, array: T[]) => unknown, thisArg?: any): T[];
/**
* 为数组中的所有元素调用指定的回调函数。回调函数的返回值是累积结果，并作为下次调用回调函数的参数提供。
* @param callbackfn 一个接受最多四个参数的函数。reduce 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param initialValue 如果指定了 initialValue，则将其用作累积的初始值。第一次调用 callbackfn 函数时，将此值作为参数提供，而不是数组值。
*/
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
reduce(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
/**
* 为数组中的所有元素调用指定的回调函数。回调函数的返回值是累积结果，并作为下次调用回调函数的参数提供。
* @param callbackfn 一个接受最多四个参数的函数。reduce 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param initialValue 如果指定了 initialValue，则将其用作累积的初始值。第一次调用 callbackfn 函数时，将此值作为参数提供，而不是数组值。
*/
reduce<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
/**
* 为数组中的所有元素调用指定的回调函数，按降序排列。回调函数的返回值是累积结果，并作为下次调用回调函数的参数提供。
* @param callbackfn 一个接受最多四个参数的函数。reduceRight 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param initialValue 如果指定了 initialValue，则将其用作累积的初始值。第一次调用 callbackfn 函数时，将此值作为参数提供，而不是数组值。
*/
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T): T;
reduceRight(callbackfn: (previousValue: T, currentValue: T, currentIndex: number, array: T[]) => T, initialValue: T): T;
/**
* 为数组中的所有元素调用指定的回调函数，按降序排列。回调函数的返回值是累积结果，并作为下次调用回调函数的参数提供。
* @param callbackfn 一个接受最多四个参数的函数。reduceRight 方法为数组中的每个元素调用一次 callbackfn 函数。
* @param initialValue 如果指定了 initialValue，则将其用作累积的初始值。第一次调用 callbackfn 函数时，将此值作为参数提供，而不是数组值。
*/
reduceRight<U>(callbackfn: (previousValue: U, currentValue: T, currentIndex: number, array: T[]) => U, initialValue: U): U;
[n: number]: T;
}
interface ArrayConstructor {
new(arrayLength?: number): any[];
new <T>(arrayLength: number): T[];
new <T>(...items: T[]): T[];
(arrayLength?: number): any[];
<T>(arrayLength: number): T[];
<T>(...items: T[]): T[];
isArray(arg: any): arg is any[];
readonly prototype: any[];
}
declare var Array: ArrayConstructor;
interface TypedPropertyDescriptor<T> {
enumerable?: boolean;
configurable?: boolean;
writable?: boolean;
value?: T;
get?: () => T;
set?: (value: T) => void;
}
declare type PromiseConstructorLike = new <T>(executor: (resolve: (value: T | PromiseLike<T>) => void, reject: (reason?: any) => void) => void) => PromiseLike<T>;
interface PromiseLike<T> {
/**
* 为 Promise 的解决或拒绝附加回调函数。
* @param onfulfilled 当 Promise 解决时要执行的回调函数。
* @param onrejected 当 Promise 被拒绝时要执行的回调函数。
* @returns 一个 Promise，用于完成执行的回调函数。
*/
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): PromiseLike<TResult1 | TResult2>;
}
/**
* 表示异步操作的完成
*/
interface Promise<T> {
/**
* 为 Promise 的解决或拒绝附加回调函数。
* @param onfulfilled 当 Promise 解决时要执行的回调函数。
* @param onrejected 当 Promise 被拒绝时要执行的回调函数。
* @returns 一个 Promise，用于完成执行的回调函数。
*/
then<TResult1 = T, TResult2 = never>(onfulfilled?: ((value: T) => TResult1 | PromiseLike<TResult1>) | undefined | null, onrejected?: ((reason: any) => TResult2 | PromiseLike<TResult2>) | undefined | null): Promise<TResult1 | TResult2>;
/**
* 仅为 Promise 的拒绝附加回调函数。
* @param onrejected 当 Promise 被拒绝时要执行的回调函数。
* @returns 一个 Promise，用于完成回调函数。
*/
catch<TResult = never>(onrejected?: ((reason: any) => TResult | PromiseLike<TResult>) | undefined | null): Promise<T | TResult>;
}
扫一扫
763
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
