Inom programmeringsspråket JavaScript finns det flera parenteser som används för olika saker. Det är alltid viktigt att avsluta varje öppningsparentes med sin motsvarande avslutningsparentes.

Klammerparenteser/måsvingar {}

Måsvingar används på olika platser för att visa vilka rader kod hör tillsammans som ett block. Till exempel inom ett om-sats används dom för att visa vilka rader kod ska utföras när villkoret är sant eller falskt. I blockläget visas detta som klämmor som kan innehålla andra block.

if (a == 1)
{
    // Detta utförs om det är sant
    // Denna raden tillhör samma block
}
else
{
    // Här är ett annat block av kod
    // Detta utförs när det är falskt
}

Liknande händer med loopar som while och for, där måsvingar används för att visa vilka rader ska loopas igenom.

while(a == 1)
{
    // Gör något flera gånger
    // Flera rader
}

for(let i = 0; i < 10; i++)
{
    // Dessa rader kommer köras 10 gånger
    // Här kan du ha hur många rader som behövs
}

Nästlade parenteser

Det är viktigt att hålla reda på var parenteser öppnas och stängs, för att detta bestämmer hur koden ska utföras. Det går bra att ha ett par parenteser inom ett yttre par parenteser, så länge att den inre stängs innan den yttre. Detta kallas för nästlade parenteser (”nested” på engelska). Till exempel kan man ha en for loop inom en yttre for loop. Följande koden går förbi alla pixlar med hjälp av en yttre loop som ändrar x-koordinaten, och en inre loop som ändrar y-koordinaten. Vad förändras om det skulle vara tvärt om? Testa själv!

basic.forever(() => {
    for (let x = 0; x <= 4; x++) {
        for (let y = 0; y <= 4; y++) {
            led.toggle(x, y)
            basic.pause(100)
        }
    }
})

Länk till koden.

Vanliga parenteser ()

Vanliga parenteser används på olika sätt, och kan betyda olika saker. Den enklaste är inom beräkningar, där dom används på samma sätt som i matematik för att ändra i vilken ordning beräkningen utförs. Till exempel:

let a = 4 * 3 + 2
let b = 4 * ( 3 + 2 )
// a innehåller värdet 14
// b innehåller värdet 20

Nästa användning är vid funktioner. En funktion definieras, och sen används med hjälp av sitt namn och ett par vanliga parenteser. Inom parenteser är platsen där värden eller variabler som används som input till funktionen skrivs. Om en funktion inte använder sig av sådan input finns ändå parenteser paret kvar.

Här är en definition av en funktion som heter tändSlumpmässigLed och inte förväntar sig få input. Den kommer att slumpmässigt tända en LED lampa.

funktion tändSlumpmässigLed() {
    led.plot(Math.random(4), Math.random(4))
}

För att använda denna funktion skriver man:

tändSlumpmässigLed()

Här är ett exempel av en funktion som behöver två parametrar (”input som funktionen förväntar”) för att kunna användas; bredd och höjd.

function räknaOmkrets(bredd: number, höjd: number) {
    basic.showNumber(2 * bredd + 2 * höjd)
}

När denna funktion används ger man två värden till den inom sina parenteser.

räknaOmkrets(4, 5)
// detta skulle visa 18 på skärmen

Pilfunktion ()=>{}

Kombinationen ()=>{} ser vi bland annat inom basic.forever(). Kort sammanfattad skapas en funktion som inte har ett namn (anonymous function), vilket sen ges som input till basic.forever(). Pildelen()=> (arrow function) ser till att variabler skickas vidare på rätt sätt. (Om du vill dyka in djupare kan du läsa mer här.)

basic.forever(() => {
    // skriv kod här
})

Hakparenteser []

Hakparenteser används på flera sätt till listor (arrays). En lista (array) är en variabel som kan innehålla flera värden (av samma typ) samtidigt.

Till exempel kan vi skapa en lista (antalGodis) som innehåller tre värden. För att skapa lista används hakparenteser. Sen för att läsa ut det första värdet, med index 0, används också hakparenteser.

let antalGodis = [4, 7, 2];
basic.showNumber(antalGodis[0]) // visar 4 på skärmen

Länk till koden.