# Kuidas luua ja manipuleerida TypeScripti massiive

Staatiline tüüpimine võimaldab **TypeScripti kompilaatoril** jälgida massiivi elementide andmetüüpi. See funktsioon aitab TypeScripti massiividel vähendada vea tõenäosust koodis, võimaldades teil arendada turvalisemaid ja usaldusväärsemaid rakendusi.

## Mis on TypeScripti massiivid?

TypeScriptis on massiivid **järjestatud väärtuste loendid**. Nagu JavaScriptis, saate ka TypeScriptis kasutada massiive elementide kogumi salvestamiseks. Elementideks võivad olla erinevad andmetüübid, sealhulgas numbrid, stringid, objektid või muud massiivid. [TypeScripti](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/mis-on-typescript/) eeliseks on staatilise tüüpimise toetamine, mis tähendab, et saate määrata massiivi elementide andmetüübi. See omakorda parandab vea tuvastamist arendamise käigus.

Massiivide oluline omadus on nende dünaamiline suurus, mis võimaldab lisada või eemaldada elemente ilma suurus eelnevalt kindlaks määramata. TypeScriptis on massiivid vaikimisi muutuvad. Siiski on võimalik luua **muutumatuid massiive**, kasutades massiivi meetodeid, nagu `map` ja `filter`. Muutumatuid massiive saab kasutada uute massiivide loomiseks olemasolevate massiivide põhjal. Massiivid pakuvad andmete organiseerimiseks ühtset struktuuri ja hõlbustavad elementide filtreerimist, sorteerimist ja iteratsiooni.

Lisaks võivad TypeScripti massiivid olla aluseks selliste andmestruktuuride rakendamisel nagu virnad (LIFO – Last-In-First-Out) ja järjekorrad (FIFO – First-In-First-Out). Need sobivad ka **nimekirjade, tabelite ja kogumite esitamiseks** mitmesugustes rakendustes. Kuna sama tüüpi elemente on lihtne hallata, on massiivid eriti kasulikud välistest allikatest, olgu need siis API-d või andmebaasid, pärit andmete töötlemisel.

## Milline on TypeScripti massiivide süntaks?

TypeScriptis deklareeritakse massiivid märksõnadega `let`, `const` või `var`, millele järgneb muutuja nimi ja **andmetüübi määratlus**. Andmetüübi deklareerimisel määratakse, millist andmetüüpi massiivi elemendid peaksid olema. Selleks kasutatakse koolonit. Elemendid paigutatakse massiivi algataja plokis nurksulgudesse ja eraldatakse komadega.

TypeScripti massiivi deklareerimise üldine süntaks on järgmine:

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

- **variableName** on massiivi jaoks valitud nimi.
- **datatype** määrab massiivi elementide andmetüübi.
- **\[element1, element2, …\]** on tegelikud elemendid või väärtused, mis massiivi salvestatakse. Nendel elementidel peab olema massiivi jaoks määratud andmetüüp.

Siin on mõned näited, mis aitavad süntaksit illustreerida:

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

## Millised TypeScripti massiivi meetodid on olemas?

TypeScripti massiivi meetodid on äärmiselt kasulikud ja võimsad, kuna need võimaldavad andmeid tõhusalt **töödelda, teisendada ja** massiivideks **organiseerida**. Järgnev tabel annab ülevaate TypeScripti levinumatest massiivi meetoditest ja nende kasutusvõimalustest.

<table>
  <thead>
    <tr>
      <th>Meetodid</th>
      <th>Kirjeldus</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`push()`</td>
      <td>Lisab massiivi lõppu ühe või mitu elementi ja tagastab massiivi uue pikkuse.</td>
    </tr>
    <tr>
      <td>`pop()`</td>
      <td>Eemaldab massiivi viimase elemendi ja tagastab selle.</td>
    </tr>
    <tr>
      <td>`unshift()`</td>
      <td>Lisab massiivi algusse ühe või mitu elementi ja tagastab massiivi uue pikkuse.</td>
    </tr>
    <tr>
      <td>`shift()`</td>
      <td>Eemaldab massiivi esimese elemendi ja tagastab selle.</td>
    </tr>
    <tr>
      <td>`concat()`</td>
      <td>Ühendab praeguse massiivi ühe või mitme teise massiiviga ja tagastab uue massiivi. Algne massiiv jääb muutumatuks.</td>
    </tr>
    <tr>
      <td>`join(separator)`</td>
      <td>Muudab massiivi elemendid stringiks ja tagastab selle. Võite valida elementide eraldaja.</td>
    </tr>
    <tr>
      <td>`slice(start, end)`</td>
      <td>Loob massiivi lame koopia, mis koosneb elementidest määratud indeksite „start” (kaasa arvatud) ja „end” (välja arvatud) vahel. Algne massiiv jääb muutumatuks.</td>
    </tr>
    <tr>
      <td>`splice(start, deleteCount, element1, element2, ...)`</td>
      <td>Lisab massiivi määratud positsioonile uusi elemente ja/või eemaldab massiivist elemente.</td>
    </tr>
    <tr>
      <td>`forEach(callback)`</td>
      <td>Käivitab antud funktsiooni massiivi iga elemendi jaoks.</td>
    </tr>
    <tr>
      <td>`map(callback)`</td>
      <td>Loob uue massiivi, rakendades funktsiooni massiivi iga elemendi suhtes.</td>
    </tr>
    <tr>
      <td>`filter(callback)`</td>
      <td>Loob uue massiivi, mis sisaldab kõiki elemente, mis läbivad määratud funktsiooni poolt rakendatud testi.</td>
    </tr>
  </tbody>
</table>

## TypeScripti massiivi näited

TypeScripti massiivid on rakendustes andmete organiseerimisel ja töötlemisel asendamatud vahendid. Allpool vaatame lähemalt mõningaid olulisemaid operatsioone.

### Juurdepääs massiivi elementidele

TypeScriptis massiivi elementidele juurdepääs on põhioperatsioon, mis võimaldab teil massiivist konkreetseid elemente välja otsida. Massiivi elementidele pääsete juurde nende indeksite abil, mis näitavad nende asukohta massiivis. TypeScriptis **on massiivi indeksid nullipõhised**. See tähendab, et esimese elemendi indeks on 0 ja teise elemendi indeks on 1.

```typescript
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
```

### Massiivide destruktureerimine

**Massiivi destruktureerimise** abil saate kiiresti ja lihtsalt massiivist väärtusi välja võtta ja need muutujale omistada.

```typescript
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
```

### TypeScripti massiivides elementide iteratsioon

Siin on näide, kuidas TypeScriptis **for-tsükliga** massiivi läbi käia:

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

Selles näites on meil massiiv `numbers`, mis sisaldab numbreid. Kasutame for-tsüklit, et massiivi läbi käia. Tsükkel algab numbrist `i = 0` ja iga tsükli läbimisel suurendame `i`. Numbriga `numbers[i]` saame juurdepääsu massiivi vastavale elemendile ja väljastame selle.

See on väljund:

```typescript
1
2
3
4
5
```


This is a markdown version of: [https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/typescripti-massiivid/](https://www.ionos.com/et-ee/digitalguide/veebisaidid/veebiarendus/typescripti-massiivid/) for AI/LLM consumption.