TypeScript provides two equivalent ways to define an array type:T[] andArray<T>.The two styles are functionally equivalent.Using the same style consistently across your codebase makes it easier for developers to read and understand array types.

exportdefault tseslint.config({
rules:{
"@typescript-eslint/array-type":"error"
}
});

module.exports={
"rules":{
"@typescript-eslint/array-type":"error"
}
};

Options​

This rule accepts the following options:

typeArrayOption='array'|'array-simple'|'generic';

typeOptions=[
{
/** The array type expected for mutable cases. */
default?: ArrayOption;
/** The array type expected for readonly cases. If omitted, the value for `default` will be used. */
readonly?: ArrayOption;
},
];

const defaultOptions: Options=[{default:'array'}];

The default config will enforce that all mutable and readonly arrays use the'array' syntax.

"array"​

Always useT[] orreadonly T[] for all array types.

const x:Array<string>=['a','b'];
const y: ReadonlyArray<string>=['a','b'];

const x:string[]=['a','b'];
const y:readonlystring[]=['a','b'];

"generic"​

Always useArray<T>,ReadonlyArray<T>, orReadonly<Array<T>> for all array types.readonly T[] will be modified toReadonlyArray<T> andReadonly<T[]> will be modified toReadonly<Array<T>>.

const x:string[]=['a','b'];
const y:readonlystring[]=['a','b'];
const z: Readonly<string[]>=['a','b'];

const x:Array<string>=['a','b'];
const y: ReadonlyArray<string>=['a','b'];
const z: Readonly<Array<string>>=['a','b'];

"array-simple"​

UseT[] orreadonly T[] for simple types (i.e. types which are just primitive names or type references).UseArray<T> orReadonlyArray<T> for all other types (union types, intersection types, object types, function types, etc).

const a:(string|number)[]=['a','b'];
const b:{ prop:string}[]=[{ prop:'a'}];
const c:(()=>void)[]=[()=>{}];
const d:Array<MyType>=['a','b'];
const e:Array<string>=['a','b'];
const f: ReadonlyArray<string>=['a','b'];

const a:Array<string|number>=['a','b'];
const b:Array<{ prop:string}>=[{ prop:'a'}];
const c:Array<()=>void>=[()=>{}];
const d: MyType[]=['a','b'];
const e:string[]=['a','b'];
const f:readonlystring[]=['a','b'];

Combination Matrix​

This matrix lists all possible option combinations and their expected results for different types of Arrays.

When Not To Use It​

This rule is purely a stylistic rule for maintaining consistency in your project.You can turn it off if you don't want to keep a consistent style for array types.

However, keep in mind that inconsistent style can harm readability in a project.We recommend picking a single option for this rule that works best for your project.

Resources​

• Rule source
• Test source