JavaScript-nummer

Innehållsförteckning

    Visa innehållsförteckning

JavaScript har bara en typ av nummer. Tal kan skrivas med eller utan decimaler.

Exempel

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

Försök Dig själv »

Extra stora eller extra små tal kan skrivas med vetenskaplig (exponent) notation:

Exempel

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

Försök Dig själv »

JavaScript-nummer är alltid 64-bitars flytande punkt

Till skillnad från många andra programmeringsspråk, JavaScript definierar inte olika typer av tal, som heltal, korta, långa, flyttal osv.

JavaScript-nummer lagras alltid som flyttal med dubbel precision nummer, enligt den internationella IEEE 754-standarden.

Detta format lagrar tal i 64 bitar, där talet (bråkdelen) lagras i bitar 0 till 51, exponenten i bitarna 52 till 62 och tecknet i bit 63:

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

Heltalsprecision

Heltal (tal utan punkt eller exponentnotation) är korrekta upp till 15 siffror.

Exempel

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

Prova själv →

<!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 maximala antalet decimaler är 17.

Flytande precision

Flyttalaritmetiken är inte alltid 100 % korrekt:

let x = 0.2 + 0.1;

Försök Dig själv »

För att lösa problemet ovan hjälper det att multiplicera och dividera:

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

Prova själv →

<!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>

Lägga till siffror och strängar

VARNING!!

JavaScript använder operatorn + för både addition och sammanlänkning.

Siffror läggs till. Strängar är sammanlänkade.

Om du lägger till två siffror blir resultatet ett tal:

Exempel

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

Prova själv →

<!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>

Om du lägger till två strängar blir resultatet en strängsammansättning:

Exempel

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

Prova själv →

<!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>

Om du lägger till ett nummer och en sträng blir resultatet en strängsammansättning:

Exempel

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

Prova själv →

<!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>

Om du lägger till en sträng och ett nummer blir resultatet en strängsammansättning:

Exempel

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

Prova själv →

<!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>

Ett vanligt misstag är att förvänta sig att resultatet blir 30:

Exempel

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

Prova själv →

<!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>

Ett vanligt misstag är att förvänta sig att resultatet blir 102030:

Exempel

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

Prova själv →

<!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-tolken fungerar från vänster till höger.

Första 10 + 20 läggs till eftersom x och y båda är tal.

Sedan är 30 + "30" sammanlänkade eftersom z är en sträng.

Numeriska strängar

JavaScript-strängar kan ha numeriskt innehåll:

let x = 100;         // x is a number

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

JavaScript kommer att försöka konvertera strängar till tal i alla numeriska operationer:

Detta kommer att fungera:

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

Prova själv →

<!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>

Detta kommer också att fungera:

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

Prova själv →

<!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>

Och det här kommer att fungera:

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

Prova själv →

<!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 detta kommer inte att fungera:

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

Prova själv →

<!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 sista exemplet använder JavaScript operatorn + för att sammanfoga strängarna.

NaN - Inte ett nummer

NaN är ett reserverat JavaScript-ord som indikerar att ett nummer inte är ett lagligt nummer.

Att försöka göra aritmetik med en icke-numerisk sträng kommer att resultera i NaN (Inte en Siffra):

Exempel

let x = 100 / "Apple";

Prova själv →

<!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 om strängen är numerisk blir resultatet a siffra:

Exempel

let x = 100 / "10";

Prova själv →

<!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 använda den globala JavaScript-funktionen isNaN() för att ta reda på om ett värde inte är ett tal:

Exempel

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

Prova själv →

<!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>

Se upp för NaN. Om du använder NaN i en matematisk operation blir resultatet också NaN:

Exempel

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

Prova själv →

<!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 vara en sammanlänkning som NaN5:

Exempel

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

Prova själv →

<!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 är ett tal: typ av NaN returnerar nummer:

Exempel

typeof NaN;

Prova själv →

<!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>

Oändlighet

Infinity (eller -Infinity) är värdet JavaScript returnerar om du beräknar ett tal utanför det största möjligt antal.

Exempel

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

Division med 0 (noll) genererar också Infinity:

Exempel

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

Prova själv →

<!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 är ett tal: typeof Infinity returnerar nummer.

Exempel

typeof Infinity;

Prova själv →

<!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 tolkar numeriska konstanter som hexadecimala om de föregås av 0x.

Exempel

let x = 0xFF;

Prova själv →

<!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 ett tal med en inledande nolla (som 07).
Vissa JavaScript-versioner tolkar tal som oktala om de skrivs med en inledande nolla.

Som standard visar JavaScript siffror som bas 10 decimaler.

Men du kan använda metoden toString() för att mata ut tal från bas 2 till bas 36.

Hexadecimal är bas 16. Decimal är bas 10. Octal är bas 8. Binär är bas 2.

Exempel

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

Prova själv →

<!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-nummer som objekt

Normalt är JavaScript-nummer primitiva värden skapade från bokstavliga ord:

let x = 123;

Men siffror kan också definieras som objekt med nyckelordet new:

let y = new Number(123);

Exempel

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

Skapa inte Number-objekt.

Nyckelordet nya komplicerar koden och saktar ner körningshastigheten.

Antal objekt kan ge oväntade resultat:

När du använder operatorn == är x och y lika:

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

Prova själv →

<!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 använder operatorn === är x och y inte lika.

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

Prova själv →

<!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>

Observera skillnaden mellan (x==y) och (x===y).

(x == y) sant eller falskt?

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

Prova själv →

<!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) sant eller falskt?

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

Prova själv →

<!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>

Att jämföra två JavaScript-objekt returnerar alltid false.

Fyll i JavaScript-nummerreferens

För en fullständig nummerreferens, besök vår:

Fyll i JavaScript-nummerreferens.

Referensen innehåller beskrivningar och exempel på alla nummeregenskaper och metoder.