Array<Type> VS Type[] en Typescript

Hasta donde sé, el tipo de una propiedad puede definirse de dos maneras cuando es un arreglo:

property_name: type

donde el tipo puede ser cualquiera

Array<string>
Array<MyType>
// etc. (e.g. let prop1: Array<string>)

y

string[]
MyType[]
// etc. (e.g. let prop1: string[])

¿Cuál es la diferencia entre los dos casos? ¿O estoy entendiendo algo mal (quizás algo sobre <> usado en el casting)?

Respuesta #1

No hay ninguna diferencia semántica

No hay ninguna diferencia en absoluto. Type[] es la sintaxis abreviada para un arreglo de Type. Array<Type> es la sintaxis genérica. Son completamente equivalentes.

El manual proporciona un ejemplo aquí. Es equivalente a escribir:

function loggingIdentity<T>(arg: T[]): T[] {
    console.log(arg.length);
    return arg;
}

O :

function loggingIdentity<T>(arg: Array<T>): Array<T> {
    console.log(arg.length);
    return arg;
}

Y aquí hay una cita de algunas notas de la versión:

Específicamente, number[] es una versión abreviada de Array<number>, así como Date[] es una abreviatura de Array<Date>.

Acerca del modificador de tipo readonly

TypeScript 3.4, introduce el modificador de tipo readonly. Con una precisión:

el modificador de tipo readonly solo se puede usar para la sintaxis en tipos de arrays y tipos de tuplas

let err2: readonly Array<boolean>; // error!    
let okay: readonly boolean[]; // works fine

La siguiente declaración es equivalente a readonly boolean[]:

let okay2: ReadonlyArray<boolean>;

Respuesta #2

Hay una diferencia cuando estás definiendo arreglos de longitud fija. No puedes definir un arreglo de longitud fija con Array<>, tienes que usar la sintaxis abreviada:

const myFunc1 = (arg: [string, number, boolean]) => {
  console.log(arg);
};
myFunc1(["hello world", 123, true]);

// error: TS2314: Generic type 'Array ' requires 1 type argument(s).
const myFunc2 = (arg: Array<string, number, boolean>) => {
  console.log(arg);
};
myFunc2(["hello world", 123, true])