# Kaip kurti ir tvarkyti TypeScript masyvus

Statinis tipizavimas leidžia **TypeScript kompiliatoriui** stebėti masyvo elementų duomenų tipą. Ši funkcija padeda TypeScript masyvams sumažinti klaidų tikimybę jūsų kode, leidžiant kurti saugesnes ir patikimesnes programas.

## Kas yra TypeScript masyvai?

TypeScript kalboje masyvai yra **tvarkingai išdėstyti verčių sąrašai**. Kaip ir JavaScript kalboje, TypeScript kalboje masyvus galima naudoti elementų rinkiniams saugoti. Elementai gali būti įvairių duomenų tipų, įskaitant skaičius, eilutes, objektus ar kitus masyvus. [TypeScript kalbos](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/kas-yra-typescript/) privalumas yra tai, kad ji palaiko statinį tipizavimą, o tai reiškia, kad galima nurodyti masyvo elementų duomenų tipą. Tai savo ruožtu pagerina klaidų aptikimą kūrimo metu.

Svarbiausia masyvų savybė yra jų dinaminis dydis, kuris leidžia pridėti arba pašalinti elementus be išankstinio dydžio nustatymo. TypeScript kalboje masyvai pagal numatytuosius nustatymus yra keičiami. Tačiau naudojant masyvų metodus, pvz., `map` ir `filter`, galima sukurti **nekintamus masyvus**. Nekintami masyvai gali būti naudojami naujiems masyvams kurti remiantis esamais masyvais. Masyvai suteikia nuoseklią struktūrą duomenų organizavimui ir palengvina elementų filtravimą, rūšiavimą ir kartojimą.

Be to, TypeScript masyvai gali būti pagrindas duomenų struktūrų, tokių kaip stekai (LIFO – Last-In-First-Out) ir eilės (FIFO – First-In-First-Out), įgyvendinimui. Jie taip pat tinka **sąrašams, lentelėms ir kolekcijoms** įvairiose programose **pateikti**. Kadangi to paties tipo elementus galima lengvai valdyti, masyvai yra ypač naudingi apdorojant duomenis iš išorinių šaltinių, pvz., API ar duomenų bazių.

## Kokia yra TypeScript masyvų sintaksė?

TypeScript kalboje masyvai deklaruojami naudojant raktinius žodžius `let`, `const` arba `var`, po kurių eina kintamojo vardas ir **duomenų tipo specifikacija**. Deklaruodami duomenų tipą, nurodote, kokio tipo duomenys turi būti masyvo elementuose. Tai daroma naudojant dvitaškį. Elementai rašomi kvadratinėse skliaustose ir atskiriami kableliais masyvo inicijavimo bloke.

Bendroji sintaksė, skirta deklaruoti TypeScript masyvą, yra tokia:

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

- **variableName** yra pavadinimas, kurį pasirenkate masyvui.
- **datatype** nurodo masyvo elementų duomenų tipą.
- **\[element1, element2, …\]** yra tikrieji elementai arba reikšmės, kurios turi būti saugomos masyve. Šie elementai turi turėti duomenų tipą, kuris buvo nurodytas masyvui.

Štai keletas pavyzdžių, kurie padeda iliustruoti sintaksę:

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

## Kokie yra TypeScript masyvo metodai?

TypeScript masyvų metodai yra labai naudingi ir galingi, nes jie leidžia efektyviai **apdoroti, transformuoti ir organizuoti** duomenis į masyvus. Toliau pateiktoje lentelėje pateikiama bendrų TypeScript masyvų metodų apžvalga ir jų naudojimo būdai.

<table>
  <thead>
    <tr>
      <th>Metodai</th>
      <th>Aprašymas</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>`push()`</td>
      <td>Prideda vieną ar daugiau elementų prie masyvo galo ir grąžina naują masyvo ilgį.</td>
    </tr>
    <tr>
      <td>`pop()`</td>
      <td>Pašalina paskutinį elementą iš masyvo ir grąžina jį.</td>
    </tr>
    <tr>
      <td>`unshift()`</td>
      <td>Prideda vieną ar daugiau elementų prie masyvo pradžios ir grąžina naują masyvo ilgį.</td>
    </tr>
    <tr>
      <td>`shift()`</td>
      <td>Pašalina pirmąjį elementą iš masyvo ir grąžina jį.</td>
    </tr>
    <tr>
      <td>`concat()`</td>
      <td>Sujungia esamą masyvą su vienu ar keliais kitais masyvais ir grąžina naują masyvą. Pirminis masyvas lieka nepakitęs.</td>
    </tr>
    <tr>
      <td>`join(separator)`</td>
      <td>Paverčia masyvo elementus į eilutę ir grąžina ją. Galite pasirinkti elementų atskyriklį.</td>
    </tr>
    <tr>
      <td>`slice(start, end)`</td>
      <td>Sukuria plokščią masyvo kopiją, sudarytą iš elementų tarp nurodytų indeksų „start“ (įskaitant) ir „end“ (neįskaitant). Pirminis masyvas lieka nepakitęs.</td>
    </tr>
    <tr>
      <td>`splice(start, deleteCount, element1, element2, ...)`</td>
      <td>Įterpia naujus elementus nurodytose pozicijose ir (arba) pašalina elementus iš masyvo.</td>
    </tr>
    <tr>
      <td>`forEach(callback)`</td>
      <td>Vykdo pateiktą funkciją kiekvienam masyvo elementui.</td>
    </tr>
    <tr>
      <td>`map(callback)`</td>
      <td>Sukuria naują masyvą, taikydamas funkciją kiekvienam masyvo elementui.</td>
    </tr>
    <tr>
      <td>`filter(callback)`</td>
      <td>Sukuria naują masyvą su visais elementais, kurie atitinka nurodytos funkcijos įgyvendintą testą.</td>
    </tr>
  </tbody>
</table>

## TypeScript masyvo pavyzdžiai

TypeScript masyvai yra nepakeičiami įrankiai, kai reikia tvarkyti ir apdoroti duomenis programose. Toliau apžvelgsime keletą pagrindinių operacijų.

### Prieiga prie masyvo elementų

Prieiga prie masyvo elementų TypeScript yra pagrindinė operacija, leidžianti gauti konkrečius elementus masyve. Prie masyvo elementų galima prieiti naudojant jų indeksą, kuris atspindi jų padėtį masyve. TypeScript **masyvo indeksai yra nuliniai**. Tai reiškia, kad pirmasis elementas turi indeksą 0, o antrasis elementas – indeksą 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
```

### Masyvų dekonstravimas

Naudodami **masyvo dekonstrukciją**, galite greitai ir lengvai išgauti reikšmes iš masyvo ir priskirti jas kintamajam.

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

### TypeScript masyvų elementų kartojimas

Štai pavyzdys, kaip kartoti masyvą TypeScript naudojant **for ciklą**:

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

Šiame pavyzdyje turime masyvą `numbers`, kuriame yra skaičiai. Naudojame for ciklą, kad pereitume per masyvą. Ciklas prasideda nuo `i = 0`, ir kiekviename ciklo praėjime padidiname `i`. Su `numbers[i]` galime pasiekti atitinkamą masyvo elementą ir jį išvesti.

Tai yra rezultatas:

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


This is a markdown version of: [https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/typescript-masyvai/](https://www.ionos.com/lt-lt/digitalguide/interneto-svetaines/interneto-svetainiu-kurimas/typescript-masyvai/) for AI/LLM consumption.