Ty­peS­cript arrays: Como criar e manipular arrays em Ty­peS­cript

Por ser de tipagem estática, a linguagem de pro­gra­ma­ção Ty­peS­cript permite o mo­ni­to­ra­mento dos tipos de dados de elementos de um array. Também por isso, arrays em Ty­peS­cript minimizam as chances de erros em códigos, per­mi­tindo que você de­sen­volva apli­ca­ções mais seguras e con­fiá­veis.

O que é array em Ty­peS­cript?

Em Ty­peS­cript, arrays são listas ordenadas de valores. Assim como em Ja­vaS­cript, você pode usar arrays em Ty­peS­cript para armazenar coleções de elementos. Esses elementos podem ter di­fe­ren­tes tipos de dados, incluindo números, strings, objetos e outros arrays. Em com­pa­ra­ção ao Ja­vaS­cript, a linguagem de pro­gra­ma­ção Ty­peS­cript oferece a vantagem de suportar a tipagem estática, per­mi­tindo que você defina o tipo de dado dos elementos de um array — isso aprimora a detecção de erros durante o processo de de­sen­vol­vi­mento, dis­pen­sando a execução de códigos.

Uma das prin­ci­pais ca­rac­te­rís­tica dos arrays é o tamanho dinâmico que eles podem ter: eles permitem que você adicione ou remova elementos sem que precise de­ter­mi­nar o tamanho destes pre­vi­a­mente. No Ty­peS­cript, arrays são mutáveis por padrão. No entanto, também é possível criar arrays imutáveis, pelo método map, e novos arrays com base em arrays exis­ten­tes, pelo método filter. Arrays facilitam a filtragem, a ordenação e a iteração de elementos, pro­por­ci­o­nando uma estrutura mais con­sis­tente para a or­ga­ni­za­ção de dados.

Arrays em Ty­peS­cript também podem servir como base para a im­ple­men­ta­ção de es­tru­tu­ras de dados como pilhas (LIFO: Last-In-First-Out) e filas (FIFO: First-In-First-Out). Eles também são adequados para a re­pre­sen­ta­ção de listas, tabelas e coleções nos mais variados tipos de apli­ca­ções. Ao conseguir gerir elementos de mesmo tipo de forma simples, arrays acabam sendo es­pe­ci­al­mente úteis para o pro­ces­sa­mento de dados de fontes externas, sejam estes pro­ve­ni­en­tes de APIs ou de bancos de dados.

Sintaxe de arrays em Ty­peS­cript

Na linguagem de pro­gra­ma­ção Ty­peS­cript, arrays devem ser de­cla­ra­dos por um destes comandos: let, const ou var. Ao comando deve se seguir o nome da variável e a de­cla­ra­ção do tipo de dado. De­cla­ra­ções de tipos de dados podem ser feitas por meio da uti­li­za­ção de dois pontos. Elas indicam o tipo de dado que os elementos do array em questão devem ter. Os elementos, por sua vez, precisam ser inseridos entre colchetes e separados por vírgulas, em blocos de ini­ci­a­li­za­ção de arrays.

A sintaxe básica para a de­cla­ra­ção de um array em Ty­peS­cript é a seguinte:

const variableName: datatype[] = [element1, element2, ...];

• variableName: É o nome que você deve dar ao array.
• datatype: Es­pe­ci­fica o tipo de dado que os elementos do array devem ter.
• [element1, element2, ...]: Re­pre­sen­tam os elementos ou valores reais que devem ser ar­ma­ze­na­dos no array — esses elementos devem ter um tipo de dado pre­vi­a­mente definido.

Apre­sen­ta­re­mos, abaixo, alguns exemplos que ilustram a sintaxe de Ty­peS­cript arrays:

// Data type: Number
const numbers: number[] = [1, 2, 3, 4, 5];
// Data type: String
const numbers: string[] = ["Alice", "Bob", "Charlie"];
// Data type: Boolean
const booleans: boolean[] = [true, false];

Métodos de arrays em Ty­peS­cript

Ty­peS­cript arrays possuem métodos ex­tre­ma­mente úteis e poderosos, que permitem que você processe, trans­forme e organize dados em arrays de modo mais eficiente. Esta tabela apresenta os métodos mais comuns de arrays em Ty­peS­cript, e explica quando estes devem ser aplicados:

Exemplos de aplicação de arrays em Ty­peS­cript

Ty­peS­cript arrays são es­sen­ci­ais na or­ga­ni­za­ção de códigos e no pro­ces­sa­mento de dados em apli­ca­ções. A seguir, acompanhe algumas das etapas mais im­por­tan­tes que envolvem arrays em Ty­peS­cript.

Acessar elementos de arrays em Ty­peS­cript

Acessar elementos de um array em Ty­peS­cript é uma operação fun­da­men­tal, que pos­si­bi­lita a re­cu­pe­ra­ção de elementos es­pe­cí­fi­cos dentro deste array. Você pode acessar elementos de um array por meio do índice, que nada mais é que a re­pre­sen­ta­ção das posições de um array. Na linguagem de pro­gra­ma­ção Ty­peS­cript, a indexação de arrays começa no zero. Portanto, todo primeiro elemento será clas­si­fi­cado com o índice 0. O segundo, por sua vez, será indicado como 1 pelo índice, e assim por diante. Observe:

let myArray: number[] = [10, 20, 30, 40, 50];
// Accessing elements using index
let firstElement: number = myArray[0]; // Output: 10
let secondElement: number = myArray[1]; // Output: 20
let thirdElement: number = myArray[2]; // Output: 30
// Assigning a new value to an array element
myArray[3] = 99; // 4th element in myArray = 99

De­ses­tru­tu­rar arrays em Ty­peS­cript

Graças à pos­si­bi­li­dade de de­ses­tru­tu­ra­ção de arrays em Ty­peS­cript, você pode extrair valores de um array com rapidez, e atribuí-los a variáveis de forma simples e direta:

let numberArray: number[] = [1, 2, 3];
// Array destructuring
let [firstNumber, secondNumber, thirdNumber] = numberArray;
// Access values
console.log(firstNumber); // Outputs 1
console.log(secondNumber); // Outputs 2
console.log(thirdNumber); // Outputs 3

Iterar sobre elementos de arrays em Ty­peS­cript

Abaixo, apre­sen­ta­mos um exemplo de iteração sobre um array em Ty­peS­cript. Para isso, fizemos uso do loop for:

let numbers: number[] = [1, 2, 3, 4, 5];
for (let i = 0; i < numbers.length; i++) {
    console.log(numbers[i]);
}

No código, inserimos o array numbers, que contém números. Em seguida, uti­li­za­mos um loop for para iterar sobre elementos do array. O loop começa com i = 0, sendo in­cre­men­tado em i a cada passage. Por meio de numbers[i], podemos acessar e exibir cada elemento do array.

Este é o resultado apre­sen­tado pelo código:

1
2
3
4
5