Array

• Se puede crear un arreglo que soporte una lista definida de tipos de datos. e.g:

  let myArray: (string | number | boolean)[];
  myArray = [false, 1, '2'];
  

• De igual forma se puede crear un arreglo irrestricto como los de Javascript. e.g:

  let myArray: any[];
  myArray = [{}, true, 'two', 0b11];
  

Dos notaciones: [] y Array<Type>
ejemplo:

const names = string[];
const months = Array<string>;

Se puede acceder con indices.

names[0];
months[5];

se puede usar la prop length
se puede usar el method push
Supongo que todos los de Array. Buscar en MDN.

Si queremos que un array contenga elementos de más de un tipo, lo podemos declarar de la siguiente manera:

let arrExample: Array<string | number | boolean>;
arrExample = ['firstItem', 2, 'thirdItem', 4, true]; // no da error

// ------- Tipo: Array -------

// Explicito
let users: string[];
users = ['luixaviles', 'paparazzi', 'lensqueen'];
// users = [1, true, 'test']; // --> Error

// Inferido
let otherUsers = ['luixaviles', 'paparazzi', 'lensqueen'];
// otherUsers = [1, true, 'test']; // --> Error

// Array<tipoDato>
let pictureTitles: Array<string>;
pictureTitles = ['Favorite Sunset', 'Vacation Time', 'Landscape'];

// Accediendo a los valores en un Array
console.log('first user : ', users[0]); // --> users[indice]: luixaviles
console.log('first title : ', pictureTitles[0]);

// Propiedades en Array
console.log('users.length : ', users.length); // -> Tamaño del Array

// Uso de funciones en Arrays
users.push('aPlatziUser');  // -> agrega dato a la cola del Array
users.sort();   // --> ordena el Array de menor a mayor (alfabetica)
console.log('users', users);

1. Array. Al igual que en JavaScript, TypeScript permite definir un arreglo para contener un conjunto de valores, para definir los arreglos se pueden usar nos notaciones [] y Array<type>.

   // Corchetes []
   const nickname: string[] = ['Syaan', 'Matt', 'Lou']
   const idNumber: number[] = [1, 2, 3, 4, 5]
   
   // Array<type>
   const pictureTitles: Array<string> = ['Favorite Sunset', 'Vacation Time', 'Landscape']
   

En la versión actual typescript ya reconoce por sí solo los diferentes tipos de valores ingresados en un array sin generar error.

• Al igual que JS, TS permite definir un arreglo para contener un conjunto de valores.
• Usa 2 notaciones: [] y Array<tipo>

Documentación oficial de tipos de datos usados en TypeScript

MY NOTES FOR ARRAY

• Al igual que Javascript, Typescript permite definir un arreglo para contener un conjunto de valores
  .
• Usa dos notaciones: [] y Array<tipo>
  .

// Corchetes []

//Tipo Explicito
  // tipodeDato[]

let users:string[];
users =['luixaviles', 'paparazzi', 'lensqueen'];

//Si le pusieramos distintos tipos de datos al que se le establecio al array
  //Daria error
// users = [1, true, 'test']; Error

//Tipo Inferido
  //Si le asignamos a una variable un array sin especificar el tipo
    //Typescript infiere el tipo de dato que tendra dependiendo lo que le pasemos


let otherUsers = ['luixaviles', 'paparazzi', 'lensqueen'];

// users = [1, true, 'test']; Error

// Arra<TIPO>
  //Definimos el array esplicitamente y dentro de los <> ponemos el tipo de dato que
    //Tendra el array

let pictureTitles: Array<string>;

  //Al berificar con el cursor la variable veremos el tipo de dato que tiene el array

pictureTitles =['Favorite Sunset', 'Vacation Time', 'Landscape'];


//Accediendo a los valores en un Array
  //Podremos acceder al elemento de un array igual que en js

  console.log(pictureTitles[0]); 


//Propiedades en Array

console.log(users.length) //3

//Funciones en Array

users.push('platzi users');
users.sort();
console.log('users', users);

Al igual que en JS o lenguajes de alto nivel, TS permite almacenar un conjunto de datos -
Para definirlo se usan dos formas:
[]TYPE || Array<TYPE>

//Tipo Explícito: []
let myFirstArray: string[];  // Se especifica que el tipo del arreglo contiene strings - Únicamente contiene Strings
myFirstArray = ['Andrés', 'Jhon', 'Iván', 'Santo'];
// myFirstArray = [123, false, 'indicator'] // Error

//Tipo Inferido: []
let mySecondArray = [ 123, false, 'indicator' ];
mySecondArray = [true, 'compulsive', 23];
mySecondArray = ['myString', false, 456];
// En los tipos inferidos de los arrays, la forma estructural de como se declara define los tipos
// que puede tener dentro el arreglo, en este caso es ( string | number | boolean ) y no importa el orden
// solo debe cumplir con que existan esos tres tipos de datos dentro del Array. Sino, arrojará Error

//Tipo Explícito: Array<TYPE>
let myNumbers: Array<number>;
myNumbers = [12, 34, 56];

console.log('valores del arreglo myNumbers -> ', myNumbers[2])
console.log('valores del arreglo myfirstArray -> ', myFirstArray[0])

mySecondArray.pop()
mySecondArray.unshift(678)
console.log('valores del arreglo mySecondArray -> ', mySecondArray)

myFirstArray.sort()
console.log('valores del arreglo myFirstArray -> ', myFirstArray)

Dejo la documentación de Mozilla sobre los Array y sus métodos (Que son bastantes): https://developer.mozilla.org/es/docs/Web/JavaScript/Referencia/Objetos_globales/Array

Si la variable la declaran en singular el compilador arroja un error.

tambien se puede hacer lo siguiente:

let variable: any [];
variable = [false, 1, '2'];

console.log(variable) 

Algunas funciones de Array en contexto typescript:

// Uso de funciones en Arrays
users.push('aPlatziUser');
users.sort();
console.log('users', users);

let newUsers = ['Leandro','Gabriela'];

let arrayConcat =users.concat(newUsers);
console.log('users concat', arrayConcat);

let usersJoin = users.join('-');
console.log('users Join', usersJoin);

let usersIndexOf = arrayConcat.lastIndexOf('Leandro');
console.log('users IndexOf', usersIndexOf);

let usersPop=users.pop();
console.log('users pop', usersPop);

Tipo: Array

• Al igual que JavaScript, TypeScript permite definir un arreglo para contener un conjunto de valores
• Usa dos notaciones: [] y Arrat<tipo>

// Tipo Explicito
let users: string[];
users = ['name1', 'name2', 'name3'];
// users = [1, true, 'test'] // Error solo string

// Tipo inferido
let otherUsers = ['a', 'b'];
// otherUsers = [1, true, 'test'] // Error solo string

// Array<TIPO>
let pictureTitles: Array<string>;
pictureTitles = ["A", "B"];

console.log("fistUser", users[0]);
console.log("fistTitle", pictureTitles[0]);

Me parece bien utilizar la nomenclaruta de variable: tipo[ ] para arreglos rapidos y de pocos elementos que vaya a ocupar en mi proyecto.
Y usar variable: Array<tipo> para aquellos arreglos que van a contener muchos elementos y su longitud estara variando a lo largo de la aplicacion.

En la mayoría de lenguajes de alto nivel no se aplica la definición estricta de “array”, ya que según su definición son un conjunto de datos del mismo tipo.

En TypeScript podemos usar la definición estricta de “array”, la que se tiene en lenguajes como JavaScript en los que podemos tener varios tipos de dato en el mismo array o incluso un término medio en el que indicamos una serie de tipos que puede contener el array.

// definición estricta de arrays
let users: string[] = ["John", "Jane"];

// arrays según JavaScript (y otros lenguajes)
let users: any[] = ["a", 1, true];

// especificar tipos de dato
let things: Array<number | boolean> = [32, true];
// or
let things: (number | boolean)[] = [32, true];

//Corchetes []

//Tipo Explicito

let users: string[];
users = ['Alejnadro', 'Vera','Hernandez'];

// users = [1, true, 'Luis']; //Error


// Tipo inferido 

let otherUsers = ['Alejnadro', 'Vera','Hernandez'] //infiere que es un array de strings
// users = [1, true, 'Luis']; //Error


// Array<TIPO>

let picturesTitle: Array<string>;
picturesTitle=['Landscape', 'Favorite sunset', 'Vacation time'];

//Accediendo a los valores de un array
console.log('First user', users[0])
console.log('First picture', picturesTitle[1]);

//Propiedades de Array

console.log('users.lenght', users.length) //Output: users.lenght 3

//Uso de funciones de Array
users.push('Luuisillo');
users.sort();
console.log('user', users); //Output: user [ 'Alejnadro', 'Hernandez', 'Luuisillo', 'Vera' ]

Luego de ver que el tipo “objeto” no permite leer sus propiedades directamente, es un alivio ver que los arrays soportan índices

Array, colección de datos almacenados en una variable. Se accede por los índices, pueden ser objetos.

array.forEach()
array.map()
array.pop()

pues al hacer un arreglo me suena un poco ilógico que no se pudiera acceder a ninguno de los métodos para arreglos de JS.

Seguimos creciendo!!!

Excelente

Conjunto de datos

Sintaxis:

// []
// Explicito
let users: string[] = ['federico', 'ramiro', 'juaquin'];

// Inferido
let users = ['federico', 'ramiro', 'juaquin'];

//Array<TIPO>
let users: Array<string> = ['federico', 'ramiro', 'juaquin'];

👌

a

un array soporta varios tipos de datos si se especifica o solo poniendo un array de any.

users.map((user)=>{
    console.log('users', user)
})```

Un Array es un tipo especial de tipo de datos que puede almacenar múltiples valores de diferentes tipos de datos secuencialmente usando una sintaxis especial.
TypeScript admite matrices, similar a JavaScript. Hay dos formas de declarar una Array :

1. Utilizando corchetes. Este método es similar a cómo declararía matrices en JavaScript.

let fruits: string[] = ['Apple', 'Orange', 'Banana'];

1. Usando un tipo de arreglo genérico, Array <elementType>.

let fruits: Array<string> = ['Apple', 'Orange', 'Banana'];

Ambos métodos producen el mismo resultado.