2. marts 2026

Grundlæggende operatorer, matematik

Vi kender mange operatorer fra skolen. De er ting som addition +, multiplikation *, subtraktion - og så videre.

I dette kapitel starter vi med simple operatorer og fokuserer derefter på JavaScript-specifikke aspekter, som ikke dækkes af skolearitmetik.

Termer: “unary (unær)”, “binær”, “operand”

Før vi går videre, lad os forstå nogle almindelige termer.

  • En operand – er hvad operatorer anvendes på. For eksempel, i multiplikationen 5 * 2 er der to operander: den venstre operand er 5 og den højre operand er 2. Nogle gange kalder folk disse “argumenter” i stedet for “operander”.

  • En operator er unary hvis den har en enkelt operand. For eksempel, den unære negation - vender fortegnet af et tal:

    let x = 1;
    
    x = -x;
    alert( x ); // -1, unary negation blev anvendt
  • En operator er binær hvis den har to operander. Den samme minus eksisterer også i binær form:

    let x = 1, y = 3;
    alert( y - x ); // 2, binær minus trækker værdier fra hinanden

    Formelt set, i eksemplerne ovenfor har vi to forskellige operatorer, der deler det samme symbol: negationsoperatoren, en unær operator der vender fortegnet, og subtraktionsoperatoren, en binær operator der trækker et tal fra et andet.

Matematik

Følgende matematiske operationer understøttes:

  • Addition +,
  • Subtraktion -,
  • Multiplikation *,
  • Division /,
  • Rest %,
  • Eksponentiering **.

De første fire er ligetil, mens % og ** kræver nogle få ord om dem.

Rest %

Rest-operatoren %, på trods af sit udseende, er ikke relateret til procenter.

Resultatet af a % b er resten af heltalsdivisionen af a med b.

For eksempel:

alert( 5 % 2 ); // 1, resten af 5 divideret med 2
alert( 8 % 3 ); // 2, resten af 8 divideret med 3
alert( 8 % 4 ); // 0, resten af 8 divideret med 4

Eksponentiering **

Eksponentieringsoperatoren a ** b hæver a til potensen b.

I skolematematik skriver vi det som ab.

For eksempel:

alert( 2 ** 2 ); // 2² = 4
alert( 2 ** 3 ); // 2³ = 8
alert( 2 ** 4 ); // 2⁴ = 16

Ligesom i matematik er eksponentieringsoperatoren også defineret for ikke-heltal.

For eksempel er en kvadratrod en eksponentiering med ½:

alert( 4 ** (1/2) ); // 2 (potens på 1/2 er det samme som en kvadratrod)
alert( 8 ** (1/3) ); // 2 (potens på 1/3 er det samme som en kubikrod)

String-sammenkædning med binær +

Lad os se på funktionerne i JavaScript-operatorer, der går ud over skolearitmetik.

Normalt summerer plus-operatoren + tal.

Men hvis den binære + anvendes på strenge, sammenkæder den dem:

let s = "min" + "streng";
alert(s); // minstreng

Bemærk, at hvis en af operanderne er en streng, så konverteres den anden også til en streng.

For eksempel:

alert( '1' + 2 ); // "12"
alert( 2 + '1' ); // "21"

Som du kan se, er det ligegyldigt, om den første operand er en streng eller den anden.

Her er et mere komplekst eksempel:

alert(2 + 2 + '1' ); // "41" og ikke "221"

Her arbejder operatorerne en efter en. Den første + summerer to tal, så den returnerer 4, derefter tilføjer den næste + strengen 1 til det, så det er som 4 + '1' = '41'.

alert('1' + 2 + 2); // "122" og ikke "14"

Her er den første operand en streng, så behandler compileren de andre to operander som strenge også. 2 bliver sammenkædet med '1', så det er som '1' + 2 = "12" og "12" + 2 = "122".

Den binære + er den eneste operator, der understøtter strenge på denne måde. Andre aritmetiske operatorer fungerer kun med tal og konverterer altid deres operander til tal.

Her er demoen for subtraktion og division:

alert( 6 - '2' ); // 4, konverterer '2' til et tal
alert( '6' / '2' ); // 3, konverterer begge operander til tal

Numerisk konvertering, unær +

Plusset + findes i to former: den binære form, som vi brugte ovenfor, og den i unary form.

Det unary plus eller, med andre ord, plusoperatoren + anvendt på en enkelt værdi, gør ikke noget ved tal. Men hvis operanden ikke er et tal, konverterer det unary plus det til et tal.

For eksempel:

// Ingen effekt på tal
let x = 1;
alert( +x ); // 1

let y = -2;
alert( +y ); // -2

// Konverterer ikke-tal
alert( +true ); // 1
alert( +"" );   // 0

Den gør faktisk det samme som Number(...), men er kortere.

Behovet for at konvertere strenge til tal opstår meget ofte. For eksempel, hvis vi får værdier fra HTML-formularfelter, er de normalt strenge. Hvad hvis vi vil summere dem?

Den binære plus ville tilføje dem som strenge:

let apples = "2";
let oranges = "3";

alert( apples + oranges ); // "23", den binære plus sammenkæder strenge

Hvis vi vil behandle dem som tal, skal vi konvertere og derefter summere dem:

let apples = "2";
let oranges = "3";

// begge værdier konverteret til tal før den binære plus
alert( +apples + +oranges ); // 5

// den længere variant
// alert( Number(apples) + Number(oranges) ); // 5

Fra en matematikers synspunkt kan overfloden af plusser virke mærkelig. Men fra en programmørens synspunkt er der ikke noget specielt: unary plusser anvendes først, de konverterer strenge til tal, og derefter summerer den binære plus dem.

Hvorfor anvendes unary plusser på værdier før de binære? Som vi skal se, er det på grund af deres højere præcedens.

Operator-præcedens

Hvis et udtryk har mere end én operator, defineres eksekveringsrækkefølgen af deres præcedens, eller med andre ord, den standard prioriteringsrækkefølge af operatorer.

Fra skolen ved vi alle, at multiplikationen i udtrykket 1 + 2 * 2 skal beregnes før additionen. Det er præcis det, præcedens handler om. Multiplikationen siges at have en højere præcedens end additionen.

Parenteser tilsidesætter enhver præcedens, så hvis vi ikke er tilfredse med standardrækkefølgen, kan vi bruge dem til at ændre den. For eksempel, skriv (1 + 2) * 2.

Der er mange operatorer i JavaScript. Hver operator har et tilsvarende præcedensnummer. Den med det højere nummer eksekveres først. Hvis præcedensen er den samme, er eksekveringsrækkefølgen fra venstre mod højre.

Her er et uddrag fra præcedenstabellen (du behøver ikke at huske dette, men bemærk at unary operatorer er højere end tilsvarende binære):

Præcedens Navn Tegn
… … …
14 unary plus +
14 unary negation -
13 eksponentiering **
12 multiplikation *
12 division /
11 addition +
11 subtraktion -
… … …
2 tildeling =
… … …

Som vi kan se, har “unary plus” en prioritet på 14, hvilket er højere end 11 for “addition” (binær plus). Derfor, i udtrykket "+apples + +oranges", arbejder unary plusser før additionen.

Tildeling

Bemærk, at en tildeling = også er en operator. Den er opført i præcedenstabellen med den meget lave prioritet 2.

Derfor, når vi tildeler en variabel, som x = 2 * 2 + 1, udføres beregningerne først, og derefter evalueres =, hvilket gemmer resultatet i x.

let x = 2 * 2 + 1;

alert( x ); // 5

Tildeling = returnerer en værdi

Det faktum, at = er en operator og ikke en “magisk” sprogkonstruktion, har en interessant implikation.

Alle operatorer i JavaScript returnerer en værdi. Det er indlysende for + og -, men også sandt for =.

Kaldet x = value skriver value ind i x og returnerer det derefter.

Her er et eksempel, der bruger en tildeling som en del af et mere komplekst udtryk:

let a = 1;
let b = 2;

let c = 3 - (a = b + 1);

alert( a ); // 3
alert( c ); // 0

I eksemplet ovenfor er resultatet af udtrykket (a = b + 1) den værdi, der blev tildelt a (det vil sige 3). Det bruges derefter til yderligere evalueringer.

Sjov kode, ikke? Vi bør forstå, hvordan det fungerer, fordi vi nogle gange ser det i JavaScript-biblioteker.

Men normalt skal du ikke skrive kode som denne. Sådanne tricks gør bestemt ikke koden klarere eller mere læsbar.

Sammenkædede tildelinger

En anden interessant funktion er muligheden for at sammenkæde tildelinger:

let a, b, c;

a = b = c = 2 + 2;

alert( a ); // 4
alert( b ); // 4
alert( c ); // 4

Sammenkædede tildelinger evalueres fra højre mod venstre. Først evalueres det højre udtryk 2 + 2 og tildeles derefter til variablerne til venstre: c, b og a. Til sidst deler alle variablerne en enkelt værdi.

For læsbarhedens skyld er det derfor ofte bedre at opdele sådan kode i flere linjer: