JavaScrip Nizi

Nizi (Strings) se uporabljajo za predstavitev in obdelavo zaporedja znakov, so uporabni za shranjevanje podatkov, ki jih je mogoče predstaviti v besedilni obliki. Nekatere najpogostejše uporabljene operacije na nizih so preverjanje njihove dolžine, njihova izdelava in povezovanje z nizovnima operaterjema + in +=, preverjanje obstoja ali lokacije podnizov (Substrings) z metodo indexOf() ali abstrahiranjem podnizov (Substrings) z metodo substring().

PRIMER

<!DOCTYPE html>
<html lang="sl">
<head>
    <meta charset="UTF-8">
    <title>Preprost primer nizov</title>
    <meta name="viewport" content="width=device-width, initial-scale=1, maximum-scale=1">
    
    <style>
        .znak {
            color: #2196F3;
            font-weight: bold;
            font-size: 1.1em;
        }
        .info {
            font-size: 0.9em;
            margin-top: 5px;
        }
        .output {
            border: 1px solid #ddd;
            padding: 10px;
            margin: 10px 0;
            border-radius: 4px;
            font-family: monospace;
        }
    </style>
</head>
<body>
    <div class="result-container">
        <p id="c"></p>
        <p class="info">* Uporabljena je charAt() metoda za dostop do posameznih znakov</p>
        
        <div id="rezultati" class="output"></div>
    </div>
    
    <p id="txt"></p>
    
    <script>
        const stavek = "Dobrodošli v JavaScript vadnici!";
        const znak1 = stavek.charAt(13); // dobi znak "J"
        const znak2 = stavek.charAt(17); // dobi znak "c"
        const znak3 = stavek.charAt(stavek.length-1); // dobi zadnji znak "!"
    
        document.getElementById("c").innerHTML = 
            "Prvi znak (indeks 13): <span class='znak'>" + znak1 + "</span><br>" +
            "Drugi znak (indeks 17): <span class='znak'>" + znak2 + "</span><br>" +
            "Zadnji znak (indeks " + (stavek.length-1) + "): <span class='znak'>" + znak3 + "</span>";
        
        // Različni načini definiranja nizov
        let ime = "Janez"; // Z dvojnimi narekovaji
        let priimek = 'Novak'; // Z enojnimi narekovaji
        let pozdrav = `Pozdravljeni`; // Z ležečimi narekovaji (backticks)

        // Združevanje nizov
        let polnoIme = ime + " " + priimek; // Klasično združevanje
        let sporocilo = `${pozdrav}, ${ime}!`; // Uporaba predloge niza (template literal)

        // Delo z nizi
        let dolzinaImena = ime.length; // Število znakov v nizu
        let velikeTiskanke = ime.toUpperCase(); // Pretvorba v velike črke
        let maleTiskanke = priimek.toLowerCase(); // Pretvorba v male črke

        // Iskanje in izločanje
        let besedilo = "Slovenija je prelepa država";
        let vsebuje = besedilo.includes("prelepa"); // Preveri, če niz vsebuje besedo
        let del = besedilo.substring(0, 9); // Izreže "Slovenija"
        let pozicija = besedilo.indexOf("je"); // Najde položaj besede "je"
        
        // Prikaz rezultatov
        let rezultati = document.getElementById("rezultati");
        rezultati.innerHTML = `
            <strong>Polno ime:</strong> ${polnoIme}<br>
            <strong>Pozdravno sporočilo:</strong> ${sporocilo}<br>
            <strong>Dolžina imena:</strong> ${dolzinaImena}<br>
            <strong>Velike črke:</strong> ${velikeTiskanke}<br>
            <strong>Male črke:</strong> ${maleTiskanke}<br>
            <strong>Ali vsebuje 'prelepa'?</strong> ${vsebuje}<br>
            <strong>Del besedila:</strong> ${del}<br>
            <strong>Pozicija besede 'je':</strong> ${pozicija}
        `;
    </script>
</body>
</html>

REZULTAT

Nize je mogoče ustvariti kot primitivne, iz nizovnih literalov ali kot objekte z uporabo konstruktorja String(). Primitivni nizi in objekti imajo veliko skupnega vedenja, vendar imajo druge pomembne razlike in opozorila. Nizovne (ang. String) literale je mogoče določiti z uporabo enojnih ali dvojnih narekovajev, ki se obravnavajo enako, ali z uporabo povratnega znaka.

Do posameznega znaka v nizu (ang. String) lahko dostopamo na dva načina. Prvi način je z metodo charAt() in drugi, da niz (ang. String) obravnavamo kot objekt, podoben tabeli (Array), kjer posamezni znaki ustrezajo številskemu indeksu.

const niz = "Banana"[1]; // vrne vrednost a iz besede Banana

Pri uporabi oglatih oklepajev ([]) za dostop do posameznih znakov poskus brisanja ali dodelitve vrednosti tem lastnostim ne bo uspel. Vključenih lastnosti ni mogoče niti zapisovati, niti konfigurirati. Znotraj niza lahko uporabimo narekovaje, če se ne ujemajo z narekovaji, ki obdajajo niz.

'Uporaba "dvojnega" narekovaja v "nizu", ki je obdan z enojnimi narekovaji.'
"Uporaba 'enojnega' narekovaja v 'nizu', ki je obdan z dvojnimi narekovaji."

Ubežni znaki

V JavaScript nizih (ang. Strings) ne moremo uporabljati enakih narekovajev znotraj niza, kot je niz obdan, obstaja pa rešitev te težave z uporabo ubežnega znaka. Ubežni znak je znak s poševnico nazaj (\) skupaj z narekovajem.

Znak	Rezultat	Opis
\'	'	Enojni narekovaj
\"	"	Dvojni narekovaj
\\	\	Poševnica nazaj (Backslash)
\b	\b	Vračalka (Backspace)
\f	\f	Podatek obrazca
\n	\n	Nova vrstica
\r	\r	Vrnitev kazalca (Carriage return)
\t	\t	Vodoravni tabulator
\v	\v	Navpični tabulator
\0	\0	Ničelni znak (Null character)
\xXX	\x41	Šestnajstiški zapis znaka (XX je šestnajstiška vrednost, primer: \x41 prikaže "A")
\uXXXX	\u0041	Unicode zapis znaka (XXXX je šestnajstiška vrednost, primer: \u0041 prikaže "A")

Ustvarjanje in osnovne lastnosti nizov

Nize je mogoče ustvariti kot primitivne vrednosti (literale) ali kot objekte. Primitivni nizi so hitrejši in se uporabljajo v večini primerov. Vsak niz ima lastnost length, ki vrača število znakov, ter številne metode za iskanje, spreminjanje in obdelavo besedila.

Metode za obdelavo nizov

Za delo z nizovi v JavaScriptu so na voljo različne metode, razdeljene v več kategorij:

Iskanje in indeksiranje znakov/podnizov (indexOf, includes, search).
Izrekanje in deljenje nizov (slice, substring, substr, split).
Spreminjanje velikosti pisave in formatiranje (toUpperCase, toLowerCase, trim, padStart).
Zamenjava in ponavljanje (replace, repeat).
Konkatenacija in pretvorbe (concat, toString, charAt, charCodeAt).

Pregled metod za nize (Strings)

Spodnja tabela prikazuje vse glavne metode in lastnosti objektov String v JavaScriptu. Za vsako metodo so navedeni opis delovanja, sintaksa in konkreten primer kode.

Ime	Opis	Sintaksa	Primer
length	Vrne število znakov v nizu.	`niz.length`	`let dolzina = "Banana".length; // 6`
indexOf()	Vrne indeks prvega pojavljanja podniza (-1, če ne najde).	`niz.indexOf("podniz", začetniIndeks)`	`"Banana".indexOf("na"); // 2`
lastIndexOf()	Vrne indeks zadnjega pojavljanja podniza.	`niz.lastIndexOf("podniz")`	`"Banana".lastIndexOf("na"); // 4`
includes()	Vrne `true`, če niz vsebuje podniz, sicer `false`.	`niz.includes("podniz")`	`"Banana".includes("na"); // true`
startsWith()	Vrne `true`, če niz začne s podnizom.	`niz.startsWith("podniz")`	`"Banana".startsWith("Ba"); // true`
endsWith()	Vrne `true`, če niz konča s podnizom.	`niz.endsWith("podniz")`	`"Banana".endsWith("na"); // true`
search()	Vrne indeks prvega pojavljanja (podpira regularne izraze).	`niz.search(regularniIzraz)`	`"Banana".search(/a/i); // 1`
match()	Vrne array ujemanj (podpira regularne izraze).	`niz.match(regularniIzraz)`	`"Banana".match(/a/g); // ["a", "a", "a"]`
slice()	Izreže del niza (podpira negativne indekse).	`niz.slice(zacetek, konec)`	`"Banana".slice(1, 4); // "ana"`
substring()	Izreže del niza (ne podpira negativnih indeksov).	`niz.substring(zacetek, konec)`	`"Banana".substring(1, 4); // "ana"`
substr()	Izreže del niza (začetek in dolžina) – opuščeno.	`niz.substr(zacetek, dolzina)`	`"Banana".substr(1, 3); // "ana"`
split()	Pretvori niz v array, ločen z določenim ločilom.	`niz.split("ločilo")`	`"a,b,c".split(","); // ["a", "b", "c"]`
toUpperCase()	Vrne niz v velikih črkah.	`niz.toUpperCase()`	`"banana".toUpperCase(); // "BANANA"`
toLowerCase()	Vrne niz v malih črkah.	`niz.toLowerCase()`	`"BANANA".toLowerCase(); // "banana"`
trim()	Odstrani presledke na začetku in koncu niza.	`niz.trim()`	`" banana ".trim(); // "banana"`
trimStart()	Odstrani presledke na začetku niza.	`niz.trimStart()`	`" banana".trimStart(); // "banana"`
trimEnd()	Odstrani presledke na koncu niza.	`niz.trimEnd()`	`"banana ".trimEnd(); // "banana"`
padStart()	Doda znake na začetek niza do določene dolžine.	`niz.padStart(dolzina, znak)`	`"5".padStart(3, "0"); // "005"`
padEnd()	Doda znake na konec niza do določene dolžine.	`niz.padEnd(dolzina, znak)`	`"5".padEnd(3, "0"); // "500"`
replace()	Zamenja prvi pojavljeni podniz (podpira regex).	`niz.replace(stari, novi)`	`"Banana".replace("B", "b"); // "banana"`
replaceAll()	Zamenja vse pojave podniza (podpira regex).	`niz.replaceAll(stari, novi)`	`"Banana".replaceAll("a", "A"); // "BAnAnA"`
repeat()	Ponovi niz določen število krat.	`niz.repeat(število)`	`"Ha".repeat(3); // "HaHaHa"`
charAt()	Vrne znak na določenem indeksu.	`niz.charAt(indeks)`	`"Banana".charAt(1); // "a"`
charCodeAt()	Vrne Unicode vrednost znaka na določenem indeksu.	`niz.charCodeAt(indeks)`	`"Banana".charCodeAt(1); // 97`
[indeks]	Dostop do znaka z oglatimi oklepaji (kot pri arrayju).	`niz[indeks]`	`"Banana"[1]; // "a"`
concat()	Poveže dva ali več nizov (manj uporabljeno od +).	`niz.concat(niz2, niz3)`	`"B".concat("anana"); // "Banana"`
toString()	Vrne vrednost kot niz (privzeto za objekte String).	`niz.toString()`	`String(123).toString(); // "123"`
valueOf()	Vrne osnovno vrednost niza.	`niz.valueOf()`	`"Banana".valueOf(); // "Banana"`
Template Literals	Omogoča vstavljanje spremenljivk v niz z backticks (`).	`Niz ${spremenljivka}`	`Pozdrav, ${ime}!`; // "Pozdrav, Ana!"

REZULTAT

JavaScrip Nizi

Ubežni znaki

Ustvarjanje in osnovne lastnosti nizov

Metode za obdelavo nizov

Pregled metod za nize (Strings)

Vadnica.org

Povezave

Podpora