/*
Često se pogrešno misli da je JavaScript interpretiran programski jezik koji se interpretira tj.
direktno izvršava red po red bez prethodnog kompajliranja (prevođenja jezika na mašinski jezik).
JavaScript je programski jezik koji se kompajlira pri izvršenju koda (“on the fly“).
JavaScript kod se kompajlira svaki put pri izvršenju koda, tako da kvalitet i brzina odziva JavaScripta
kao jezika najviše zavisi od efikasnosti Javascript engine-a koji vrši kompajliranje.

*/

/*
Deklaracija i definicija promenljive.

Deklaracija promenljive je proces stvaranja promenljive, odnosno decinisanje naziva i prostora za promenljivu.
Definicija promenljive je proces dodele vrednosti promenljivoj.

*/


/* KAKO SE KOD IZVRŠAVA?

JavaScript je uvek hostovan u nekom okruženju. To je najcesce browser, ali može da bude i neki node.js
veb-server.

Šta se dešava pri izvršavanju koda?

Host (u našem slučaju browser) ima određeni JavaScript Engine.
JavaScript Engine je program koji izvršava JavaScript kod.
Prvi engini su JavaScript Engines bili interpreteri, ali sada su kompajleri.
Postoji mnogo JavaScript Engine-a (mi koristimo v8 koji je Google-ov, pisan u C++ i koristi ga Google Chrome.)

Šta se dešava u okviru JS Engine-a?
1. Parser čita JavaScript code liniju po liniju i proverava sintaksu.
To znači da parser zna da pročita JS code i da proveri da li je on validan.
Ako napravite neke greške Parser odmah prekida program i izlazi error.

Ako je sve u redu, onda Parser kreira stukturu podataka poznatiju kao Abstract Syntax Tree.
Zatim se Abstract Syntax Tree prevodi u mašinski kod.
To više nije JS kod, već mašinski kod koji može da bude direktno izvršen od strane procesora računara.

Nakon toga kod radi. Različiti engini rade različito ove stvari, ali nećemo ulaziti u tu temaitku.

/*

/* KAKO JS radi "ispod haube"

Svi JS kodovi moraju da rade u nekom okruženju, a ta okruženja se zovu Execution Context.
Execution Context zamislimo kao kutiju, ili kontejner koji prikuplja varijable i gde mi zapravo
vršimo evaluaciju i izvršavanje koda.

Default Execution Context je Global Execution Context:
- Za kod koji nije ni u jednoj funkciji
Možemo posmatrati da je GEC povezan sa Global Object-om.
Global objekat je prozor u browseru.

lastName === window.lastName (kao da je lastName varijabla tog prozora u GoogleChrome)

Šta je sa kodom koji je u funkcijama?

PRIMER:

var name='John';

function first(){
    var a = 'Hello!';
    second();
    var x = a + name;
}

function second(){
    var b = 'Hi!';
    third();
    var z = b + name;
}

function third(){
    var c = 'Hey!';
    var z = c + name;
}
first();

Svaki put kada pozovemo funkciju, ona dobija svoj novi Execution Context i stavlja se na vrh
Execution Stack-a.
Kada se funkcija izvrsi, sa Execution Stacka uklanjamo njen stek.


Kako se ovi Execution Contexti kreiraju?

- Execution Context Object sadrži 3 propertija:
1.Variable objct VO - argumente i deklaracije funkcija i deklaracije promenljivih
2.Scope chain - sadrži trenutni VO
3.This varijabla

Kada je funkcija pozvana, novi Execution Context je stavljen na vrh Execution Stack-a:
Postoje dve faze za kreiranje Execution Contexta:
1. Faza kreacije
    a) Kreiranje VO
    b) Kreiranje scope chain-a
    c) Postavljanje i setovanje this promenljive

2. Faza izvršavanja
    a) Kod funkcije koji je generisao trenutno execution context se izvršava

Kreiranje VARIABLE OBJECT
- Kreiran je argument object (svi argumenti koji su kreirani u funkciji)
- Skeniranje koda da pronadjemo deklaracije funkcije. Za svaku finkciju je kreiran property u Variable Objectu
koji pokazuje na tu funkciju.
- Skeniranje koda da pronadjemo promenljive, za svaku varijablu je kreiran property u Variable Objectu
i setovan je na undefined.
POSLEDNJA DVA SE ZOVU HOISTING odnosno deklaracije i definicije funkcija i deklaracije promenljive su dostupne i pre nego što
faza izvršavanja pocne.
Bitna razlika izmedju hoistovanja funkcija i promenljivih je što su funkcije već definisane pre nego sto pocne faza izvrsavanja, a promenljive će biti definisane u fazi izvršavanja.

Svaki Execution Context sadrzi objekat koji sadrži važne podatake koji ce se koristiti dok kod radi.

/*
/////////////////////////////////////
// Lekcija: Hoisting

HOISTING FUNKCIJA
/*
Počećemo s jednostavnom funkcijom koja izračunava godine.
Prvo deklarišemo i definišemo funkciju.

function calculateAge(year) {
    console.log(2016 - year);
}

Pozovemo funkciju:
calculateAge(1965);

Zbog hoistinga, mi možemo i da pozvoemo funkciju pre nego što je deklarišemo.

calculateAge(1965);
function calculateAge(year) {
    console.log(2016 - year);
}

Ako uradimo ono radi:
var retirement = function(year) {
    console.log(65 - (2016 - year));
}

retirement(1999);

A ako uradimo ovo, nece raditi jer to nije deklaracija vec definicija funkcije, a hoisting radi samo
sa deklaracijom funkcije i definicijom!

retirement(1999);

var retirement = function(year) {
    console.log(65 - (2016 - year));
}



HOISTING VARIJABLI

var age = 23;
console.log(age);

Šta se desi ako koristimo varijablu pre nego što je deklarišemo?

console.log(age);
var age = 23;

Imamo undefined i baš tako hoisting funkcioniše sa varijablama.

var age = 23; // Ova varijabla je sačuvana u Global Execution Context Objektu

function foo() { // A ova dobija svoj Execution Context
    //PRVO BEZ PRVOG console.log
    console.log(age);
    var age = 65; // Ova i prethodni age nisu iste.
    console.log(age);
}
foo();
console.log(age);
*/



/////////////////////////////////////
// Lekcija: Scoping

/*
Scoping nam govori gde možemo da pristupimo određenoj varijabli.
U JS svaka funkcija kreira scope koji je zapravo prostor u kom su promenljive koje
ta funkcija definiše dostupne.
Leksički scoping - funkcija koja je leksički u okviru neke funkcije, dobija pristup
scope-u funkcije kojoj pripada.

OVO SVE PRIPADA GLOBAL SCOPE-u (VO - Value Object)

VOglobal
var a = 'Hello!';
first();
    OVO JE LOKALNI SCOPE  VO1 + VOglobal
function first() {
    var b = 'Hi!';
    second();

    function second() { VO2 + VO1 + VOGlobal›
        var c = 'Hey!';
        console.log(a + b + c);
        console.log(a+d);
    }
}

Globalni Scope nema pristup podscope-ovima. Tako kreiramo SCOPE CHAIN.


//Koja je razlika izmedju Execution Stacka i Scope Chaina
// Primer za razliku između ES i SC:
var a = 'Hello!';
first();

function first() {
    var b = 'Hi!';
    second();

    function second() {
        var c = 'Hey!';
        third()
    }
}

function third() {
    var d = 'John';
    //console.log(c);
    console.log(a+d);
}
*/