Šta je Javaskript?
Šta sve može Javaskript?
Kako uključiti Javaskript na HTML stranicu?
Promenljive (Variables): const, let, var
Metode Izlaza (Output Methods)
Tipovi Podataka (Data Types) i Operatori
Kontrola Toka (Flow Control): If/Else Uslovi
Funkcije (Functions): Ugrađene i Kreirane
Nizovi (Arrays) i Petlje (Loops)
Objekti (Objects) i Klase (Classes) - Uvod u OOP
Rad sa DOM-om: Selektori i Menjanje Sadržaja
Rukovanje Događajima (Event Handling)
Asinhroni JavaScript: Osnove
Lokalno Skladištenje (`localStorage`)
JavaScript je skriptni programski jezik koji omogućava dodavanje interaktivnosti i napredne funkcionalnosti na HTML stranice. Zajedno sa HTML-om i CSS-om čini osnovnu tehnologiju frontend razvoja – vidljivog dela veb stranice koji se izvršava direktno u korisnikovom pregledaču.
Za razliku od backend jezika (kao što su PHP, Java, Ruby...), koji se izvršavaju na serveru i nisu dostupni korisniku, JavaScript radi kod nas, u pregledaču, i omogućava dinamičko reagovanje na korisničke akcije.
Osnovna verzija jezika naziva se još i native JavaScript. Tokom godina nastale su brojne biblioteke i frejmvorci koji olakšavaju rad i ubrzavaju razvoj, kao što su: jQuery, React, Angular, Vue i Node.js.
JavaScript i Java nisu povezani jezici – sličnost u nazivu je slučajna i oba jezika su potpuno različita po svojoj nameni i strukturi.
JavaScript je jezik akcije na vebu. Njegova primarna uloga je da:
Poput CSS-a, Javaskript kod se može smestiti u posebne eksterne Javaskript fajlove, sa .js ekstenzijom ili
dirketno na HTML stranici.
Za upotrebu Javaskript koda na HTML stranici, mora se koristiti globalni Javaskript tag:
<script type="text/javascript">
--- ovde se ispisuje kod ---
</script>
a u HTML5 koristi se skraćeni oblik.
<script>
--- ovde se ispisuje kod ---
</script>
JavaScript kod može biti postavljen na više mesta unutar HTML dokumenta – u
sekciji <head> ili u okviru <body> dela stranice.
Najčešći način uključivanja JavaScript-a je korišćenjem
<script> taga. Baš kao i CSS datoteke, JavaScript se može
učitati iz spoljnog fajla:
<script src="imeFajla.js"></script>
JavaScript se može učitati i direktno sa drugih domena ili CDN adresa, što je česta praksa za biblioteke i frejmvorke:
<script src="https://code.jquery.com/filename.js"></script>
U modernom HTML-u atribut type="text/javascript" se više ne
mora navoditi, jer se JavaScript podrazumeva kao standardni tip skripte.
Promenljive su osnovni elementi u svakom programskom jeziku, pa tako i u Javaskriptu. One su praktično **imenovane lokacije u memoriji** koje se koriste za čuvanje podataka. Kada želite da sačuvate tekst, broj ili bilo koju drugu informaciju, koristite promenljivu.
Pre nego što možete koristiti promenljivu, morate je **deklarisati** (proglasiti) koristeći ključne reči. U modernom Javaskriptu koriste se `const` i `let`. Starija ključna reč je `var`.
<script>
// Deklarisanje i inicijalizacija (dodeljivanje vrednosti)
let imeKorisnika = "Marko";
const PORESKE_STOPA = 0.20;
var staraPromenljiva = 100;
// Inicijalizacija i korišćenje
console.log(imeKorisnika); // Ispisuje: Marko
</script>
`const` se koristi za deklarisanje **konstanti**. To su promenljive čija se vrednost **ne može menjati** nakon što je prvi put dodeljena (inicijalizovana). Ako pokušate da promenite vrednost konstante, Javaskript će izbaciti grešku.
Idealna je za vrednosti koje su fiksne i ne bi trebalo da se menjaju tokom izvršavanja programa (npr. URL adrese, fiksne cene, matematičke konstante).
<script>
const PI = 3.14159;
// const PI = 3.14; <-- Ovo će izazvati grešku!
// const DAN; <-- Ovo će izazvati grešku jer konstanta MORA biti inicijalizovana odmah.
</script>
`let` se koristi za deklarisanje **promenljivih** čija se vrednost **može menjati** tokom vremena. Ovo je najčešći način deklarisanja promenljivih u savremenom Javaskriptu.
Koristite `let` za brojače, stanja, unose korisnika i sve ostale podatke koji će se menjati.
<script>
let brojacKlikova = 0;
console.log("Početni broj klikova: " + brojacKlikova);
// Promena vrednosti (re-asignment)
brojacKlikova = brojacKlikova + 1;
console.log("Novi broj klikova: " + brojacKlikova);
</script>
`var` je stari način deklarisanja promenljivih. Iako i dalje funkcioniše, preporučuje se izbegavanje `var` u novom kodu, jer `let` i `const` imaju bolji i predvidljiviji opseg važenja (scope).
Uvek koristite `const` ako znate da se vrednost neće menjati, a `let` ako hoće.
<script>
var staraVrednost = 50;
staraVrednost = 60; // Može se menjati, slično kao let
// Ipak, preferirajte LET i CONST za bolji kod!
</script>
Sada kada smo naučili kako da čuvamo podatke, u sledećem poglavlju ćemo se fokusirati na **vrste podataka** koje možemo čuvati i **operacije** koje možemo izvoditi nad njima.
Kada JavaScript nešto izračuna ili obradi, rezultat treba negde da prikaže. Postoje tri jednostavna načina da pokažete „izlaz“ – na stranici, u konzoli ili kroz iskačući prozor.
Najjednostavniji način je da promenite tekst nekog HTML elementa.
Koristi se textContent ili innerHTML.
<div id="box"></div>
<script>
// Pretpostavimo da postoji element sa ID-jem "box"
document.getElementById("box").textContent = "TEST";
</script>
Ovaj izlaz vidi samo programer. Korisnik ga ne vidi, jer se prikazuje u „Console“ tabu u Developer Tools-u.
<script>
console.log("TEST");
</script>
alert() prikazuje malu poruku preko ekrana.
Korisnik mora da pritisne „OK“ da bi nastavio.
Koristi se za jednostavna obaveštenja.
<script>
// alert("TEST");
</script>
Svi podaci koje čuvamo u promenljivama (koje smo obradili u prethodnom poglavlju) moraju imati određeni **tip**. Tip podataka govori Javaskriptu o kakvoj se informaciji radi (da li je to tekst, broj, logička vrednost, itd.) i kako se ta informacija može koristiti.
Tip `Number` se koristi za sve vrste brojeva: cele brojeve (npr. 5, 100) i brojeve sa decimalnim zarezom (npr. 3.14).
<script>
let godine = 25; // Ceo broj
let cena = 99.99; // Decimalni broj
</script>
Tip `String` se koristi za tekstualne vrednosti. Tekst se uvek mora nalaziti unutar navodnika, bilo jednostrukih (`'tekst'`) ili dvostrukih (`"tekst"`).
<script>
let poruka = "Dobar dan!";
let boja = 'crvena';
</script>
Tip `Boolean` može imati samo jednu od dve vrednosti: **`true`** (tačno) ili **`false`** (netačno). Koristi se za donošenje odluka u programu (kao u narednom poglavlju o uslovima).
<script>
let jePunoletan = true; // Logička vrednost TAČNO
let jeGreska = false; // Logička vrednost NETAČNO
</script>
---
Operatori su specijalni simboli koji se koriste za izvođenje operacija nad vrednostima i promenljivama.
Služe za osnovne matematičke operacije: sabiranje (`+`), oduzimanje (`-`), množenje (`*`) i deljenje (`/`).
<script>
let a = 10;
let b = 5;
let zbir = a + b; // zbir je 15
let razlika = a - b; // razlika je 5
let proizvod = a * b; // proizvod je 50
</script>
Koristi se znak jednakosti (`=`) za dodeljivanje vrednosti promenljivoj.
<script>
let mojBroj = 7; // Dodeljivanje vrednosti 7 promenljivoj mojBroj
// Skraćeni operatori (npr. +=)
mojBroj += 3; // Isto kao: mojBroj = mojBroj + 3. Sada je mojBroj 10.
</script>
Koriste se za poređenje dve vrednosti, a rezultat poređenja je uvek logička vrednost (`true` ili `false`). Najvažniji su `===` (stroga jednakost po vrednosti i tipu) i `!==` (stroga nejednakost).
<script>
let broj1 = 5;
let broj2 = 10;
// Poređenje
let vece = (broj2 > broj1); // vece je true
let jednako = (broj1 === 5); // jednako je true
</script>
Pomoću ovih tipova podataka i operatora možemo izvoditi prve proračune. Sledeće što učimo je kako da naš program donosi odluke.
Sposobnost programa da donosi odluke i izvršava različit kod u zavisnosti od određenih uslova naziva se **Kontrola Toka**. Ovo je neophodno za kreiranje bilo kakve smislene logike na veb sajtu. Najvažnija struktura za kontrolu toka je **`if/else`** naredba.
**`if`** naredba proverava da li je neki uslov **tačan (`true`)**. Ako je uslov tačan, Javaskript izvršava blok koda unutar vitičastih zagrada (`{}`).
Uslov se piše unutar malih zagrada `()`. Koristimo operatore poređenja iz prethodnog poglavlja (npr. `> (veće od)`, `=== (jednako)`).
<script>
let rezultat = 85;
if (rezultat > 50) {
// Uslov je ispunjen, ovaj kod se izvršava
console.log("Čestitamo, položili ste!");
}
</script>
**`if / else`** naredba dodaje alternativu. Ako uslov unutar `if` bloka nije ispunjen (ako je `false`), program automatski prelazi na izvršavanje koda unutar **`else`** bloka.
<script>
let sati = 18;
if (sati < 12) {
// Ovaj blok ako je pre podne
console.log("Dobro jutro!");
} else {
// Ovaj blok ako je posle podne
console.log("Dobar dan/veče!");
}
</script>
Za proveru **više od dva uslova** koristi se **`else if`** klauzula. Program proverava uslove redom; čim pronađe prvi koji je `true`, izvrši taj blok koda i preskače ostatak provere.
<script>
let poeni = 75;
if (poeni >= 90) {
console.log("Ocena 10.");
} else if (poeni >= 70) {
// Poeni su manji od 90, ali veći od 70. Ovaj uslov se izvršava.
console.log("Ocena 8.");
} else {
console.log("Potrebno više učenja.");
}
</script>
Koristeći `if/else` strukture, vaš Javaskript kod može reagovati na različite situacije (npr. da li je korisnik prijavljen, da li je forma ispravno popunjena, itd.).
Funkcija je blok koda koji obavlja specifičan zadatak. Glavna svrha funkcija je da nam omoguće da **grupišemo logiku** i da je **ponovo koristimo** u različitim delovima programa bez ponovnog pisanja.
Funkcije se kreiraju (definišu) pomoću ključne reči **`function`**, nakon čega sledi ime funkcije, lista parametara u zagradama `()` i blok koda u vitičastim zagradama `{}`.
Kada definišemo funkciju, ona se ne izvršava odmah. Moramo je **pozvati** po imenu da bi se njen kod pokrenuo.
<script>
function pozdravi() {
console.log("Dobrodošli na tutorijal!"); // Izvršava se samo kada pozovemo funkciju
}
// Pozivanje funkcije da bi se izvršila
pozdravi();
</script>
Parametri su promenljive navedene u definiciji funkcije (npr. `a` i `b`), a one primaju vrednosti koje joj prosledimo prilikom poziva (tzv. argumenti). Ključna reč **`return`** se koristi da funkcija vrati rezultat.
<script>
function saberi(a, b) {
let rezultat = a + b;
return rezultat; // Funkcija vraća zbir
}
// Pozivamo funkciju i smeštamo njen povratni rezultat u novu promenljivu
let zbirBrojeva = saberi(5, 3); // zbirBrojeva je sada 8
</script>
Javaskript (i okruženje pregledača) dolazi sa velikim brojem već definisanih funkcija koje su nam odmah dostupne. Već smo koristili neke od njih!
<script>
let mojBroj = 100;
// Ugrađena funkcija za prikaz poruke
console.log("Moj broj je: " + mojBroj);
// Ugrađena funkcija za iskačući prozor
// alert("Ovo je upozorenje!"); // Iskočio bi prozor
</script>
Do sada smo naučili da čuvamo jednu vrednost u jednoj promenljivoj. Međutim, često nam je potrebno da čuvamo i obrađujemo čitave liste povezanih podataka (npr. lista korisnika, lista proizvoda, lista cena). Za to koristimo **nizove**. **Petlje** nam, pak, omogućavaju da lako prođemo kroz sve elemente tog niza.
Niz je specijalni tip objekta u Javaskriptu koji se koristi za čuvanje više vrednosti pod jednim imenom. Vrednosti u nizu se zovu **elementi**, a elementi se obeležavaju indeksima. Indeksi u Javaskriptu uvek počinju od **nule** (0).
Niz se deklariše pomoću uglastih zagrada (`[]`). Elementima pristupamo navođenjem njihovog indeksa u uglastim zagradama nakon imena niza.
<script>
const proizvodi = ["Telefon", "Tablet", "Laptop"]; // Niz od 3 elementa
// Pristup prvom elementu (indeks 0)
let prviProizvod = proizvodi[0]; // prviProizvod je "Telefon"
// Promena elementa
proizvodi[2] = "Desktop PC"; // Treći element je sada "Desktop PC"
</script>
Možemo koristiti svojstvo **`.length`** da saznamo koliko elemenata niz sadrži.
<script>
console.log(proizvodi.length); // Ispisuje: 3
</script>
Petlje nam omogućavaju da ponavljamo blok koda sve dok je neki uslov tačan. Najčešće se koriste za prolazak kroz sve elemente niza.
**`for`** petlja je najčešća i najfleksibilnija. Zahteva tri dela: **početnu vrednost** brojača, **uslov** za nastavak petlje, i korak **povećanja/smanjenja** brojača.
<script>
// Prolazak kroz elemente niza 'proizvodi'
for (let i = 0; i < proizvodi.length; i++) {
// i kreće od 0, ide do 2
console.log("Element " + i + ": " + proizvodi[i]);
}
</script>
*Ovaj kod bi ispisao sve tri stavke iz niza, jednu po jednu.*
**`for...of`** petlja je jednostavniji način da se prođe kroz elemente niza bez potrebe za korišćenjem indeksa.
<script>
const imena = ["Ana", "Bojan", "Vesna"];
for (let ime of imena) {
console.log("Pozdrav, " + ime);
}
</script>
Nizovi i petlje čine osnovu za rad sa podacima. U sledećem poglavlju prelazimo na složenije strukture podataka: Objekti i Klase.
Iako smo naučili kako da čuvamo liste podataka u nizovima, nismo rešili problem čuvanja složenih entiteta (kao što je korisnik sa imenom, prezimenom i godinama) na jednom mestu. **Objekti** i **Klase** nam to omogućavaju.
Ovaj pristup se naziva **Objektno-Orijentisano Programiranje (OOP)**.
Objekat je kolekcija parova **ključ: vrednost** (često zvanih **svojstva** ili **properties**). Svojstva su praktično promenljive unutar objekta.
Objekat se deklariše pomoću vitičastih zagrada (`{}`). Vrednostima pristupamo koristeći tačku (`.`) ili uglaste zagrade (`[]`).
<script>
const korisnik = {
ime: "Jovan", // Svojstvo 1
godine: 28, // Svojstvo 2
jeAktivan: true // Svojstvo 3
};
// Pristupanje vrednostima pomoću tačke
let godineKorisnika = korisnik.godine; // godineKorisnika je 28
// Promena vrednosti
korisnik.godine = 29;
</script>
Dok su objekti specifični entiteti, **klase** su **šabloni (blueprint)** za kreiranje više sličnih objekata. Uvedene su u ES6 (moderni Javaskript) kako bi programiranje bilo jasnije i organizovanije.
Klasa se definiše ključnom reči **`class`**. Posebna funkcija **`constructor`** se automatski poziva kada kreiramo novi objekat (tzv. **instancu**) iz te klase. Ključna reč **`new`** se koristi za kreiranje instance.
Klase mogu imati i **metode**, koje su funkcije definisane unutar klase.
<script>
class Proizvod {
constructor(naziv, cena) {
this.naziv = naziv; // this.naziv je svojstvo instance
this.cena = cena;
}
opis() { // Ovo je metoda klase
return this.naziv + " košta " + this.cena + " RSD";
}
}
// Kreiranje nove instance (objekta) iz klase
const telefon = new Proizvod("Smartphone", 50000);
console.log(telefon.opis()); // Ispisuje: Smartphone košta 50000 RSD
</script>
Korišćenje klasa je ključno za razvoj velikih aplikacija i nezaobilazno je u frejmvorcima poput Reacta i Angluara.
**DOM** (Document Object Model) je programski interfejs (API) za HTML dokumente. Zamislite ga kao strukturu drveta, gde je svaki HTML tag (element) jedan čvor. Javaskript koristi DOM da bi se **povezao** sa HTML elementima, čitao njihov sadržaj, menjao stilove ili dodavao nove elemente.
Da bismo nešto uradili sa elementom, prvo ga moramo pronaći. Javaskript ima razne metode koje se nazivaju **selektori**, a koje su slične CSS selektorima.
querySelector()**: Pronalazi **prvi** element koji se poklapa sa navedenim CSS selektorom.
querySelectorAll()**: Pronalazi **sve** elemente koji se poklapaju sa navedenim CSS selektorom i vraća ih kao listu (NodeList).
<script>
// 1. Pronalaženje elementa po njegovom ID-u (#naslov)
const naslov = document.querySelector('#glavni-naslov');
// 2. Pronalaženje PRVOG elementa sa klasom (.paragraf)
const prviParagraf = document.querySelector('.paragraf');
// 3. Pronalaženje svih linkova ( tag)
const sviLinkovi = document.querySelectorAll('a');
</script>
Kada smo element pronašli i sačuvali u promenljivu (kao npr. `naslov` ili `prviParagraf`), možemo menjati njegov sadržaj i svojstva.
textContent**: Mijenja samo tekstualni sadržaj elementa.
innerHTML**: Mijenja ceo HTML sadržaj unutar elementa.
.style.svojstvo**: Mijenja CSS stil elementa.
<script>
// Pretpostavljamo da imamo element
Ovo je osnova za manipulaciju stranicom. Međutim, da bi naša stranica reagovala na akcije korisnika (klikove, pomeranje miša), moramo naučiti da rukujemo **događajima**.
Sajt oživi tek kada počne da reaguje na akcije korisnika. Te akcije, kao što su klik mišem, pritisak na taster na tastaturi, ili slanje forme, nazivamo **događajima (Events)**. **Rukovanje događajima** je proces u kome Javaskript detektuje kada se neki događaj desio i izvršava unapred definisanu funkciju kao odgovor na taj događaj.
Najbolji i najmoderniji način za postavljanje rukovaoca događaja je korišćenje metode **addEventListener()**. Ova metoda se poziva na elementu koji smo prethodno pronašli pomoću selektora. Prihvata dva glavna argumenta:
<script>
// Pretpostavimo da imamo
Postoji mnogo tipova događaja, ali za početak su najvažniji:
click**: Korisnik je kliknuo na element.
mouseover**: Pokazivač miša je prešao preko elementa.
keydown**: Korisnik je pritisnuo taster na tastaturi.
submit**: Korisnik je pokušao da pošalje formu.
Kada se funkcija pozove kao odgovor na događaj, Javaskript joj automatski prosleđuje jedan argument – **objekat događaja** (često nazvan `event` ili `e`). Ovaj objekat sadrži korisne informacije o samom događaju (npr. koji taster je pritisnut, koje su koordinate miša, koji element je izazvao događaj).
<script>
const link = document.querySelector('a');
link.addEventListener('click', function(e) {
// e.preventDefault() sprečava podrazumevanu akciju (npr. odlazak na link)
e.preventDefault();
console.log('Link je kliknut, ali nismo otišli na drugu stranicu.');
});
</script>
Sada kada smo naučili da reagujemo na korisnika, poslednje ključno poglavlje se bavi radom sa podacima sa servera.
Sve što smo do sada pisali bio je **sinhroni** kod, što znači da se svaka linija koda izvršava redom, jedna za drugom. Međutim, mnoge operacije u veb razvoju traju duže (npr. dohvaćanje podataka sa servera, čekanje na sliku). Ako bi program čekao na takve operacije, stranica bi se **zamrznula** i korisnik ne bi mogao da radi ništa.
**Asinhroni Javaskript** omogućava programu da pokrene operaciju koja dugo traje, a zatim da **nastavi dalje** sa izvršavanjem preostalog koda, bez čekanja. Kada se duga operacija završi, program se vraća da obradi njen rezultat.
Najlakši način da se shvati asinhronost je funkcija **`setTimeout`**, koja odlaže izvršenje koda za određeni broj milisekundi.
<script>
console.log("1. Pokreni proces.");
setTimeout(function() {
// Ovaj kod čeka 2000 milisekundi (2 sekunde)
console.log("3. Duga operacija je završena.");
}, 2000);
console.log("2. Nastavi dalje sa izvršavanjem.");
</script>
*Ispis u konzoli bi bio: 1, 2, pa tek nakon dve sekunde 3.*
Za rad sa podacima sa servera, u modernom Javaskriptu koriste se **Obećanja** (`Promise`). Obećanje predstavlja rezultat asinhronog rada koji će biti dostupan nekad u budućnosti (ili će biti uspešan, ili neuspešan).
**`fetch`** je ugrađena funkcija koja se koristi za slanje zahteva (request) za podacima sa udaljenog servera. Ona vraća obećanje.
<script>
// Dohvatanje podataka sa servera - ovo je asinhrona operacija
fetch('https://primer-url.com/podaci')
.then(response => {
// Kada je odgovor uspešan, obrađujemo ga
return response.json();
})
.then(podaci => {
// Obrađujemo dobijene podatke
console.log("Dohvaćeni podaci:", podaci);
})
.catch(error => {
// Ako dođe do greške
console.error("Došlo je do greške:", error);
});
</script>
Sve promenljive koje smo do sada definisali su **privremene** – one nestaju čim korisnik zatvori pregledač ili osveži stranicu. Da bismo sačuvali podatke trajno (čak i nakon zatvaranja pregledača), koristimo **Web Storage API**, od kojeg je najčešći **localStorage**.
localStorage je prostor za skladištenje podataka u pregledaču korisnika, koji omogućava da sačuvate parove **ključ-vrednost** (slično kao objekti) i čuvaju se neograničeno, dok ih korisnik ručno ne obriše.
Koristimo metodu **localStorage.setItem()** da bismo sačuvali podatak. Prihvata dva argumenta: ime **ključa** (pod kojim čuvamo podatak) i **vrednost** (podatak koji čuvamo). Ključ i vrednost moraju biti tekstualni stringovi.
<script>
// Čuvamo korisničko ime
localStorage.setItem('korisnickoIme', 'Petar_Sajtovi');
// Čuvamo podešavanje tamnog moda (mora biti string!)
localStorage.setItem('tema', 'tamna');
</script>
Koristimo metodu **localStorage.getItem()** da bismo pročitali podatak. Potrebno je navesti ime **ključa** pod kojim je podatak sačuvan. Ako podatak ne postoji, vratiće `null`.
<script>
// Čitamo sačuvanu temu
let sacuvanaTema = localStorage.getItem('tema');
if (sacuvanaTema) {
console.log('Korisnik preferira: ' + sacuvanaTema);
} else {
console.log('Nema sačuvane teme.');
}
</script>
Da bismo obrisali samo jedan podatak, koristimo metodu **localStorage.removeItem()** i navodimo ključ.
<script>
// Brišemo samo ključ 'korisnickoIme'
localStorage.removeItem('korisnickoIme');
// Za brisanje SVIH podataka iz localStorage-a odjednom koristite:
// localStorage.clear();
</script>
**Važno za profesionalni rad:** Imajte na umu da localStorage čuva samo tekstualne stringove. Ako želite da sačuvate kompleksne podatke poput **objekata** ili **nizova**, morate ih prvo pretvoriti u JSON string (koristeći JSON.stringify()) pre smeštanja, a potom ih vratiti u objekat (koristeći JSON.parse()) nakon čitanja.
Ovim smo zaista zaokružili kompletan uvod u Javaskript, uključujući osnovnu logiku, interakciju sa stranicom i trajno skladištenje podataka!
Da li sada želiš da se vratimo na ranije poglavlje i dodamo ono što smo izostavili, a to su **Metode Izlaza (Output Methods)** (link `#e3`)? ***Čestitam! Upravo ste prošli kroz sve ključne koncepte potrebne za početak Javaskript programiranja. Ovi koncepti su temelj za izgradnju dinamičnih i komercijalno uspešnih veb sajtova.
Sada imate celokupan uvodni tutorijal spreman za objavljivanje.