JavaScript számok

Tartalomjegyzék

    Tartalomjegyzék megjelenítése

A JavaScript csak egy típusú számot tartalmaz. A számok írhatók tizedesjegyekkel vagy anélkül.

Példa

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

Próbáld ki Saját magad "

Extra nagy vagy extra kis számok írhatók tudományos (exponens) jelöléssel:

Példa

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

Próbáld ki Saját magad "

A JavaScript számok mindig 64 bites lebegőpontosak

Sok más programozási nyelvtől eltérően, A JavaScript nem határoz meg különböző típusú számokat, például egész számokat, rövid, hosszú, lebegőpontos stb.

A JavaScript számokat mindig dupla pontosságú lebegőpontként tároljuk számok, a nemzetközi IEEE 754 szabvány szerint.

Ez a formátum 64 bitben tárolja a számokat, ahol a szám (a tört) 0 bitben van tárolva 51-ig, a kitevő az 52-62. bitben és az előjel a 63. bitben:

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

Egész pontosság

Az egész számok (pont vagy kitevő nélküli számok) 15 számjegyig pontosak.

Példa

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

Próbálja ki Ön is →

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

A tizedesjegyek maximális száma 17.

Lebegő pontosság

A lebegőpontos aritmetika nem mindig 100%-ban pontos:

let x = 0.2 + 0.1;

Próbáld ki Saját magad "

A fenti probléma megoldásához segít szorozni és osztani:

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

Próbálja ki Ön is →

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

Számok és karakterláncok hozzáadása

FIGYELEM !!

A JavaScript a + operátort használja az összeadáshoz és az összefűzéshez is.

A számok hozzáadódnak. A karakterláncok összefűzve vannak.

Ha két számot ad hozzá, az eredmény egy szám lesz:

Példa

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

Próbálja ki Ön is →

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

Ha két karakterláncot ad hozzá, az eredmény egy karakterlánc-összefűzés lesz:

Példa

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

Próbálja ki Ön is →

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

Ha hozzáad egy számot és egy karakterláncot, az eredmény egy karakterlánc-összefűzés lesz:

Példa

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

Próbálja ki Ön is →

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

Ha hozzáad egy karakterláncot és egy számot, akkor az eredmény egy karakterlánc-összefűzés lesz:

Példa

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

Próbálja ki Ön is →

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

Gyakori hiba, hogy ezt az eredményt 30-ra várjuk:

Példa

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

Próbálja ki Ön is →

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

Gyakori hiba, hogy ezt az eredményt 102030-ra várjuk:

Példa

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

Próbálja ki Ön is →

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

A JavaScript értelmező balról jobbra halad.

Először 10 + 20 kerül hozzáadásra, mert x és y is számok.

Ekkor a 30 + "30" összefűződik, mert z egy karakterlánc.

Numerikus karakterláncok

A JavaScript-karakterláncok numerikus tartalommal rendelkezhetnek:

let x = 100;         // x is a number

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

A JavaScript minden numerikus művelet során megpróbálja a karakterláncokat számokká alakítani:

Ez működni fog:

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

Próbálja ki Ön is →

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

Ez is működni fog:

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

Próbálja ki Ön is →

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

És ez működni fog:

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

Próbálja ki Ön is →

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

De ez nem fog menni:

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

Próbálja ki Ön is →

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

Az utolsó példában a JavaScript a + operátort használja a karakterláncok összefűzésére.

NaN - Nem szám

A NaN egy JavaScript által fenntartott szó, amely azt jelzi, hogy egy szám nem törvényes szám.

Ha nem numerikus karakterlánccal próbál számolni, az NaN (nem Szám):

Példa

let x = 100 / "Apple";

Próbálja ki Ön is →

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

Ha azonban a karakterlánc numerikus, az eredmény a szám:

Példa

let x = 100 / "10";

Próbálja ki Ön is →

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

Használhatja az isNaN() globális JavaScript-függvényt annak megállapításához, hogy egy érték nem szám-e:

Példa

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

Próbálja ki Ön is →

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

Ügyeljen a NaN-ra. Ha a NaN-t használja egy matematikai műveletben, az eredmény NaN is lesz:

Példa

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

Próbálja ki Ön is →

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

Vagy az eredmény egy összefűzés lehet, mint például a NaN5:

Példa

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

Próbálja ki Ön is →

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

A NaN egy szám: a NaN típusa a számot adja vissza >:

Példa

typeof NaN;

Próbálja ki Ön is →

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

végtelenség

A végtelen (vagy -végtelen) az az érték, amelyet a JavaScript ad vissza, ha a legnagyobbon kívül eső számot számít ki lehetséges szám.

Példa

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

A 0-val (nullával) való osztás a végtelent is generálja:

Példa

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

Próbálja ki Ön is →

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

A Végtelen egy szám: a végtelen típusa a számot adja vissza >.

Példa

typeof Infinity;

Próbálja ki Ön is →

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

Hexadecimális

A JavaScript a numerikus állandókat hexadecimálisként értelmezi, ha előttük van 0x.

Példa

let x = 0xFF;

Próbálja ki Ön is →

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

Soha ne írjon be egy számot kezdő nullával (például 07).
Egyes JavaScript-verziók értelmezik a számok oktálisak, ha kezdő nullával vannak felírva.

Alapértelmezés szerint a JavaScript a számokat alap 10 tizedesjegyként jeleníti meg.

De használhatja a toString() metódust számok kiadására a 2. alapból a 36-os alapra.

A hexadecimális a 16-os bázis. A tizedes a 10-es alapszám. Az oktális a 8-as bázis. A bináris a 2. bázis.

Példa

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

Próbálja ki Ön is →

<!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 számok mint objektumok

Általában a JavaScript számok primitív értékek, amelyeket literálokból hoztak létre:

let x = 123;

De a számok objektumként is meghatározhatók a new kulcsszóval:

let y = new Number(123);

Példa

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

Ne hozzon létre számobjektumokat.

A new kulcsszó bonyolítja a kódot és lelassítja a végrehajtási sebességet.

A számobjektumok váratlan eredményeket hozhatnak:

A == operátor használatakor x és y egyenlő:

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

Próbálja ki Ön is →

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

A === operátor használatakor x és y nem egyenlők.

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

Próbálja ki Ön is →

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

Vegye figyelembe a (x==y) és a (x===y) közötti különbséget.

(x == y) igaz vagy hamis?

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

Próbálja ki Ön is →

<!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) igaz vagy hamis?

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

Próbálja ki Ön is →

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

Két JavaScript objektum összehasonlítása mindig false értékkel tér vissza.

Teljes JavaScript számhivatkozás

A teljes számhivatkozásért látogassa meg oldalunkat:

Teljes JavaScript számhivatkozás.

A hivatkozás leírásokat és példákat tartalmaz az összes Number tulajdonságra és metódusra.