W3cubDocs

/Angular

FormArray

class final

Tracks the value and validity state of an array of FormControl, FormGroup or FormArray instances.

See more...

class FormArray<TControl extends AbstractControl<any> = any> extends AbstractControl<ɵTypedOrUntyped<TControl, ɵFormArrayValue<TControl>, any>, ɵTypedOrUntyped<TControl, ɵFormArrayRawValue<TControl>, any>> {
  constructor(controls: TControl[], validatorOrOpts?: ValidatorFn | AbstractControlOptions | ValidatorFn[], asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[])
  controls: ɵTypedOrUntyped<TControl, Array<TControl>, Array<AbstractControl<any>>>
  length: number
  at(index: number): ɵTypedOrUntyped<TControl, TControl, AbstractControl<any>>
  push(control: TControl, options: { emitEvent?: boolean; } = {}): void
  insert(index: number, control: TControl, options: { emitEvent?: boolean; } = {}): void
  removeAt(index: number, options: { emitEvent?: boolean; } = {}): void
  setControl(index: number, control: TControl, options: { emitEvent?: boolean; } = {}): void
  setValue(value: ɵIsAny<TControl, any[], ɵRawValue<TControl>[]>, options: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void
  patchValue(value: ɵIsAny<TControl, any[], ɵValue<TControl>[]>, options: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void
  reset(value: ɵIsAny<TControl, any, ɵIsAny<TControl, any[], ɵValue<TControl>[]>> = [], options: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void
  getRawValue(): ɵFormArrayRawValue<TControl>
  clear(options: { emitEvent?: boolean; } = {}): void

  // inherited from forms/AbstractControl
  constructor(validators: ValidatorFn | ValidatorFn[], asyncValidators: AsyncValidatorFn | AsyncValidatorFn[])
  value: TValue
  validator: ValidatorFn | null
  asyncValidator: AsyncValidatorFn | null
  parent: FormGroup | FormArray | null
  status: FormControlStatus
  valid: boolean
  invalid: boolean
  pending: boolean
  disabled: boolean
  enabled: boolean
  errors: ValidationErrors | null
  pristine: boolean
  dirty: boolean
  touched: boolean
  untouched: boolean
  valueChanges: Observable<TValue>
  statusChanges: Observable<FormControlStatus>
  updateOn: FormHooks
  root: AbstractControl
  setValidators(validators: ValidatorFn | ValidatorFn[]): void
  setAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void
  addValidators(validators: ValidatorFn | ValidatorFn[]): void
  addAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void
  removeValidators(validators: ValidatorFn | ValidatorFn[]): void
  removeAsyncValidators(validators: AsyncValidatorFn | AsyncValidatorFn[]): void
  hasValidator(validator: ValidatorFn): boolean
  hasAsyncValidator(validator: AsyncValidatorFn): boolean
  clearValidators(): void
  clearAsyncValidators(): void
  markAsTouched(opts: { onlySelf?: boolean; } = {}): void
  markAllAsTouched(): void
  markAsUntouched(opts: { onlySelf?: boolean; } = {}): void
  markAsDirty(opts: { onlySelf?: boolean; } = {}): void
  markAsPristine(opts: { onlySelf?: boolean; } = {}): void
  markAsPending(opts: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void
  disable(opts: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void
  enable(opts: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void
  setParent(parent: FormGroup<any> | FormArray<any>): void
  abstract setValue(value: TRawValue, options?: Object): void
  abstract patchValue(value: TValue, options?: Object): void
  abstract reset(value?: TValue, options?: Object): void
  getRawValue(): any
  updateValueAndValidity(opts: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void
  setErrors(errors: ValidationErrors, opts: { emitEvent?: boolean; } = {}): void
  get<P extends string | ((string | number)[])>(path: P): AbstractControl<ɵGetProperty<TRawValue, P>> | null
  getError(errorCode: string, path?: string | (string | number)[]): any
  hasError(errorCode: string, path?: string | (string | number)[]): boolean
}

Description

A FormArray aggregates the values of each child FormControl into an array. It calculates its status by reducing the status values of its children. For example, if one of the controls in a FormArray is invalid, the entire array becomes invalid.

FormArray accepts one generic argument, which is the type of the controls inside. If you need a heterogenous array, use UntypedFormArray.

FormArray is one of the four fundamental building blocks used to define forms in Angular, along with FormControl, FormGroup, and FormRecord.

Further information is available in the Usage Notes...

Constructor

Creates a new FormArray instance.

This class is "final" and should not be extended. See the public API notes.

constructor(controls: TControl[], validatorOrOpts?: ValidatorFn | AbstractControlOptions | ValidatorFn[], asyncValidator?: AsyncValidatorFn | AsyncValidatorFn[])

Parameters
controls TControl[]

An array of child controls. Each child control is given an index where it is registered.

validatorOrOpts ValidatorFn | AbstractControlOptions | ValidatorFn[]

A synchronous validator function, or an array of such functions, or an AbstractControlOptions object that contains validation functions and a validation trigger.

Optional. Default is undefined.

asyncValidator AsyncValidatorFn | AsyncValidatorFn[]

A single async validator or array of async validator functions

Optional. Default is undefined.

Properties

Property Description
controls: ɵTypedOrUntyped<TControl, Array<TControl>, Array<AbstractControl<any>>>
length: number Read-Only

Length of the control array.

Methods

Get the AbstractControl at the given index in the array.

at(index: number): ɵTypedOrUntyped<TControl, TControl, AbstractControl<any>>

Parameters
index number

Index in the array to retrieve the control. If index is negative, it will wrap around from the back, and if index is greatly negative (less than -length), the result is undefined. This behavior is the same as Array.at(index).

Returns

ɵTypedOrUntyped<TControl, TControl, AbstractControl<any>>

Insert a new AbstractControl at the end of the array.

push(control: TControl, options: { emitEvent?: boolean; } = {}): void

Parameters
control TControl

Form control to be inserted

options object

Specifies whether this FormArray instance should emit events after a new control is added.

  • emitEvent: When true or not supplied (the default), both the statusChanges and valueChanges observables emit events with the latest status and value when the control is inserted. When false, no events are emitted.

Optional. Default is {}.

Returns

void

Insert a new AbstractControl at the given index in the array.

insert(index: number, control: TControl, options: { emitEvent?: boolean; } = {}): void

Parameters
index number

Index in the array to insert the control. If index is negative, wraps around from the back. If index is greatly negative (less than -length), prepends to the array. This behavior is the same as Array.splice(index, 0, control).

control TControl

Form control to be inserted

options object

Specifies whether this FormArray instance should emit events after a new control is inserted.

  • emitEvent: When true or not supplied (the default), both the statusChanges and valueChanges observables emit events with the latest status and value when the control is inserted. When false, no events are emitted.

Optional. Default is {}.

Returns

void

Remove the control at the given index in the array.

removeAt(index: number, options: { emitEvent?: boolean; } = {}): void

Parameters
index number

Index in the array to remove the control. If index is negative, wraps around from the back. If index is greatly negative (less than -length), removes the first element. This behavior is the same as Array.splice(index, 1).

options object

Specifies whether this FormArray instance should emit events after a control is removed.

  • emitEvent: When true or not supplied (the default), both the statusChanges and valueChanges observables emit events with the latest status and value when the control is removed. When false, no events are emitted.

Optional. Default is {}.

Returns

void

Replace an existing control.

setControl(index: number, control: TControl, options: { emitEvent?: boolean; } = {}): void

Parameters
index number

Index in the array to replace the control. If index is negative, wraps around from the back. If index is greatly negative (less than -length), replaces the first element. This behavior is the same as Array.splice(index, 1, control).

control TControl

The AbstractControl control to replace the existing control

options object

Specifies whether this FormArray instance should emit events after an existing control is replaced with a new one.

  • emitEvent: When true or not supplied (the default), both the statusChanges and valueChanges observables emit events with the latest status and value when the control is replaced with a new one. When false, no events are emitted.

Optional. Default is {}.

Returns

void

Sets the value of the FormArray. It accepts an array that matches the structure of the control.

setValue(value: ɵIsAny<TControl, any[], ɵRawValue<TControl>[]>, options: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void

Parameters
value ɵIsAny<TControl, any[], ɵRawValue<TControl>[]>

Array of values for the controls

options object

Configure options that determine how the control propagates changes and emits events after the value changes

  • onlySelf: When true, each change only affects this control, and not its parent. Default is false.
  • emitEvent: When true or not supplied (the default), both the statusChanges and valueChanges observables emit events with the latest status and value when the control value is updated. When false, no events are emitted. The configuration options are passed to the AbstractControl#updateValueAndValidity method.

Optional. Default is {}.

Returns

void

This method performs strict checks, and throws an error if you try to set the value of a control that doesn't exist or if you exclude the value of a control.

Usage Notes

Set the values for the controls in the form array
const arr = new FormArray([
  new FormControl(),
  new FormControl()
]);
console.log(arr.value);   // [null, null]

arr.setValue(['Nancy', 'Drew']);
console.log(arr.value);   // ['Nancy', 'Drew']

Patches the value of the FormArray. It accepts an array that matches the structure of the control, and does its best to match the values to the correct controls in the group.

patchValue(value: ɵIsAny<TControl, any[], ɵValue<TControl>[]>, options: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void

Parameters
value ɵIsAny<TControl, any[], ɵValue<TControl>[]>

Array of latest values for the controls

options object

Configure options that determine how the control propagates changes and emits events after the value changes

  • onlySelf: When true, each change only affects this control, and not its parent. Default is false.
  • emitEvent: When true or not supplied (the default), both the statusChanges and valueChanges observables emit events with the latest status and value when the control value is updated. When false, no events are emitted. The configuration options are passed to the AbstractControl#updateValueAndValidity method.

Optional. Default is {}.

Returns

void

It accepts both super-sets and sub-sets of the array without throwing an error.

Usage Notes

Patch the values for controls in a form array
const arr = new FormArray([
   new FormControl(),
   new FormControl()
]);
console.log(arr.value);   // [null, null]

arr.patchValue(['Nancy']);
console.log(arr.value);   // ['Nancy', null]

Resets the FormArray and all descendants are marked pristine and untouched, and the value of all descendants to null or null maps.

reset(value: ɵIsAny<TControl, any, ɵIsAny<TControl, any[], ɵValue<TControl>[]>> = [], options: { onlySelf?: boolean; emitEvent?: boolean; } = {}): void

Parameters
value ɵIsAny<TControl, any, ɵIsAny<TControl, any[], ɵValue<TControl>[]>>

Array of values for the controls

Optional. Default is [].

options object

Configure options that determine how the control propagates changes and emits events after the value changes

  • onlySelf: When true, each change only affects this control, and not its parent. Default is false.
  • emitEvent: When true or not supplied (the default), both the statusChanges and valueChanges observables emit events with the latest status and value when the control is reset. When false, no events are emitted. The configuration options are passed to the AbstractControl#updateValueAndValidity method.

Optional. Default is {}.

Returns

void

You reset to a specific form state by passing in an array of states that matches the structure of the control. The state is a standalone value or a form state object with both a value and a disabled status.

Usage Notes

Reset the values in a form array
const arr = new FormArray([
   new FormControl(),
   new FormControl()
]);
arr.reset(['name', 'last name']);

console.log(arr.value);  // ['name', 'last name']
Reset the values in a form array and the disabled status for the first control
arr.reset([
  {value: 'name', disabled: true},
  'last'
]);

console.log(arr.value);  // ['last']
console.log(arr.at(0).status);  // 'DISABLED'

The aggregate value of the array, including any disabled controls.

getRawValue(): ɵFormArrayRawValue<TControl>

Parameters

There are no parameters.

Returns

ɵFormArrayRawValue<TControl>

Reports all values regardless of disabled status.

Remove all controls in the FormArray.

clear(options: { emitEvent?: boolean; } = {}): void

Parameters
options object

Specifies whether this FormArray instance should emit events after all controls are removed.

  • emitEvent: When true or not supplied (the default), both the statusChanges and valueChanges observables emit events with the latest status and value when all controls in this FormArray instance are removed. When false, no events are emitted.

Optional. Default is {}.

Returns

void

Usage Notes

Remove all elements from a FormArray
const arr = new FormArray([
   new FormControl(),
   new FormControl()
]);
console.log(arr.length);  // 2

arr.clear();
console.log(arr.length);  // 0

It's a simpler and more efficient alternative to removing all elements one by one:

const arr = new FormArray([
   new FormControl(),
   new FormControl()
]);

while (arr.length) {
   arr.removeAt(0);
}

Usage notes

Create an array of form controls

const arr = new FormArray([
  new FormControl('Nancy', Validators.minLength(2)),
  new FormControl('Drew'),
]);

console.log(arr.value);   // ['Nancy', 'Drew']
console.log(arr.status);  // 'VALID'

Create a form array with array-level validators

You include array-level validators and async validators. These come in handy when you want to perform validation that considers the value of more than one child control.

The two types of validators are passed in separately as the second and third arg respectively, or together as part of an options object.

const arr = new FormArray([
  new FormControl('Nancy'),
  new FormControl('Drew')
], {validators: myValidator, asyncValidators: myAsyncValidator});

Set the updateOn property for all controls in a form array

The options object is used to set a default value for each child control's updateOn property. If you set updateOn to 'blur' at the array level, all child controls default to 'blur', unless the child has explicitly specified a different updateOn value.

const arr = new FormArray([
   new FormControl()
], {updateOn: 'blur'});

Adding or removing controls from a form array

To change the controls in the array, use the push, insert, removeAt or clear methods in FormArray itself. These methods ensure the controls are properly tracked in the form's hierarchy. Do not modify the array of AbstractControls used to instantiate the FormArray directly, as that result in strange and unexpected behavior such as broken change detection.

© 2010–2023 Google, Inc.
Licensed under the Creative Commons Attribution License 4.0.
https://angular.io/api/forms/FormArray