类 default<T>

constructor

• new default<T>(innerType: ConstructorType<T>): default<T>

  初始化 List 类的新实例

  类型参数

  • T

  参数

  • innerType: ConstructorType<T>

    元素类型构造函数

  返回 default<T>

• new default<T>(
      innerType: ConstructorType<T>,
      list: default<T> | NativeType<T>[],
  ): default<T>

  初始化 List 类的新实例

  类型参数

  • T

  参数

  • innerType: ConstructorType<T>

    元素类型构造函数

  • list: default<T> | NativeType<T>[]

    要复制的元素列表

  返回 default<T>

• new default<T>(innerType: ConstructorType<T>, count: number): default<T>

  初始化 List 类的新实例

  类型参数

  • T

  参数

  • innerType: ConstructorType<T>

    元素类型构造函数

  • count: number

    初始容量

  返回 default<T>

[iterator]

[isConcatSpreadable]

• get "[isConcatSpreadable]"(): boolean

  返回 boolean

[toStringTag]

• get "[toStringTag]"(): string

  返回 string

length

• get length(): number

  获取包含的元素数

  返回 number

add

• add(item: NativeType<T> | null): void

  添加一个元素

  参数

  • item: NativeType<T> | null

    要添加的元素

  返回 void

addRange

• addRange(list: default<T> | NativeType<T>[]): void

  添加一组元素

  参数

  • list: default<T> | NativeType<T>[]

    要添加的元素列表

  返回 void

• addRange(...items: NativeType<T>[]): void

  添加一组元素

  参数

  • ...items: NativeType<T>[]

    要添加的元素列表

  返回 void

asReadOnly

• asReadOnly(): ReadOnlyList<T>

  返回一个只读的 List

  返回 ReadOnlyList<T>

  只读的 List

clear

• clear(): void

  清空所有元素

  返回 void

clone

• clone(): default<T>

  复制一个 List

  返回 default<T>

  复制的 List

concat

• concat(list: default<T> | NativeType<T>[]): default<T>

  合并两个 List

  参数

  • list: default<T> | NativeType<T>[]

    要合并的 List

  返回 default<T>

  合并后的 List

contains

• contains(item: NativeType<T>): boolean

  判断是否包含某个元素

  参数

  • item: NativeType<T>

    要判断的元素

  返回 boolean

  是否包含

convertAll

• convertAll<U>(
      targetType: ConstructorType<U>,
      converter: (item: NativeType<T>) => U,
  ): default<U>

  将当前 List 的元素转换为另一种类型，并返回包含转换后元素的 List

  类型参数

  • U

  参数

  • targetType: ConstructorType<U>

    目标类型构造函数

  • converter: (item: NativeType<T>) => U

    转换函数

  返回 default<U>

  转换后的 List

copyTo

• copyTo(array: NativeType<T>[], arrayIndex?: number, count?: number): void

  复制到一个数组

  参数

  • array: NativeType<T>[]

    目标数组

  • 可选arrayIndex: number

    数组起始位置

  • 可选count: number

    复制数量

  返回 void

exists

• exists(predicate: (item: NativeType<T>) => boolean): boolean

  确定 List 中是否包含与指定谓词定义的条件匹配的元素

  参数

  • predicate: (item: NativeType<T>) => boolean

    判断函数

  返回 boolean

  是否包含

find

• find(predicate: (item: NativeType<T>) => boolean): NativeType<T> | undefined

  搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的第一个匹配元素

  参数

  • predicate: (item: NativeType<T>) => boolean

    判断函数

  返回 NativeType<T> | undefined

  符合条件的元素

findAll

• findAll(predicate: (item: NativeType<T>) => boolean): default<T>

  检索与指定谓词定义的条件匹配的所有元素

  参数

  • predicate: (item: NativeType<T>) => boolean

    判断函数

  返回 default<T>

  包含所有匹配元素的 List

findIndex

• findIndex(predicate: (item: NativeType<T>) => boolean): number

  搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的第一个匹配元素的从零开始的索引

  参数

  • predicate: (item: NativeType<T>) => boolean

    判断函数

  返回 number

  符合条件的元素索引

findLast

• findLast(predicate: (item: NativeType<T>) => boolean): NativeType<T> | undefined

  搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的最后一个匹配元素

  参数

  • predicate: (item: NativeType<T>) => boolean

    判断函数

  返回 NativeType<T> | undefined

  符合条件的元素

findLastIndex

• findLastIndex(predicate: (item: NativeType<T>) => boolean): number

  搜索与指定谓词所定义的条件相匹配的元素，并返回整个 List 中的最后一个匹配元素的从零开始的索引

  参数

  • predicate: (item: NativeType<T>) => boolean

    判断函数

  返回 number

  符合条件的元素索引

forEach

• forEach(
      callback: (item: NativeType<T>, index: number, list: default<T>) => void,
  ): void

  对 List 中每个元素执行指定操作

  参数

  • callback: (item: NativeType<T>, index: number, list: default<T>) => void

    操作函数

  返回 void

getInnerType

• getInnerType(): ConstructorType<T>

  获取内部元素类型

  返回 ConstructorType<T>

  元素类型

indexOf

• indexOf(item: NativeType<T>): number

  搜索指定的对象，并返回整个 List 中第一个匹配项的从零开始的索引

  参数

  • item: NativeType<T>

    要搜索的元素

  返回 number

  元素索引

insert

• insert(index: number, item: NativeType<T> | null): void

  将元素插入 List 的指定索引处

  参数

  • index: number

    索引

  • item: NativeType<T> | null

    要插入的元素

  返回 void

insertRange

• insertRange(index: number, list: default<T> | NativeType<T>[]): void

  将集合的元素插入 List 的指定索引处

  参数

  • index: number

    索引

  • list: default<T> | NativeType<T>[]

    要插入的元素列表

  返回 void

• insertRange(index: number, ...items: NativeType<T>[]): void

  将集合的元素插入 List 的指定索引处

  参数

  • index: number

    索引

  • ...items: NativeType<T>[]

    要插入的元素列表

  返回 void

join

• join(separator?: string): string

  串联 List 的成员，其中在每个成员之间使用指定的分隔符

  参数

  • 可选separator: string

    分隔符

  返回 string

  拼接后的字符串

lastIndexOf

• lastIndexOf(item: NativeType<T>): number

  搜索指定的对象，并返回整个 List 中最后一个匹配项的从零开始的索引

  参数

  • item: NativeType<T>

    要搜索的元素

  返回 number

  元素索引

remove

• remove(item: NativeType<T>): boolean

  从 List 中移除特定对象的第一个匹配项

  参数

  • item: NativeType<T>

    要移除的元素

  返回 boolean

  是否成功移除

removeAll

• removeAll(predicate: (item: NativeType<T>) => boolean): number

  删除与指定谓词所定义的条件匹配的所有元素

  参数

  • predicate: (item: NativeType<T>) => boolean

    判断函数

  返回 number

  删除数量

removeAt

• removeAt(index: number): void

  移除 List 中指定索引处的元素

  参数

  • index: number

    索引

  返回 void

removeRange

• removeRange(index: number, count: number): void

  移除 List 中指定索引处的元素

  参数

  • index: number

    索引

  • count: number

    移除数量

  返回 void

reverse

• reverse(): void

  反转整个 List 中元素的顺序

  返回 void

• reverse(index: number, count: number): void

  反转整个 List 中元素的顺序

  参数

  • index: number

    起始索引

  • count: number

    反转数量

  返回 void

slice

• slice(start: number, length: number): default<T>

  在源 List 中创建元素范围的浅表副本

  参数

  • start: number

    起始索引

  • length: number

    复制数量

  返回 default<T>

  新 List

sort

• sort(): void

  使用默认比较器对整个 List 中的元素进行排序

  返回 void

• sort(compareFn: (a: NativeType<T>, b: NativeType<T>) => number): void

  使用指定的比较器对整个 List 中的元素进行排序

  参数

  • compareFn: (a: NativeType<T>, b: NativeType<T>) => number

    比较函数

  返回 void

toArray

• toArray(): NativeType<T>[]

  将整个 List 中的元素复制到新数组中

  返回 NativeType<T>[]

  新数组

toString

• toString(): string

  返回 List 的字符串表示形式

  返回 string

  字符串

trueForAll

• trueForAll(predicate: (item: NativeType<T>) => boolean): boolean

  判断是否所有元素都符合条件

  参数

  • predicate: (item: NativeType<T>) => boolean

    判断函数

  返回 boolean

  是否所有元素都符合条件

静态T

• T<T>(innerType: ConstructorType<T>): typeof default

  获取指定元素类型的 List 类型

  类型参数

  • T

  参数

  • innerType: ConstructorType<T>

    元素类型构造函数

  返回 typeof default