JavaScript-numre

Indholdsfortegnelse

JavaScript har kun én type nummer. Tal kan skrives med eller uden decimaler.

Eksempel

let x = 3.14;    // A number with decimals
let y = 3;       // A number without decimals

Prøv det Dig selv "

Ekstra store eller ekstra små tal kan skrives med videnskabelig (eksponent) notation:

Eksempel

let x = 123e5;    // 12300000
let y = 123e-5;   // 0.00123

Prøv det Dig selv "

JavaScript-numre er altid 64-bit flydende punkt

I modsætning til mange andre programmeringssprog, JavaScript definerer ikke forskellige typer tal, såsom heltal, korte, lange, flydende komma osv.

JavaScript-numre gemmes altid som flydende komma med dobbelt præcision numre efter den internationale IEEE 754-standard.

Dette format gemmer tal i 64 bit, hvor tallet (brøken) gemmes i bit 0 til 51, eksponenten i bit 52 til 62 og tegnet i bit 63:

Value (aka Fraction/Mantissa)	Exponent	Sign
52 bits (0 - 51)	11 bits (52 - 62)	1 bit (63)

Heltals præcision

Heltal (tal uden punktum eller eksponentnotation) er nøjagtige op til 15 cifre.

Eksempel

let x = 999999999999999;   // x will be 999999999999999
let y = 9999999999999999;  // y will be 10000000000000000

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h1>JavaScript Numbers</h1>
<h2>Integer Precision</h2>

<p>Integers (numbers without a period or exponent notation) are accurate up to 15 digits:</p>

<p id="demo"></p>

<script>
let x = 999999999999999;
let y = 9999999999999999;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>

</body>
</html>

Det maksimale antal decimaler er 17.

Flydende præcision

Flydende kommaaritmetik er ikke altid 100 % nøjagtig:

let x = 0.2 + 0.1;

Prøv det Dig selv "

For at løse problemet ovenfor hjælper det at gange og dividere:

let x = (0.2 * 10 + 0.1 * 10) / 10;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Floating point arithmetic is not always 100% accurate:</p>
<p id="demo1"></p>

<p>But it helps to multiply and divide:</p>

<p id="demo2"></p>

<script>
let x = 0.2 + 0.1;
document.getElementById("demo1").innerHTML = "0.2 + 0.1 = " + x;
let y = (0.2*10 + 0.1*10) / 10;
document.getElementById("demo2").innerHTML = "0.2 + 0.1 = " + y;
</script>

</body>
</html>

Tilføjelse af tal og strenge

ADVARSEL!!

JavaScript bruger operatoren + til både tilføjelse og sammenkædning.

Tal tilføjes. Strenge er sammenkædet.

Hvis du tilføjer to tal, vil resultatet være et tal:

Eksempel

let x = 10;
let y = 20;
let z = x + y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you add two numbers, the result will be a number:</p>

<p id="demo"></p>

<script>
let x = 10;
let y = 20;
let z = x + y;
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Hvis du tilføjer to strenge, vil resultatet være en strengsammenkædning:

Eksempel

let x = "10";
let y = "20";
let z = x + y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you add two numeric strings, the result will be a concatenated string:</p>

<p id="demo"></p>

<script>
let x = "10";
let y = "20";
let z = x + y;
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Hvis du tilføjer et tal og en streng, vil resultatet være en strengsammenkædning:

Eksempel

let x = 10;
let y = "20";
let z = x + y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you add a number and a numeric string, the result will be a concatenated string:</p>

<p id="demo"></p>

<script>
let x = 10;
let y = "20";
let z = x + y;
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Hvis du tilføjer en streng og et tal, vil resultatet være en strengsammenkædning:

Eksempel

let x = "10";
let y = 20;
let z = x + y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you add a numeric string and a number, the result will be a concatenated string:</p>

<p id="demo"></p>

<script>
let x = "10";
let y = 20;
document.getElementById("demo").innerHTML = "The result is: " + x + y;
</script>

</body>
</html>

En almindelig fejl er at forvente, at dette resultat er 30:

Eksempel

let x = 10;
let y = 20;
let z = "The result is: " + x + y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>A common mistake is to expect this result to be 30:</p>

<p id="demo"></p>

<script>
var x = 10;
var y = 20;
document.getElementById("demo").innerHTML =
"The result is: " + x + y;
</script>

</body>
</html>

En almindelig fejl er at forvente, at dette resultat er 102030:

Eksempel

let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>A common mistake is to expect this result to be 102030:</p>

<p id="demo"></p>

<script>
let x = 10;
let y = 20;
let z = "30";
let result = x + y + z;
document.getElementById("demo").innerHTML = result;
</script>

</body>
</html>

JavaScript-fortolkeren arbejder fra venstre mod højre.

De første 10 + 20 tilføjes, fordi x og y begge er tal.

Så er 30 + "30" sammenkædet, fordi z er en streng.

Numeriske strenge

JavaScript-strenge kan have numerisk indhold:

let x = 100;         // x is a number

let y = "100";       // y is a 
string

JavaScript vil forsøge at konvertere strenge til tal i alle numeriske operationer:

Dette vil virke:

let x = "100";
let y = "10";
let z = x / y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript will try to convert strings to numbers when dividing:</p>

<p id="demo"></p>

<script>
let x = "100";
let y = "10";
let z = x / y;   
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Dette vil også fungere:

let x = "100";
let y = "10";
let z = x * y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript will try to convert strings to numbers when multiplying:</p>

<p id="demo"></p>

<script>
let x = "100";
let y = "10";
let z = x * y;   
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Og dette vil virke:

let x = "100";
let y = "10";
let z = x - y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript will try to convert strings to numbers when subtracting:</p>

<p id="demo"></p>

<script>
let x = "100";
let y = "10";
let z = x - y;   
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

Men dette vil ikke virke:

let x = "100";
let y = "10";
let z = x + y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript will NOT convert strings to numbers when adding:</p>

<p id="demo"></p>

<script>
let x = "100";
let y = "10";
let z = x + y;   
document.getElementById("demo").innerHTML = z;
</script>

</body>
</html>

I det sidste eksempel bruger JavaScript operatoren + til at sammenkæde strengene.

NaN - Ikke et tal

NaN er et JavaScript reserveret ord, der angiver, at et nummer ikke er et lovligt nummer.

At forsøge at lave regnestykker med en ikke-numerisk streng vil resultere i NaN (ikke en Nummer):

Eksempel

let x = 100 / "Apple";

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>A number divided by a non-numeric string becomes NaN (Not a Number):</p>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = 100 / "Apple";
</script>

</body>
</html>

Men hvis strengen er numerisk, vil resultatet være en nummer:

Eksempel

let x = 100 / "10";

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>A number divided by a numeric string becomes a number:</p>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = 100 / "10";
</script>

</body>
</html>

Du kan bruge den globale JavaScript-funktion isNaN() for at finde ud af, om en værdi ikke er et tal:

Eksempel

let x = 100 / "Apple";
isNaN(x);

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>You can use the global JavaScript function isNaN() to find out if a value is not a number:</p>

<p id="demo"></p>

<script>
let x = 100 / "Apple";
document.getElementById("demo").innerHTML = isNaN(x);
</script>

</body>
</html>

Pas på NaN. Hvis du bruger NaN i en matematisk operation, vil resultatet også være NaN:

Eksempel

let x = NaN;
let y = 5;
let z = x + y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you use NaN in a mathematical operation, the result will also be NaN:</p>

<p id="demo"></p>

<script>
let x = NaN;
let y = 5;
document.getElementById("demo").innerHTML = x + y;
</script>

</body>
</html>

Eller resultatet kan være en sammenkædning som NaN5:

Eksempel

let x = NaN;
let y = "5";
let z = x + y;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>If you use NaN in a mathematical operation, the result can be a concatenation:</p>

<p id="demo"></p>

<script>
let x = NaN;
let y = "5";
document.getElementById("demo").innerHTML = x + y;
</script>

</body>
</html>

NaN er et tal: typeof NaN returnerer tal:

Eksempel

typeof NaN;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>The typeof NaN is number:</p>

<p id="demo"></p>

<script>
let x = NaN;
document.getElementById("demo").innerHTML = typeof x;
</script>

</body>
</html>

Uendelighed

Infinity (eller -Infinity) er den værdi, JavaScript returnerer, hvis du beregner et tal uden for den største muligt antal.

Eksempel

let myNumber = 2;
// Execute until Infinity
while (myNumber != Infinity) {
    myNumber = myNumber * myNumber;
}

Division med 0 (nul) genererer også Infinity:

Eksempel

let x =  2 / 0;
let y = -2 / 0;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Division by zero generates Infinity;</p>

<p id="demo"></p>

<script>
let x = 2/0;
let y = -2/0;
document.getElementById("demo").innerHTML = x + "<br>" + y;
</script>

</body>
</html>

Infinity er et tal: typeof Infinity returnerer tal.

Eksempel

typeof Infinity;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Infinity is a number:</p>

<p id="demo"></p>

<script>
document.getElementById("demo").innerHTML = typeof Infinity;
</script>

</body>
</html>

Hexadecimal

JavaScript fortolker numeriske konstanter som hexadecimale, hvis de indledes med 0x.

Eksempel

let x = 0xFF;

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Numeric constants, preceded by 0x, are interpreted as hexadecimal:</p>

<p id="demo"></p>

<script>
let x = 0xFF;
document.getElementById("demo").innerHTML = "0xFF = " + x;
</script>

</body>
</html>

Skriv aldrig et tal med et indledende nul (som 07).
Nogle JavaScript-versioner fortolker tal som oktale, hvis de skrives med et indledende nul.

Som standard viser JavaScript tal som grundlag 10 decimaler.

Men du kan bruge metoden toString() til at udlæse tal fra grundlag 2 til basis 36.

Hexadecimal er grundlag 16. Decimal er grundtal 10. Oktal er basis 8. Binær er basis 2.

Eksempel

let myNumber = 32;
myNumber.toString(32);
myNumber.toString(16);
myNumber.toString(12);
myNumber.toString(10);
myNumber.toString(8);
myNumber.toString(2);

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>The toString() method can output numbers from base 2 to 36:</p>

<p id="demo"></p>

<script>
let myNumber = 32;
document.getElementById("demo").innerHTML =
"Decimal 32 = " + "<br><br>" + 

"Hexatrigesimal (base 36): " + myNumber.toString(36) + "<br>" +
"Duotrigesimal (base 32): " + myNumber.toString(32) + "<br>" +
"Hexadecimal (base 16): " + myNumber.toString(16) + "<br>" +
"Duodecimal (base 12): " + myNumber.toString(12) + "<br>" +
"Decimal (base 10): " + myNumber.toString(10) + "<br>" +
"Octal (base 8): " + myNumber.toString(8) + "<br>" +
"Binary (base 2): " + myNumber.toString(2);
</script>

</body>
</html>

JavaScript-numre som objekter

Normalt er JavaScript-numre primitive værdier skabt ud fra bogstaver:

let x = 123;

Men tal kan også defineres som objekter med søgeordet new:

let y = new Number(123);

Eksempel

let x = 123;
let y = new Number(123);

Opret ikke Number-objekter.

nye søgeordet komplicerer koden og sænker udførelseshastigheden.

Nummerobjekter kan give uventede resultater:

Når du bruger == operatoren, er x og y lige:

let x = 500;
let y = new Number(500);

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Numbers and Number objects cannot be safely compared:</p>

<p id="demo"></p>

<script>
// x is a number
let x = 500;

// y is an object
let y = new Number(500);
document.getElementById("demo").innerHTML = (x==y);
</script>

</body>
</html>

Når du bruger === operatoren, er x og y ikke ens.

let x = 500;
let y = new Number(500);

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>Numbers and Number objects cannot be safely compared:</p>

<p id="demo"></p>

<script>
// x is a number
let x = 500;

// y is an object
let y = new Number(500);

document.getElementById("demo").innerHTML = (x===y);
</script>

</body>
</html>

Bemærk forskellen mellem (x==y) og (x===y).

(x == y) sand eller falsk?

let x = new Number(500);
let y = new Number(500);

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript objects cannot be compared:</p>

<p id="demo"></p>

<script>
// x is an object
let x = new Number(500);

// y is an object
let y = new Number(500);

document.getElementById("demo").innerHTML = (x==y);
</script>

</body>
</html>

(x === y) sand eller falsk?

let x = new Number(500);
let y = new Number(500);

Prøv det selv →

<!DOCTYPE html>
<html>
<body>

<h2>JavaScript Numbers</h2>

<p>JavaScript objects cannot be compared:</p>

<p id="demo"></p>

<script>
// x is an object
let x = new Number(500);

// y is an object
let y = new Number(500);

document.getElementById("demo").innerHTML = (x===y);
</script>

</body>
</html>

Sammenligning af to JavaScript-objekter returnerer altid falsk.

Komplet JavaScript-nummerreference

For en komplet nummerreference, besøg vores:

Komplet JavaScript-nummerreference.

Referencen indeholder beskrivelser og eksempler på alle talegenskaber og metoder.