Kā izveidot un apstrādāt TypeScript masīvus

Statiskā ti­pi­zā­ci­ja ļauj TypeScript kom­pi­la­to­ram uzraudzīt masīva elementu datu tipu. Šī funkcija palīdz TypeScript masīviem samazināt kļūdu ie­spē­ja­mī­bu kodā, ļaujot izstrādāt drošākas un uz­ti­ca­mā­kas lie­to­jum­prog­ram­mas.

Kas ir TypeScript masīvi?

TypeScript valodā masīvi ir sa­kār­to­tas vērtību saraksti. Tāpat kā Ja­vaScript valodā, arī TypeScript valodā masīvus var izmantot, lai uzglabātu elementu kopu. Elementi var piederēt dažādiem datu tipiem, tostarp skaitļiem, virknēm, objektiem vai citiem masīviem. TypeScript priekš­ro­cī­ba ir statiskās ti­pi­zā­ci­jas atbalsts, kas nozīmē, ka var norādīt masīva elementu datu tipu. Tas savukārt uzlabo kļūdu atklāšanu izstrādes laikā.

Masīvu galvenā iezīme ir to di­na­mis­kais izmērs, kas ļauj pievienot vai noņemt elementus, iepriekš ne­no­tei­cot izmēru. TypeScript valodā masīvi pēc no­klu­sē­ju­ma ir maināmi. Tomēr, iz­man­to­jot masīvu metodes, piemēram, map un filter, var izveidot ne­mai­nā­mus masīvus. Ne­mai­nā­mus masīvus var izmantot, lai izveidotu jaunus masīvus, pa­ma­to­jo­ties uz esošajiem masīviem. Masīvi nodrošina vienotu struktūru datu or­ga­ni­zē­ša­nai un atvieglo elementu fil­trē­ša­nu, šķirošanu un iterēšanu.

Turklāt TypeScript masīvi var no­dro­ši­nāt pamatu tādu datu struktūru īs­te­no­ša­nai kā skapi (LIFO — Last-In-First-Out) un rindas (FIFO — First-In-First-Out). Tie ir piemēroti arī sarakstu, tabulu un kolekciju at­tē­lo­ša­nai dažādās lie­to­jum­prog­ram­mās. Tā kā vienāda tipa elementus var viegli pārvaldīt, masīvi ir īpaši noderīgi, ap­strā­dā­jot datus no ārējiem avotiem, piemēram, API vai datu bāzēm.

Kāda ir TypeScript masīvu sintakse?

TypeScript valodā masīvi tiek deklarēti ar at­slēg­vār­diem let, const vai var, kam seko mainīgā vārds un datu tipa spe­ci­fi­kā­ci­ja. Dek­la­rē­jot datu tipu, jūs norādāt, kādam datu tipam jābūt masīva ele­men­tiem. To dara, iz­man­to­jot divpunktu. Elementi tiek ievietoti kvad­rā­tie­ka­vās un atdalīti ar komatiem masīva ini­cia­li­za­to­ra blokā.

Vispārīgā sintakse TypeScript masīva dek­la­rē­ša­nai ir šāda:

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

• va­riab­le­Na­me ir nosaukums, ko iz­vē­la­ties masīvam.
• datatype norāda masīva elementu datu tipu.
• [element1, element2, …] ir faktiskie elementi vai vērtības, kas jāuzglabā masīvā. Šiem ele­men­tiem jābūt tādam datu tipam, kas ir norādīts masīvam.

Šeit ir daži piemēri, kas palīdz ilustrēt sintaksi:

// 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];

Kādas TypeScript masīva metodes ir pieejamas?

TypeScript masīvu metodes ir ļoti noderīgas un jaudīgas, jo tās ļauj efektīvi apstrādāt, pārveidot un organizēt datus masīvos. Turp­mā­ka­jā tabulā ir sniegts pārskats par iz­pla­tī­tā­ka­jām masīvu metodēm TypeScript un to lie­to­ša­nas veidiem.

TypeScript masīva piemēri

TypeScript masīvi ir ne­aiz­stā­ja­mi rīki, kad runa ir par datu or­ga­ni­zē­ša­nu un apstrādi lie­to­jum­prog­ram­mās. Tur­pi­nā­ju­mā ap­ska­tī­sim dažas no gal­ve­na­jām darbībām.

Piekļuve masīva ele­men­tiem

Piekļuve masīva ele­men­tiem TypeScript ir pamata darbība, kas ļauj atgūt konkrētus elementus masīvā. Jūs varat piekļūt masīva ele­men­tiem, iz­man­to­jot to indeksu, kas atspoguļo to pozīciju masīvā. TypeScript masīva indeksi sākas no nulles. Tas nozīmē, ka pirmajam elementam ir indekss 0, bet otrajam elementam ir indekss 1.

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

Masīvu des­truk­tu­rē­ša­na

Iz­man­to­jot masīva des­truk­tu­ri­zā­ci­ju, var ātri un viegli izgūt vērtības no masīva un piešķirt tās mai­nī­ga­jam.

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

Iterācija pār ele­men­tiem TypeScript masīvos

Šeit ir piemērs, kā atkārtot masīvu TypeScript, iz­man­to­jot for cilpu:

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

Šajā piemērā mums ir masīvs numbers, kas satur skaitļus. Mēs iz­man­to­jam for cilpu, lai izietu cauri masīvam. Cilpa sākas ar i = 0, un mēs pa­lie­li­nām i katrā cilpas ciklā. Ar numbers[i] mēs varam piekļūt at­tie­cī­ga­jam masīva elementam un izvadīt to.

Šis ir izvades rezultāts:

1
2
3
4
5

b063a9a0bb050c0cbf3a12ca06492bdb

367d32e6e3dca06fe225f3fb0920ab8d

7023faba66ebf53c94fb07a51ede46c2

787c9893abf7d98e9aa25d17a1eebedd