JavaScript Števila

Vadnica JavaScript Števila je praktičen vodnik, ki razvijalcem vseh ravni pomaga razumeti in uporabljati številčne funkcije ter metode v JavaScriptu. Pokriva osnovne tipe (Number, BigInt), aritmetične operacije, pretvorbe, natančnost plavajoče vejice, kontrolne metode (isNaN, isFinite) in pogoste pasti, kot so zaokroževanje in delo s časovnimi vrednostmi. Vsak koncept je podprt s kratkimi primeri, ki jih je mogoče preizkusiti neposredno v brskalniku, ter nasveti za optimizacijo in varno ravnanje s številkami v realnih aplikacijah.

PRIMER

<!DOCTYPE html>
<html lang="sl">
<head>
    <meta charset="UTF-8">
    <title>JavaScript Števila - Preprost primer</title>
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    <style>
        #izpis {
            padding: 15px;
            border: 1px solid #ccc;
            margin-top: 20px;
            font-family: monospace;
            white-space: pre-line;
        }
    </style>
</head>
<body>
    <h1>JavaScript Števila</h1>
    
    <div id="izpis">Nalaganje...</div>

    <script>
        // 1. Ustvarjanje števil
        let celo = 42;
        let decimalno = 3.14;
        let negativno = -10;

        // 2. Osnovne operacije
        let vsota = celo + decimalno;
        let razlika = celo - negativno;
        let produkt = celo * 2;
        let kolicnik = decimalno / 2;

        // 3. Prikaži rezultate
        let izpis = document.getElementById('izpis');
        izpis.innerHTML = "Vsota: " + vsota + "<br>";
        izpis.innerHTML += "Razlika: " + razlika + "<br>";
        izpis.innerHTML += "Produkt: " + produkt + "<br>";
        izpis.innerHTML += "Količnik: " + kolicnik + "<br>";

        // 4. Metode in lastnosti
        izpis.innerHTML += "Zaokroženo: " + Math.round(decimalno) + "<br>";
        izpis.innerHTML += "Naključno število: " + Math.random() + "<br>";
        izpis.innerHTML += "Kvadratni koren: " + Math.sqrt(celo) + "<br>";
        izpis.innerHTML += "Največje: " + Math.max(celo, decimalno, negativno) + "<br>";
        izpis.innerHTML += "Najmanjše: " + Math.min(celo, decimalno, negativno) + "<br>";

        // 5. Pretvorbe
        let izNiza = Number("123");
        let vNiz = String(celo);
        izpis.innerHTML += "Iz niza: " + (izNiza + 1) + "<br>";
        izpis.innerHTML += "V niz: " + vNiz + "<br>";
    </script>
</body>
</html>

REZULTAT

Kako JavaScript shranjuje števila

JavaScript uporablja enoten številski podatkovni tip za vsa števila. Ta števila lahko zapišemo kot cela števila ali decimalna števila.

let st1 = 13;, // Celo število
let st2 = 13.75;, // Decimalno število
let st3 = [1, 2, 3, 4, 5];, // Tabela števil

Za zapis zelo velikih ali zelo majhnih števil lahko uporabimo znanstveni (eksponentni) zapis.

let st1 = 1234e5;, // 123400000 (1234 * 10^5)
let st2 = 1234e-5;, // 0.01234 (1234 * 10^-5)

Za razliko od mnogih drugih programskih jezikov JavaScript ne pozna različnih številskih tipov (kot so integer, short, long, float). Vsa števila v JavaScriptu so shranjena kot števila s plavajočo vejico dvojne natančnosti po standardu IEEE 754. Ta format uporablja 64 bitov za zapis števila: 52 bitov za mantiso (številko), 11 bitov za eksponent in 1 bit za predznak.

let st1 = 999999999999999;, // 15 števk - še pravilno: 999999999999999
let st2 = 9999999999999999;, // 16 števk - netočno: 10000000000000000

Cela števila (števila brez decimalne pike ali eksponentnega zapisa) so natančno predstavljena do 15 števk. Pri večjem številu števk lahko pride do izgube natančnosti.

Ustvarjanje in lastnosti števil

Števila v JavaScriptu so vedno tipa Number in so zapisana v 64-bitnem formatu z float vrednostjo (IEEE 754). Lahko so cela, decimalna, negativna ali neskončna. Vsako število ima dostop do statičnih lastnosti (kot so MAX_VALUE, NaN) in metod za pretvorbo ter formatiranje.

Metode za delo s števili in Math objekt

Za delo s števili so na voljo različne metode, razdeljene v več kategorij:

Statične lastnosti in metode za preverjanje vrednosti (isFinite, isInteger, isNaN, isSafeInteger).
Pretvorbe niza v število (parseInt, parseFloat).
Metode za formatiranje izhoda (toFixed, toPrecision, toExponential, toLocaleString).
Matematične operacije preko objekta Math (zaokroževanje, naključna števila, potence, koreni).

Pregled metod in lastnosti za števila

Spodnja tabela prikazuje vse glavne lastnosti in metode objekta Number ter najpogosteje uporabljene funkcije objekta Math. Za vsako metodo so navedeni opis delovanja, sintaksa in konkreten primer kode.

Ime	Opis	Sintaksa	Primer
constructor	Vrne funkcijo, ki je ustvarila prototip objekta Number.	`številka.constructor`	`let c = (42).constructor; // function Number() { ... }`
prototype	Omogoča dodajanje lastnosti in metod objektu Number.	`Number.prototype`	`Number.prototype.novaMetoda = function() { ... };`
EPSILON	Najmanjša razlika med 1 in naslednjim številom z float vrednostjo.	`Number.EPSILON`	`console.log(Number.EPSILON); // 2.220446049250313e-16`
MAX_SAFE_INTEGER	Največje varno celo število v JavaScriptu (2^53 - 1).	`Number.MAX_SAFE_INTEGER`	`console.log(Number.MAX_SAFE_INTEGER); // 9007199254740991`
MIN_SAFE_INTEGER	Najmanjše varno celo število v JavaScriptu (-(2^53 - 1)).	`Number.MIN_SAFE_INTEGER`	`console.log(Number.MIN_SAFE_INTEGER); // -9007199254740991`
MAX_VALUE	Največje pozitivno število, ki ga lahko predstavi JavaScript.	`Number.MAX_VALUE`	`console.log(Number.MAX_VALUE); // 1.7976931348623157e+308`
MIN_VALUE	Najmanjše pozitivno število (bližje 0 kot katerokoli drugo).	`Number.MIN_VALUE`	`console.log(Number.MIN_VALUE); // 5e-324`
NaN	"Not a Number" - vrednost, ki predstavlja neveljavno številsko vrednost.	`Number.NaN`	`console.log(Number.NaN); // NaN`
NEGATIVE_INFINITY	Negativna neskončnost.	`Number.NEGATIVE_INFINITY`	`console.log(Number.NEGATIVE_INFINITY); // -Infinity`
POSITIVE_INFINITY	Pozitivna neskončnost.	`Number.POSITIVE_INFINITY`	`console.log(Number.POSITIVE_INFINITY); // Infinity`
isFinite()	Vrne `true`, če je vrednost končno število.	`Number.isFinite(vrednost)`	`Number.isFinite(42); // true`
isInteger()	Vrne `true`, če je vrednost celo število.	`Number.isInteger(vrednost)`	`Number.isInteger(42); // true`
isNaN()	Vrne `true`, če je vrednost NaN (strožja od globalnega isNaN).	`Number.isNaN(vrednost)`	`Number.isNaN(NaN); // true`
isSafeInteger()	Vrne `true`, če je vrednost varno celo število.	`Number.isSafeInteger(vrednost)`	`Number.isSafeInteger(9007199254740991); // true`
parseFloat()	Razčleni niz in vrne decimalno število.	`Number.parseFloat(niz)`	`Number.parseFloat("3.14px"); // 3.14`
parseInt()	Razčleni niz in vrne celo število.	`Number.parseInt(niz, osnova)`	`Number.parseInt("42px"); // 42`
toExponential()	Vrne število v eksponentnem zapisu.	`številka.toExponential(decimalka)`	`(3.14).toExponential(2); // "3.14e+0"`
toFixed()	Vrne število z določenim številom decimalk.	`številka.toFixed(decimalka)`	`(3.14159).toFixed(2); // "3.14"`
toLocaleString()	Vrne število v lokalnem formatu (npr. 1.000,00 za Slovenijo).	`številka.toLocaleString(locale)`	`(1234567.89).toLocaleString('sl-SI'); // "1.234.567,89"`
toPrecision()	Vrne število z določeno natančnostjo (skupno število števk).	`številka.toPrecision(natančnost)`	`(123.456).toPrecision(4); // "123.5"`
toString()	Vrne število kot niz (podpira osnovo/radix).	`številka.toString(osnova)`	`(42).toString(16); // "2a" (hexadecimalno)`
valueOf()	Vrne osnovno vrednost števila.	`številka.valueOf()`	`(42).valueOf(); // 42`
Math.PI	Vrednost π (pi).	`Math.PI`	`console.log(Math.PI); // 3.141592653589793`
Math.random()	Vrne naključno število med 0 (vključno) in 1 (izključno).	`Math.random()`	`let nakljucno = Math.random(); // 0.123456`
Math.round()	Zaokroži število na najbližje celo število.	`Math.round(številka)`	`Math.round(3.6); // 4`
Math.floor()	Zaokroži navzdol (na manjše celo število).	`Math.floor(številka)`	`Math.floor(3.9); // 3`
Math.ceil()	Zaokroži navzgor (na večje celo število).	`Math.ceil(številka)`	`Math.ceil(3.1); // 4`
Math.abs()	Vrne absolutno vrednost števila.	`Math.abs(številka)`	`Math.abs(-42); // 42`
Math.pow()	Vrne število na določeno potenco.	`Math.pow(baza, eksponent)`	`Math.pow(2, 3); // 8`
Math.sqrt()	Vrne kvadratni koren števila.	`Math.sqrt(številka)`	`Math.sqrt(16); // 4`
Math.max()	Vrne največje število iz podanih argumentov.	`Math.max(številka1, številka2, ...)`	`Math.max(10, 20, 5); // 20`
Math.min()	Vrne najmanjše število iz podanih argumentov.	`Math.min(številka1, številka2, ...)`	`Math.min(10, 20, 5); // 5`
Math.trunc()	Odstrani decimalni del števila (vrne celo število).	`Math.trunc(številka)`	`Math.trunc(3.9); // 3`

REZULTAT

JavaScript Števila

Kako JavaScript shranjuje števila

Ustvarjanje in lastnosti števil

Metode za delo s števili in Math objekt

Pregled metod in lastnosti za števila

Vadnica.org

Povezave

Podpora