Hur man skapar och hanterar Ty­pe­Script-matriser

Statisk typning gör det möjligt för Ty­pe­Script-kom­pi­la­torn att övervaka datatypen för ar­ray­e­le­ment. Denna funktion hjälper Ty­pe­Script-arrayer att minska risken för fel i din kod, vilket gör att du kan utveckla säkrare och mer till­för­lit­li­ga ap­pli­ka­tio­ner.

Vad är Ty­pe­Script-matriser?

I Ty­pe­Script är arrayer ordnade listor med värden. Precis som i Ja­va­Script kan du använda arrayer i Ty­pe­Script för att lagra en samling element. Elementen kan tillhöra olika datatyper, inklusive siffror, strängar, objekt eller andra arrayer. Ty­pe­Script har fördelen att det stöder statisk typning, vilket innebär att du kan ange datatypen för elementen i en array. Detta för­bätt­rar i sin tur felupp­täck­ten under ut­veck­ling­en.

En viktig egenskap hos arrayer är deras dynamiska storlek, som gör att du kan lägga till eller ta bort element utan att behöva bestämma storleken i förväg. I Ty­pe­Script är arrayer muterbara som standard. Du kan dock skapa immutabla arrayer genom att använda array-metoder som map och filter. Immutabla arrayer kan användas för att skapa nya arrayer baserade på be­fint­li­ga arrayer. Arrayer ger en kon­se­kvent struktur för att or­ga­ni­se­ra data och gör det enklare att filtrera, sortera och iterera över element.

Dessutom kan Ty­pe­Script-matriser utgöra en grund för im­ple­men­te­ring av da­ta­struk­tu­rer såsom stackar (LIFO – Last-In-First-Out) och köer (FIFO – First-In-First-Out). De är också lämpliga för att re­pre­sen­te­ra listor, tabeller och samlingar i en rad olika ap­pli­ka­tio­ner. Eftersom element som tillhör samma typ är lätta att hantera är matriser särskilt an­vänd­ba­ra vid be­ar­bet­ning av data från externa källor, vare sig det är API:er eller databaser.

Vad är syntaxen för Ty­pe­Script-matriser?

I Ty­pe­Script de­kla­re­ras arrayer med nyc­kelor­den let, const eller var följt av ett va­ri­a­bel­namn och en da­ta­typs­spe­ci­fi­ka­tion. När du de­kla­re­rar en datatyp anger du vilken datatyp elementen i arrayen ska ha. Detta görs med hjälp av ett kolon. Elementen placeras inom hak­pa­ren­te­ser och separeras med kom­ma­tec­ken i ett ar­ray­i­ni­ti­a­li­se­rings­block.

Den allmänna syntaxen för att deklarera en Ty­pe­Script-array är följande:

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

• va­ri­ab­le­Na­me är det namn du väljer för arrayen.
• datatype anger datatypen för elementen i arrayen.
• [element1, element2, …] är de faktiska elementen eller värdena som ska lagras i arrayen. Dessa element ska ha den datatyp som har angetts för arrayen.

Här är några exempel som hjälper till att il­lu­stre­ra syntaxen:

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

Vilka array-metoder finns det i Ty­pe­Script?

Ty­pe­Script-array-metoder är extremt an­vänd­ba­ra och kraft­ful­la eftersom de gör det möjligt att effektivt bearbeta, omvandla och or­ga­ni­se­ra data i arrayer. Följande tabell ger en översikt över vanliga array-metoder i Ty­pe­Script och hur de kan användas.

Exempel på Ty­pe­Script-matriser

Ty­pe­Script-matriser är oum­bär­li­ga verktyg när det gäller att or­ga­ni­se­ra och bearbeta data i ap­pli­ka­tio­ner. Nedan tittar vi på några av de vik­ti­gas­te funk­tio­ner­na.

Åtkomst till ar­ray­e­le­ment

Att komma åt ar­ray­e­le­ment i Ty­pe­Script är en grund­läg­gan­de operation som gör det möjligt att hämta specifika element i en array. Du kan komma åt ar­ray­e­le­ment med hjälp av deras index, som re­pre­sen­te­rar deras position i arrayen. I Ty­pe­Script är ar­ray­in­dex noll­ba­se­ra­de. Det innebär att det första elementet har index 0 och det andra elementet har index 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

De­struk­tu­re­ra arrayer

Med array-de­struk­tu­re­ring kan du snabbt och enkelt extrahera värden från en array och tilldela dem till en variabel.

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

Iterera över element i Ty­pe­Script-matriser

Här är ett exempel på hur man itererar över en array i Ty­pe­Script med hjälp av en for-slinga:

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

I det här exemplet har vi arrayen numbers, som in­ne­hål­ler siffror. Vi använder en for-slinga för att iterera genom arrayen. Slingan börjar vid i = 0, och vi ökar med i i varje sling­ge­nom­gång. Med numbers[i] kan vi komma åt re­spek­ti­ve element i arrayen och mata ut det.

Detta är re­sul­ta­tet:

1
2
3
4
5