Array-metoder

Arrays har innebygde metoder, funksjoner som hører til arrayen og lar deg gjøre ting med den. Du kaller en metode med punktum: tall.push(4) ber arrayen tall om å utføre handlingen push.

Jeg vil ...

Legge til med push()

.push() legger til en eller flere verdier på slutten av arrayen. Arrayen vokser.

tall = [1, 2, 3]
tall.append(4)
print(tall)        # [1, 2, 3, 4]
print(len(tall))   # 4

var tall = [1, 2, 3]
tall.append(4)
print(tall)         # [1, 2, 3, 4]
print(tall.size())  # 4

let tall = [1, 2, 3];
tall.push(4);
console.log(tall);          // [1, 2, 3, 4]
console.log(tall.length);   // 4

Du kan også legge til flere verdier på én gang:

tall.extend([5, 6])
print(tall)   # [1, 2, 3, 4, 5, 6]

tall.append_array([5, 6])
print(tall)   # [1, 2, 3, 4, 5, 6]

tall.push(5, 6);
console.log(tall);   // [1, 2, 3, 4, 5, 6]

Fjerne med pop()

.pop() fjerner den siste verdien i arrayen. Men den gjør også noe annet: den returnerer verdien som ble fjernet.

farger = ['rød', 'grønn', 'blå']
siste = farger.pop()
print(siste)    # blå
print(farger)   # ['rød', 'grønn']

var farger = ['rød', 'grønn', 'blå']
var siste = farger.pop_back()
print(siste)    # blå
print(farger)   # ['rød', 'grønn']

let farger = ['rød', 'grønn', 'blå'];
let siste = farger.pop();
console.log(siste);    // 'blå'
console.log(farger);   // ['rød', 'grønn']

Selv om du ikke tar vare på returverdien, returnerer .pop() den likevel. Verdien bare kastes.

Se push og pop i aksjon

Filtrere arrays med filter()

Noen ganger trenger du ikke hele arrayen, bare de verdiene som oppfyller en bestemt betingelse. Da bruker du .filter().

.filter() går gjennom hvert element, sjekker det mot en betingelse, og returnerer en ny array med bare de elementene som bestod.

tall = [3, 8, 1, 12, 5, 9]
store = [t for t in tall if t > 6]
print(store)   # [8, 12, 9]
print(tall)    # [3, 8, 1, 12, 5, 9]  (uendret!)

var tall = [3, 8, 1, 12, 5, 9]
var store = tall.filter(func(t): return t > 6)
print(store)   # [8, 12, 9]
print(tall)    # [3, 8, 1, 12, 5, 9]  (uendret!)

let tall = [3, 8, 1, 12, 5, 9];
let store = tall.filter(t => t > 6);
console.log(store);   // [8, 12, 9]
console.log(tall);    // [3, 8, 1, 12, 5, 9]  (uendret!)

Legg merke til at tall ikke endres. .filter() lager en helt ny array. Originalen er trygg.

Lese filter-uttrykket

let store = tall.filter(t => t > 6);

Steg for steg:

1. tall.filter(...) gå gjennom hvert element i tall
2. t => t > 6 for hvert element t, sjekk: er t større enn 6?
3. Hvis ja → ta med i den nye arrayen
4. Hvis nei → hopp over

Gjøre om verdier med map()

Noen ganger vil du ikke plukke ut elementer, men gjøre noe med hvert element og få en ny array tilbake. Da bruker du .map().

.map() går gjennom hvert element, kjører en funksjon på det, og returnerer en ny array med resultatene. Lengden er alltid den samme som originalen.

tall = [1, 2, 3, 4]
doble = [t * 2 for t in tall]
print(doble)   # [2, 4, 6, 8]
print(tall)    # [1, 2, 3, 4]  (uendret!)

var tall = [1, 2, 3, 4]
var doble = tall.map(func(t): return t * 2)
print(doble)   # [2, 4, 6, 8]
print(tall)    # [1, 2, 3, 4]  (uendret!)

let tall = [1, 2, 3, 4];
let doble = tall.map(t => t * 2);
console.log(doble);   // [2, 4, 6, 8]
console.log(tall);    // [1, 2, 3, 4]  (uendret!)

Akkurat som .filter() lager .map() en helt ny array. Originalen røres ikke.

Lese map-uttrykket

let doble = tall.map(t => t * 2);

Steg for steg:

1. tall.map(...) gå gjennom hvert element i tall
2. t => t * 2 for hvert element t, regn ut t * 2
3. Legg resultatet inn i den nye arrayen

Forskjellen: endre vs. lage ny

Det er viktig å forstå forskjellen mellom metoder som endrer arrayen og metoder som lager en ny array:

Denne forskjellen blir viktigere jo mer komplisert koden din blir. Når du bruker .filter(), vet du at originaldataene alltid er trygge.