Logične vrednosti (Boolean)

Zelo pogosto pri programiranju potrebujemo podatkovni tip, ki ima lahko samo dve vrednosti, in ti dve vrednosti sta true (slo. Pravilno) in false (slo. Napačno). Zato ima JavaScript logični podatkovni tip (Boolean). S funkcijo Boolean() lahko ugotovimo, ali je izraz (ali spremenljivka) resničen ali ne. JavaScript izjave omogočajo primerjavo in preverjanje vrednosti z uporabo različnih operatorjev (==, ===, >, <). Z njimi lahko preverjamo enakost vrednosti, primerjamo števila in izvajamo pogojne stavke (if, else).

PRIMER

<!DOCTYPE html>
<html lang="sl">
<head>
    <meta charset="UTF-8">
    <title>JavaScript Boolean - Izjave in Objekti</title>
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    
    <style>
        .seznam li {
            margin-bottom: 10px;
            padding: 8px;
            list-style-type: circle;
        }
        
        body h2 {
            margin-top: 0;
            color: #fe5849;
        }  
        
        body h3 {
            margin-top: 0;
            color: #0066cc;
        }  
    </style>
</head>
<body>
    <h2>Primerjave in izjave (statements)</h2>
    <h3>Primerjave z različnimi operatorji</h3>
    
    <ol class="seznam">
        <li id="a"></li>
        <li id="b"></li>
        <li id="c"></li>
        <li id="d"></li>
        <li id="e"></li>
        <li id="f"></li>
    </ol>

    <h2>Logične vrednosti kot objekti</h2>
    <h3>Prikaz razlike med primitivno in objektno vrednostjo</h3>
    
    <ol class="seznam">
        <li id="g"></li>
        <li id="h"></li>
        <li id="i"></li>
    </ol>

    <script>
        // PRVI DEL: IZJAVE IN PRIMERJAVE
        // Definiramo osnovne številske vrednosti
        let a = 13;
        let b = 562;
        let c = 51;
    
        // Primerjave z različnimi operatorji
        document.getElementById("a").innerHTML =
            "Ali je število 13 enako številu 51: " + (a === c); // Uporaba === za strogo primerjavo
    
        document.getElementById("b").innerHTML =
            "Ali je število 562 večje od števila 51: " + (b > c);
    
        document.getElementById("c").innerHTML =
            "Ali je število 13 manjše od števila 562: " + (a < b);
    
        // Uporaba if-else stavkov za primerjave
        let stevka; // Deklaracija spremenljivke za shranjevanje rezultata
    
        // Prva primerjava
        if (c < a) {
            stevka = "Število 13 je manjše od števila 51.";
        } else {
            stevka = "Število 51 ni manjše od števila 13.";
        }
        document.getElementById("d").innerHTML = stevka;
    
        // Druga primerjava
        if (c > b) {
            stevka = "Število 562 je večje od števila 51.";
        } else {
            stevka = "Število 51 je manjše od števila 562.";
        }
        document.getElementById("e").innerHTML = stevka;
    
        // Tretja primerjava - samo if stavek
        if (b > c) {
            stevka = "Število 562 je večje od števila 51.";
        }
        document.getElementById("f").innerHTML = stevka;
    
        // DRUGI DEL: LOGIČNE VREDNOSTI KOT OBJEKTI
        // Primitivna logična vrednost
        let primitivniBoolean = false;
    
        // Boolean kot objekt (ni priporočljivo uporabljati)
        let objektniBoolean = Boolean(false);
    
        // Prikaz razlike med primitivno in objektno vrednostjo
        document.getElementById("g").innerHTML =
            "Tip primitivne vrednosti: " + typeof primitivniBoolean;
    
        document.getElementById("h").innerHTML =
            "Tip objektne vrednosti: " + typeof objektniBoolean;
    
        document.getElementById("i").innerHTML =
            "Primerjava vrednosti: " + (primitivniBoolean === objektniBoolean) +
            ", Primerjava s tipom: " + (primitivniBoolean === objektniBoolean);
    </script>
</body>
</html>

REZULTAT

Rezultat vsake primerjave je logična vrednost true ali false. Običajno so logične vrednosti JavaScript-a primitivne vrednosti, ustvarjene iz literalov. Logične vrednosti je mogoče definirati tudi kot objekte s ključno besedo new, vendar se uporaba objektnih logičnih vrednosti odsvetuje, saj lahko privede do nepričakovanih rezultatov pri primerjavi vrednosti.

Stvar	Opis	Sintaksa	Primer
Logične vrednosti
true	Logično resnično	`true`	`let x = true;`
false	Logično neresnično	`false`	`let x = false;`
Boolean()	Pretvori vrednost v boolean	`Boolean(vrednost)`	`Boolean(0); // false`
Falsy vrednosti (vrnejo false)
false, 0, -0, 0n	Številske ničle	`Boolean(0)`	`Boolean(0); // false`
""	Prazen niz	`Boolean("")`	`Boolean(""); // false`
null, undefined, NaN	Prazne ali neveljavne vrednosti	`Boolean(null)`	`Boolean(null); // false`
Truthy vrednosti (vrnejo true)
Karkoli drugega	Vse, kar ni falsy	`Boolean(vrednost)`	`Boolean("0"); // true`
{}, []	Prazni objekti in tabele	`Boolean({})`	`Boolean([]); // true`
Logični operatorji
&&	IN (obe morata biti true)	`a && b`	`true && false; // false`
\|\|	ALI (vsaj ena mora biti true)	`a \|\| b`	`true \|\| false; // true`
!	NE (obrne vrednost)	`!a`	`!true; // false`
!!	Dvojno NE (pretvori v boolean)	`!!a`	`!!"hello"; // true`
Primerjalni operatorji (vrnejo boolean)
===, !==	Strogo enako/neenako (tip + vrednost)	`a === b`	`5 === "5"; // false`
==, !=	Enako/neenako (s pretvorbo tipa)	`a == b`	`5 == "5"; // true`
> , < , >= , <=	Primerjava velikosti	`a > b`	`10 > 5; // true`
Metode Boolean objekta
constructor	Vrne funkcijo, ki je ustvarila logični prototip.	`obj.constructor`	▶ Primer kode
prototype	Omogoča dodajanje lastnosti in metod logičnemu prototipu.	`Boolean.prototype`	▶ Primer kode
toString()	Pretvori logično vrednost v niz.	`bool.toString()`	▶ Primer kode
valueOf()	Vrne osnovno primitivno vrednost.	`bool.valueOf()`	▶ Primer kode

Logične vrednosti (Boolean)

Vadnica.org

Povezave

Podpora