JavaScript nyelvi alapjai VI.
                    • createElement(”Tag”);
                    • Segítségével létrehozható egy megadott nevű tag.
                    • Pl.:
                    • var tag = document.createElement(”p”);
                    • createTextNode(”Szöveg”);
                    • Létrehoz egy element szintű szöveget.
                    • Pl.:
                    • var szoveg = document.createTextNode(”Helló Világ!”);
                    • Természetesen a document objektumnak számos további
              függvénylehetősége is van még, amikkel mi nem fogunk
              foglalkozni.
                    • További függvények:
              • http://www.w3schools.com/jsref/dom_obj_document.asp 21
              JavaScript nyelvi alapjai VII.
                    • A visszakapott, kinyert szerkezeti elemek (Tag-ek) tulajdonságai:
                    • A JavaScript eléri az összes a HTML-ben használt attribútumot, illetve
                      tartalmat a következőképpen:
                    • element.InnerHTML;
                    • Az aktuális elem belső szerkezeti részét (a kezdő és záró tag közti részt) lehet vele
                      kiolvasni, vagy módosítani.
                    • element.attributes;
                    • A megadott elem összes tulajdonságát lehet vele lekérdezni.
                    • element.setAttribute(”attribute”,”value”);
                    • A megadott elem, megadott attribútumának lehet vele értéket adni.
                    • element.getAttribute(”attribute”);
                    • A megadott elem, megadott attribútum értékének kiolvasása. 22
              JavaScript nyelvi alapjai VIII.
                    • element.appendChild(tag);
                    • Belefűz egy létrehozott tag-et egy már létező, meglévő tag-be.
                    • Pl.:
                      var pelem = document.createElement(”p”);
                      var pszoveg = document.createTextNode(”Szöveg”);
                      pelem.appendChild(pszoveg);
                    • element.removeChild(tag);
                    • Kitöröl egy megadott elemet a megadott tag alól.
                    • element.replaceChild(mire, mit);
                    • Kicseréli az adott elemet, egy másikra, a megadott elemen belül.
                    • Természetesen az egyes elemeknek is további beállításai lehetségesek.
                    • További függvények:
              JavaScript nyelvi alapjai IX.
                    • Metódusok, funkciók:
                    • Mivel a JavaScript gyengén típusos nyelv, így a funkciók, metódusok
                      létrehozása és működése eltér az eddig megszokottaktól:
                    • Akár metódust, akár funkciót szeretnénk létrehozni a function kulcsszó
                      segítségével tudjuk megoldani:
                    • function ()
                      { …
                        }
                    • A funkció és metódus közti különbséget nem kell kód szinten jelölni, csak az
                      dönti el, hogy van-e visszatérés az adott ágon, vagy nincs.
                    • Lehetséges olyan funkció írása, aminek bizonyos esetben van visszatérése, és bizonyos
                      esetben nincs, illetve a visszatérés típusdefiníciója nélkül bármilyen típussal visszatérhet
                      egy-egy függvény.
                     
              JavaScript nyelvi alapjai X.
                    • Események:
                    • Mivel a JavaScript eseményvezérlet, így a felhasználói
                      műveleteket események segítségével tudjuk elérni, azokra azokon
                      keresztül tudunk reagálni.
                    • Új események definiálására is van lehetőség (mint ahogy C# alatt
                      is) azonban ezzel nem fogunk foglalkozni.
                    • Az eseményekre való feliratkozás a HTML-ben történik a megadott
                      komponens, megadott eseményén.
                    • Általában funkciót írunk az eseményekhez.
              JavaScript nyelvi alapjai XI.
                    • Általános HTML-ben kiváltható események:
                    • A feliratkozás általános formája:
                    • 
                      onchange Az elem megváltozott.
                      onclick A felhasználó az elemre kattintott.
                      onmouseover A felhasználó az elem felé navigált (egérrel).
                      onmouseout A felhasználó elnavigált az elemről (egérrel).
                      onkeydown A felhasználó leütött egy billentyűt.
                      onload A böngésző befejezte az oldal betöltését.
              A window objektum
                    • Segítségével a különböző ablakok megjelenését tudjuk
                      szabályozni.
                    • Fontosabb függvényei:
                    • open(”url”,[”név”], [”paraméterek”]);
                    • Új lapot nyit, a megadott url-el.
                    • Az ablaknak név is adható, melyen keresztül elérhetővé válik, így további
                      komponenseket rakhatunk bele, vagy módosíthatunk benne.
                    • close();
                    • Bezárja az adott lapot.
                    • Csak window objektumnál működik. 29
              A window object időzítési lehetőségei:
                    • window.setInterval(”funkció”, milliszekundumok);
                    • Mint egy időzítő, az adott funkció x milliszekundumonként le lesz
                    futtatva.
                    • window.setTimeout(”funkció”, milliszekundumok);
                    • Egyszeri időzítés, az adott funkció, egyszer lesz lefuttatva x
                    milliszekundum után.
              JavaScript nyelvi alapjai XV.
                    • A window object dialógusai:
                    • window.alert(”Szöveg”);
                    • Egy szimpla figyelemfelhívás dialógus ablak, egy oké gombbal ellátva.
                    • window.confirm(”Kérdés”);
                    • Egy döntési ablak, Ok és Mégsem gombokkal ellátva.
                    • window.prompt(”Kérdés”, [”Alapértelmezett válasz”]);
                    • Egy InputBox, adatot lehet vele bekérni.
              Alprogramok tovább vezetése I.
                    • Az előzőekben már láthattuk, hogy a JS alapvetően is a
                    procedurális logikára épül.
                    • A procedurális logikában azonban vannak további
                    részegységek melyek elengedhetetlenek annak mélységi
                    felhasználásához:
                    • Névtelen funkciók
                    • Opcionális paraméterek
                    • Események kezelése programkódból
                    2
              Névtelen funkciók I.
                    • A névtelen, vagy anonymous funkciók használata a
                    JavaScript-ben egy teljesen általános megoldás.
                    • A JS alapvetően a programkód hordozását nem teszi
                    lehetővé, így abban az esetben ha egy megadott helyen
                    dinamikus programkód átadásra van szükség, ott helyben
                    is definiálhatjuk az alprogramot ami a funkcionalitást
                    fogja adni.
                    3
              Névtelen funkciók II.
                    • A névtelen funkciók, ahogy nevükben is benne van olyan
                    funkciók melyeket prompt definiálva használunk és
                    ezáltal nem szükséges elnevezni őket.
                    • A felépítése két féleképpen is lehetséges:
                    • Normál felírásban:
                    • function() {…}
                    • Lambda kifejezés logikával:
                    • () => {…}
                    4
              Eseménykezelés programkódból I.
                    • A névtelen funkciók azért is fontosak, mert az eddigi HTML
                    alapú eseményekezelést fel tudjuk váltani jóval egyszerűbb,
                    programkód szintű megoldásra.
                    • Az eddigi megoldásunk keretében egy tetszőleges HTML DOM
                    elem on… attribútumán keresztül tudtunk feliratkozni egy
                    eseményre egy általunk előre megírt funkcióval.
                    • A kód szintű megoldás keretében a DOM elemet JS-ben
                    elkapjuk és úgy iratkozunk fel rá.
                    5
              Eseménykezelés programkódból II.
                    • Az eseménykezelés kontrollálása programkódból
                    alapvetően két dolog miatt hasznos:
                    • Egyrészt nem vagyunk a HTML szerkezetre utalva, a
                    programkód elkülönülhet a HTML részektől.
                    • Másrészt a programkód szinten lehet vezérelni, hogy mikor
                    melyik esemény milyen formában legyen lekezelve.
                    • Az eseménykezelés alapvető működése természetesen
                    ettől nem változik és nem zárja ki ez a megoldás a HTML
                    alaú felhasználást sem.
                    6
              Eseménykezelés programkódból III.
                    • A feliratkozás formája:
                    • A kifejtett újabb megoldás:
                    • var = document.GetElementById();
                    .addEventListener(””, function()
                    {
                    //esemény lekezelése
                    }, false); //Nem adunk meg extra paramétereket alapértelmezetten
                    • Az attribútum alapú megoldás:
                    • var = document.GetElementById();
                    .on = function() {/*esemény lekezelése*/};
                    7
              Eseménykezelés programkódból IV.
                    • Az előző két példa technikailag megegyezik eredmény
                    szempontjából, az addEventListener alapú megoldás az
                    újabb és „szebb megoldás”.
                    • A második megoldás valójában abból adódóan működik,
                    hogy JS alól a DOM elem összes attribútuma elérhető,
                    így ha az onclick pl. bejegyezhető DOM szinten akkor JS
                    szinten is attribútumként.
              Opcionális paraméterek I.
                    • Az alprogramok további fontos tényezője a
                    paraméterezés.
                    • Az alprogramok esetében a paraméterek megadása
                    fontos, hiszen ezen keresztül tudunk adatokat átadni a
                    futáshoz.
                    • Előfordul azonban, hogy bizonyos paraméterek nem
                    kötelezően kitöltendők, így időt is spórolhatunk és futást
                    is stabilizálhatunk - (helytelen funkció paraméterezések)
                    10
              Opcionális paraméterek II.
                    • Az opcionális paraméterek alkalmazása JS-ben hasonlóan
                    a többi nyelvhez igen egyszerűen kivitelezhető,
                    mindössze értéket kell adni a paraméternek a listában:
                    • function ( = <érték>,…) {…}
                    • Természetesen a paraméterezésben továbbra is lehetnek
                    fix paraméterek az opcionálisok előtt, utánuk már fix
                    paraméternek nem lenne értelme, hiszen a sorrend
                    összekuszálódna.
                    11
              Opcionális paraméterek III.
                    • Példa:
                    • function osszead(a, b = 42)
                    {
                    return a + b;
                    }
                    • A JS alapvetően megengedő, így ha egy paraméter nem
                    opcionális, de nem adjuk meg sem lesz belőle hiba!
                    • Mindössze undefined lesz az értéke.
                    
              Opcionális paraméterek IV.
                    • A funkción belül az arguments jelölővel lekérdezhetjük az
                    összes beérkező paramétert, így programozottan is tudjuk
                    kezelni a paramétereket.
                    • function osszead(a, b = 42)
                    {
                    a = (arguments.length == 0) ? 1 : a; //a értéke eddig
                    undefined, mivel nem érkezett paraméter, ha így van akkor 1-re
                    állítjuk.
                    return a + b;
                    }
              A Prototípus-orientált programozás IV.
                    • A prototípus létrehozása egyszerű, egy speciális funkciót
                    hozunk létre:
                    • function ()
                    {
                    this. = ;…
                    }
                    • Ezzel létrehoztunk egy új prototípust, mellyel tudunk
                    létrehozni tetszőleges adatokat.
                    19
              A Prototípus-orientált programozás V.
                    • Például:
                    • function Auto(rendszam, marka, tipus)
                    {
                    this.rendszam = rendszam;
                    this.marka = marka;
                    this.tipus = tipus;
                    }
                    • A létrehozás:
                    • var auto1 = new Auto(”ABC-123”, ”AUDI”, ”A4”);
                    var auto2 = new Auto(”ABC-321”, ”Suzuki”, ”Swift”);
                    20
              A Prototípus-orientált programozás VI.
                    • Természetesen lehetnek fixen megadott elemek is a
                    prototípusban:
                    • function Auto(rendszam, tipus)
                    { this.rendszam = rendszam;
                    this.marka = ”Suzuki”;
                    this.tipus = tipus;
                    }
                    • var auto1 = new Auto(”ABC-321”, ”Swift”);
                    var auto2 = new Auto(”ABC-132”, ”SX4”);
                    • Minden autó Suzuki tehát ebben az esetben.
                    21
              A Prototípus-orientált programozás VII.
                    • A prototípusokhoz lehet funkciókkal is bővíteni:
                    • function Auto(rendszam, tipus)
                    { this.rendszam = rendszam;
                    this.marka = ”Suzuki”;
                    this.tipus = tipus;
                    }
                    • Auto.prototype.teljesNev = function()
                    { return this.marka + ” ” + this.tipus;
                    }
                    • A prototype segítségével férünk hozzá egy meglévő prototípus szerkezetéhez
              A Prototípus-orientált programozás VIII.
                    • Prototípusokat természetesen létre lehet hozni prompt
                      megoldás keretében is, ilyenkor maga az objektum jön
                      közvetlenül létre, melyet azonnal fel is töltünk adattal:
                    • var auto1 =
                    {
                      rendszam : ”ABC-123”,
                      marka : ”AUDI”,
                      tipus: ”A4”
                    };
              A Prototípus-orientált programozás IX.
                    • Ugyan ritka, de ilyenkor természetesen ugyan úgy lehet funkciókat
                      is társítani a rendszerhez:
                    • var auto1 =
                      { rendszam : ”ABC-123”,
                        marka : ”AUDI”,
                        tipus: ”A4”,
                        teljesNev: function()
                      { return this.marka + ” ” + this.tipus;
                      }
                    };
              A Prototípus-orientált programozás X.
                    • Az utóbbi eset azért ritka, mert a prompt létrehozott
                      anonym prototípusok általában azért jönnek létre, hogy
                      adatokat strukturáltan hordozzunk bennük.
                    • A prototípusok anonym létrehozásának felépítése a JSON
                      leíró nyelv logikájának megfelelően működik.
                    • A JSON (JavaScript Object Notation) – JavaScript objektum
                      jelölő.
              JavaScript adatszerkezetei I.
                      • A JavaScript ugyan gyengén típusos nyelv, ugyanakkor
                      működéséhez elengedhetetlen néhány komplexebb
                      adatszerkezet, melyek beépítetten rendelkezésre állnak
                      benne:
                      • Tömb
                      • Halmaz
                      • Szótár
                      • Ezeket fogjuk megnézni a következőkben.
              JavaScript tömb I.
                      • A JS-ben a tömb adatszerkezet, mint a legtöbb
                      programozási környezetben egy indexelhető és bejárható
                      adatszerkezet.
                      • Természetesen gyengén típusos nyelv lévén a tömböknek
                      nincs konkrét mérete és típuskötése sem.
                      • A tömb létrehozása egyszerű, mindössze [] közé kell
                      felsoroljuk az adatokat, illetve implicit módon a rendszer
                      létre is hozza nekünk, ha indexelünk egy változót.
              JavaScript tömb II.
                      • Példa – indexelt létrehozás:
                      • var tomb = [];
                      tomb[0] = <érték1>;
                      tomb[1] = <érték2>;
                      tomb[2] = <érték3>;
                      • Példa – előre feltöltött megoldás:
                      • var tomb = [<érték1>, <érték2>, <érték3>];
                      • A tömbök tehát tetszőleges típusúak lehetnek és szabadon
                      bővíthetők.
              JavaScript tömb III.
                      • A tömbök-nek a hosszát a length tulajdonságon keresztül kérdezhetjük le.
                      • Bejárásuk pedig több formában is lehetséges:
                      • For ciklus:
                      • for(var i = 0; i < tomb.length; i++)
                      { //tomb[i] felhasználása
                      }
                      • Illetve létezik beépített funkcionális forEach
                      • tomb.forEach(function(value)
                      { //value feldolgozása
                      });
                      • Mindkettőt szabadon használhatjuk.
              JavaScript tömb IV.
                      • Tömbből a delete parancs segítségével tudunk törölni.
                      • Fontos, hogy a delete törli az adott elemet a tömbben,
                      de a tömb nem változik meg indexelése szempontjából,
                      így az indexek megmaradnak, csak lyukacsos marad a
                      tömb.
                      • delete [];
                      34
              JavaScript – Halmaz I.
                      • A halmaz, mint matematikában itt is egyedi elemek
                      tárolója.
                      • Nem lehet benne duplikált elem, melyet kifejezetten
                      akkor szoktunk alkalmazni, ha egy olyan adatszerkezetet
                      szeretnénk kialakítani, amiben az egyes elemek csak
                      akkor jelenhetnek meg, ha nem egyformák.
                      • Felhasználása ritka ugyanakkor hasznos lehet.
                      35
              JavaScript – Halmaz II.
                      • Használata:
                      • var halmaz = new Set();
                      halmaz.add(); // Hozzáad egy elemet a halmazhoz
                      halmaz.delete(); //Törli az adott elemet a halmazból
                      halmaz.has(); //Megadja, hogy ilyen elem van-e már a
                      halmazban
                      halmaz.clear(); //Törli az összes elemet halmazból
                      halmaz.size  megadja, hogy hány elem van a halmazban
              JavaScript – Szótár I.
                      • A szótár egy másodlagos indexelési lehetőséget biztosító
                      adatszerkezet.
                      • A Szótár valójában kulcs-érték párosokat tárol, melyeket fel
                      tudunk használni.
                      • Segítségével egy bármilyen adat egy tetszőleges másik típusú
                      adattal jelölhető mint kulcs, ezáltal könnyebb később megtalálni.
                      • A kulcsok közti kereséssel pedig az adatokat visszakaphatjuk.
                      38
              JavaScript – Szótár II.
                      • Használata:
                      • var szotar = new Map();
                      szotar.set(,<érték>); // Hozzáad egy kulcs-érték
                      párost a szótárhoz
                      szotar.delete(); //Törli az adott elemet a szótárból
                      szotar.has(); //Megadja, hogy ilyen kulcs van-e már a
                      szótárban
                      szotar.clear(); //Törli az összes elemet szótárból
                      szotar.size  megadja, hogy hány elem van a szótárban
            

              Reguláris kifejezések II.
                      • A reguláris kifejezéseket alapvetően 3 dologra használjuk:
                      • Szöveg mintaillesztése
                      • Meg tudjuk állapítani, hogy egy szöveg megfelel-e egy adott
                        mintának, vagy van-e benne olyan rész ami megfelel annak.
                      • Szöveg keresése
                      • Meg tudjuk keresni azt a szöveget, vagy azon részeket amik
                        megfelel egy mintának.
                      • Szöveg bontása
                      • Szöveg bontása a minta szerinti tördelőpontoknál.
              Reguláris kifejezések III.
                      • A reguláris kifejezések általános formális leírást tesznek
                        lehetővé a legtöbb programozási környezetben, ennek
                        megfelelően szinten minden programnyelv rendelkezik
                        reguláris kifejezés értelmező részegységgel, így a
                        JavaScript is.
                      • Az egyes programnyelvek tekintetében a felírásban
                        lehetnek eltérések, de a főbb funkciók és leírások
                        azonosak.
              Reguláris kifejezések IV.
                      • A reguláris kifejezések alap formátuma JS-ben:
                      • .search(minta);
                      • Megadja, hogy a minta hol található meg a szövegben, ha megtalálható
                        egyáltalán benne.
                      • .replace(minta, ””);
                      • Megadja a minta szerint, hogy mit kell ki cserélni a szövegben és mire.
                      • .test(””);
                      • Megadja, hogy az adott szöveg megfelel-e a mintának.
                      • A JavaScript a reguláris mintákat függvényként kezeli, így nem
                        szövegesen kell kezelni a mintákat.
              Reguláris kifejezések V.
                      • A kifejezések megírása:
                      • A kifejezéseket minden esetben /…/ (per jelek között) kell megírni.
                        Pl.: /[abc]+/
                      • Kifejezés módosítói:
                      • i  kis-nagy betűk figyelmen kívül hagyása (case insensitive)
                      • g  globális találatok, ne álljon meg az első találat után
                      • m  több soros keresés, keressen tovább az enter után is
                        (multiline)
                      • Felhasználási példa: /…/ig
              Reguláris kifejezések VI.
                      • Reguláris opciók:
                      • [] / []
                      • A jelölt helyen a megadott karakterek szerepelhetnek
                      • Példa:
                      • [abc]  a jelölt helyen a, b, vagy c lehet
                      • [a-z]  a jelölt helyen a-z-ig bármi lehet
                      • ( | )
                      • A jelölt helyen az egyik, vagy a másik formula is lehet.
                      • Példa: /(a | b)/g  a, vagy b karakterek keresése
              Reguláris kifejezések VII.
                      • Jelölő karakterek:
                      • \d  egy bármilyen szám karakter keresése
                      • \s  egy szóköz keresése
                      • \b  valaminek azzal kell kezdődnie, hogy (Begining with)
                      • \u  megadott Unicode karakter keresése
                      • .  a jelölt helyen egy bármilyen karakter lehet, kivéve
                        sortörés.
                      • Példa:
                      • /\d/g –y megadja milyen számok vannak a szövegben egyesével.
                        Reguláris kifejezések VIII.
                      • A formulákban mennyiségi megadások:
                      • +  a jelölt helyen legalább 1, de azt követően több ugyan olyan
                        formátumnak megfelelő karakter is lehet
                      • *  a jelölt helyen több ugyan olyan formátumnak megfelelő
                        karakter is lehet, akár 0 is.
                      • ?  a jelölt helyen legfeljebb egy karakter fele meg a formulának.
                      • Példa:
                      • „1200 Ft.” | a formula: /\d/g  1,2,0,0
                      • „1200 Ft.” | a formula: /\d+/g  1200
              Reguláris kifejezések VIII.
                      • Speciális jelölők:
                      • ^  a megadott formula csak a szöveg elejétől értelmezhető,
                        belsőleg nem.
                      • Példa: „Az összeg: 1200 Ft.” | a formula: /^\d+/  nem ad vissza semmit.
                      • $  a minta végén a szövegnek is véget kell érnie.
                      • Példa: „Az összeg: 1200 Ft.” | a formula: /\d+$/  nem ad vissza semmit.
                      • (?=)  opciós csoport, az adott helyen lehet ilyen is, de
                        nem lesz elkapva, tehát olyan csoport ami kitöltheti a formulák
                        közti helyet.
                      • Példa: „a 12 EMBER”  /[a-z]+(?=\d+)[A-Z]+/
              XML feldolgozás I.
                      • JavaScript-ben is fontos, hogy egy távoli kommunikáció (AJAX
                      hívás) során visszatérő strukturált adatot megfelelően fel
                      tudjon dolgozni.
                      • Az XML a világ egyik legelterjedtebb adatleíró nyelve, melyen
                      keresztül a kommunikáció lehetséges két végpont között.
                      • Így egyértelmű, hogy a JS-nek a HTML alapjául is szolgáló
                      XML-hez kell rendelkezzen beépített feldolgozóval.
             XML feldolgozás II.
                      • Az XML feldolgozása valójában nem is annyira nagy
                      kihívás a JS-nek, hiszen a HTML is egyfajta XML, így a
                      megoldás is annak megfelelően fog alakulni.
                      • A JS beépített XML feldolgozója a DOMParser, ami
                      lényegében teljese mértékben azonos funkcionalitással
                      rendelkezik mint a HTML feldolgozója (az is egyfajta
                      DOMParser)
            XML feldolgozás III.
                      • Az XML feldolgozása igen
                      egyszerű tehát, ha adott egy
                      szöveges állomány amiben a
                      megkapott XML formátumú adat
                      szerepel.
                      • A feldolgozás után indulhat az
                      XML szétszedése.
                      • Példa:
                      var xml = "";
                      var feldolgozo = new DOMParser();
                      xmlDoc =
                      feldolgozo.parseFromString(xml,
                      "text/xml");
            XML feldolgozás IV.
                      • A feldolgozás után kezdődhet az adatok
                      szétszedése.
                      • Alapvetően a logika szinte azonos a
                      document prototype használatával,
                      mindösszesen itt az id és class nem
                      alapértelmezett szűrők a felhasználás
                      során.
                      • A childNodes segítségével lekérdezhetjük
                      egy elem alá tartozó node-okat
                      • A nodeValue pedig az adott node belső,
                      szöveges értékét adja vissza.
            JSON feldolgozás I.
                      • A JSON (JavaScript Object Notation) egy hasonló
                      feladatra kialakított leíró nyelv mint az XML.
                      • Szerkezetét tekintve az XML-el szemben terse
                      leírónyelvnek minősül, ami azt jelenti, hogy a tömörítő
                      nyelvek családjába tartozik (csak úgy mint programozási
                      nyelvek tekintetében a C alapú nyelvek)
                      • A JSON elterjedésének fő oka a szerkezeti egyszerűsége.
            JSON feldolgozás II.
                      • A JSON alapvetően 3 szerkezeti elemre épül:
                      • Az object
                      • Jelölése: {…}
                      • Olyan komplex objektum mely más komplex és nem komplex adatokat
                      tartalmazhat.
                      • A tömb:
                      • Jelölése: […, …, …]
                      • Tömbösített adatok tárolására kialakított elem.
                      • Az attribútum:
                      • Jelölése: : <érték>
                      • Valójában maga a változó / adattároló megjelenítése a nyelvben.
            JSON feldolgozás III.
                      • Minden JSON fájl kapcsoszárójelek közötti adatokat
                      fognak tárolni. ({…})
                      • Ennek oka, hogy a JSON legfelsőbb szintje egy objektum kell
                      legyen, ami akár egy hipotetikus objektum is lehet, de abba
                      kell beletartozzon minden – hasonlóan az XML root node-
                      jához.
                      • A JSON fájlt, ugyan úgy mint az XML fájlt, szimpla text-
                      ként értelmezzük.
            JSON feldolgozás IV.
                      • A JSON felépítésében tehát a cél,
                      hogy a natív elemeket szimpla
                      értékként, a belső objektumokat
                      JSON object-ként és a belső
                      tömböket JSON array-ként
                      tároljuk.
                      • Így egy teljes objektum tárolható.
                      {
                      "type": "basket",
                      "beans": 47,
                      "apples": 7,
                      "oranges": 23,
                      "brand": "ConvertSimple",
                      "ratio": 33.9,
                      "fees": {
                      "cleaning": "$4.50",
                      "baking": "$27.30",
                      "commission": "$93.10"
                      },
                      "descriptors": ["clean", "fresh", "juicy",
                      "delicious"]
                      }
            JSON feldolgozás V.
                      • JavaScript-ben a JSON felhasználása alapvetően egy igen
                      egyszerű folyamat, hiszen a nyelvhez készült kifejezetten.
                      • Mivel alapvetően objektumok szerializációjára használjuk,
                      így a nyelv automatikusan le tudja generálni az
                      objektumok belső szerkezeti felépítményét JSON-ben és
                      vissza is tudja építeni azt.
                      • A prototípusok szerkezete pedig így könnyen menthető,
                      továbbítható stb. szövegesen.
            JSON feldolgozás VI.
                      • A JSON-t természetesen manuálisan is fel lehet dolgozni
                      ha szükséges, akár az XML-t habár beépített feldolgozó
                      alapvetően nincs rá – küldő megoldás viszont létezik és
                      létre is hozható.
                      • Azonban az esetek nagy részében erre nincs szükség,
                      hiszen a belső adatok előállítása és kimentése 1-1
                      függvénnyel megoldható a JSON segítségével.
            JSON feldolgozás VII.
                      • A JavaScript JSON prototípusa:
                      • JSON.parse("JSON");
                      • Egy megadott JSON anyagot konvertál belső objektumokká
                      • JSON.stringify();
                      • Egy megadott objektumot alakít JSON formátumúvá.
                      • Ezzel a két függvénnyel lehet ide-oda konvertálni a JS
                      belső objektumait.
            Aszinkron JavaScript II.
                      • Az aszinkron megoldásokhoz fontos megkötések:
                      • A végrehajtási sor alapvetően nem teljesen szekvenciális. Ezt már
                      eddig is tapasztalhattuk, hiszen az alprogramok megírási helye
                      nem befolyásolja azok lefutását, tehát a szekvenciális lefutás csak
                      a hívási sorban jelentkezik, nem a programkódban.
                      • A másik fontos megkötés, hogy a programkódnak hordozhatónak
                      kell lennie. A hordozhatóság legkisebb egységének pedig az
                      alprogramnak kell lennie.
                      • Ez sem újdonság az eddigiekhez képest, hiszen az eseményvezérlés és az
                      anonim függvények is Callback logika mentén működtek.
            Aszinkron JavaScript III.
                      • A JavaScript-ben jelenleg két alapvető párhuzamosítási
                      általános megoldás található meg:
                      • Promise (ígéret)
                      • Async/Await – nyelvi szintre emelt Promise
                      • Ezzel a kettővel lehet párhuzamosan végrehajtatni
                      általános kódokat – tehát nem timeout, vagy hasonló
                      specifikus megoldások esetében szoktuk használni.
            Aszinkron JavaScript IV.
                      • A Promise, avagy ígéret a nevét onnan kapta, hogy egy
                      olyan aszinkronos futtatóról van szó, mely Callback
                      függvények segítségével jelzi vissza, hogy valami sikeres,
                      avagy sem, így biztosan kapunk választ.
                      • Valójában egy köztes réteg, ami eltakarja az aszinkron
                      megoldás hátterét és összekapcsolja a szinkronos kódot az
                      aszinkronossal.
                      • Egy igen jól felhasználható eszköz párhuzamosításra.
            Aszinkron JavaScript V.
                      • A Promise egy prototype, melyet létre
                      tudunk hozni és meg tudjuk adni
                      benne a párhuzamosan futtatandó
                      kódot.
                      • A Promise-nak létrehozáskor egy
                      speciális függvényre van szükséges,
                      ami két funkciót vár:
                      • Az egyik akkor fut le a végeredményt
                      hordozva, ha minden rendben volt
                      • A másik pedig ha hiba lépett fel.
                      • Példa:
                      var prom = new Promise(function(megoldva,
                      hiba)
                      { megoldva(); //amikor sikerült
                      hiba(); //amikor nem sikerült
                      });
                      //…
                      prom.then(
                      function(eredmeny) { /*…*/ },
                      function(hibaEredmeny) { /*…*/ }
                      );
            Aszinkron JavaScript VI.
                      • A promise-t használhatjuk
                      szekvenciális aszinkron
                      ütemezőnek is, mivel minden
                      then(…) alprogramnak is Promise a
                      visszatérése.
                      • Így többször is futtathatjuk akár
                      más visszajelzésekkel az aszinkron
                      programot.
                      • Példa:
                      var prom = new Promise(function(megoldva,
                      hiba)
                      {
                      megoldva(); //amikor sikerült
                      hiba(); //amikor nem sikerült
                      });
                      //…
                      prom
                      .then(megoldva1Func, hiba1Func)
                      .then(megoldva2Func, hiba2Func)
                      .then(megoldva3Func, hiba3Func)
                      .then(megoldva4Func, hiba4Func);
            Aszinkron JavaScript VII.
                      • A Promise objektum a then-en
                      kívül még két másik alprogrammal
                      is rendelkezik:
                      • catch  elkapja általánosan a
                      hibákat.
                      • finally  lekezeli, hogy mi történjen
                      ha akár hiba, akár minden rendben
                      végbement.
                      • Példa:
                      var prom = new Promise(function(megoldva,
                      hiba)
                      {
                      megoldva(); //amikor sikerült
                      hiba(); //amikor nem sikerült
                      });
                      //…
                      prom
                      .then(megoldva1Func)
                      .then(megoldva2Func)
                      .then(megoldva3Func)
                      .then(megoldva4Func)
                      .catch(hibaGlobalFunc)
                      .finally(vegezetulGlobalFunc);
            Aszinkron JavaScript VIII.
                      • A Promise-nak van egy pár „flow control” funkciója is:
                      • Promise.all()  bevárja a tömbként átadott
                      Promise objektumokat és egy tömbként adja vissza azok
                      eredményét.
                      • Promise.any() bevárja az első lefutó Promise-t
                      a megadottak közül és annak eredményét adja vissza.
                      • Promise.race()  bevárja az első lefutó, vagy
                      hibára futó Promise-t a megadottak közül és annak eredményét,
                      vagy hibáját adja vissza.
            Aszinkron JavaScript IX.
                      • Természetesen az előző funkciókat is futtatni kell, a then-
                      el, hiszen egy keret Promise-ba rakjuk a többi Promise-t:
                      Aszinkron JavaScript X.
                      • A Promise-nak idő közben lett egy nyelvi szintű
                      alternatívája az async-await.
                      • Az async-await teljes mértékben ugyan úgy működik
                      mint a Promise (hiszen valójában az is), a különbség,
                      hogy nyelvi szinten került implementációra.
                      • Ennek megfelelően az async-await valójában nem új, csak
                      másabb megoldás az eddigiekhez képest.
            Aszinkron JavaScript XI.
                      • A felhasználása igen egyszerű, egy
                      async függvény mindig Promise
                      objektummal tér vissza, amit
                      szekvenciális oldalon bevárhatunk.
                      • Ennek megfelelően ez inkább csak
                      egy egyszerűsítés, mint sem egy
                      önálló működésű párhuzamosítás.
                      • Példa:
                      async function funkcio()
                      {
                      return "Helló világ!";
                      }
                      //Ezt bevárhatjuk akár úgy is, mint egy
                      Promise‐t:
                      funkcio.then(…);
                      //De nyelvi szinten is:
                      var eredmeny = await funkcio();
            

              A git felhasználása II.
                      • A git telepítése után, az első dolgunk, hogy meg kell
                      adni, hogy az adott user (aki használja a git-et) globálisan
                      kicsoda.
                      • Alapvetően a lépés kihagyható, de ebben az esetben
                      külön gondoskodni kellene róla minden egyes
                      alkalommal, hogy megadjuk, hogy ki hozta létre az adott
                      verziót, ami körülményes és nem is túl kifizetődő
                      hosszútávon.
              A git felhasználása III.
                      • A git felhasználó megadása:
                      • git config --global user.name ”felhasználó”
                      • git config --global user.email ”email cím”
                      • Ezek után vissza is lehet nézni a konfigurációt:
                      • git config --global --list
                      • Itt látszódnia kell a felhasználónknak miután létrehoztuk.
                      • Ezek után már elkezdhetjük a felhazsnálást.
              A git felhasználása IV.
                      • Amikor egy git-elt verziókezelést szeretnénk végrehajtani,
                      az első lépés, hogy létre kell hozni a verziókezelési alapot.
                      • Ez lesz a master repo, amely a kezdeti állapottól adja a
                      főszálat, mely a fő verziókezelési vonalat mutatja.
                      • A repo a repository-nk lesz, mely azt vezeti, hogy melyik
                      verzió mit változatott az előzőhöz képest. Természetesen az
                      első repo a legnagyobb, a többi ennek a módosulata lesz.
                      • A létrehozásnál az alap fájloknak már érdemes léteznie.
              A git felhasználása V.
                      • A master létrehozása:
                      • Be kell navigáljunk a mappába a cd parancs segítségével.
                      • Pl.: cd ”útvonal”
                      • Majd inicializáljuk a repository-nkat
                      • git init
                      • Ez automatikusan létrehozza az adott szinten a git repository-nakt.
                      • A létrehozás után a mappában jelenleg található mappák
                      és fájlok automatikusan nem feltétlen kerülnek bele a
                      repo-ba.
              A git felhasználása VI.
                      • Az, hogy jelenleg az adott repo pontosan mit tartalmaz
                      és hogy áll lekérdezhető:
                      • git status
                      • Ez megadja az adott repo-ra vetítve (az adott mappában
                      lévő repo-t figyelembe véve), hogy áll az adott repo.
                      • Itt azt is láthatjuk, hogy mely fájlok, hogy állnak
                      (kihagyva, friss, vagy láthatóan módosult)
              A git felhasználása VII.
                      • Ha valami hiányzik a repo-ból és szeretnénk hozzáadni, akkor
                      azt manuálisan kell megtegyük:
                      • git add 
                      • Ha mindent szeretnénk hozzáadni: git add -A
                      • Ezek után a git status már jelezni is fogja, hogy mit lát ezek
                      után a mappában.
                      • Természetesen előfordulhat, hogy valamire még sincs szükség
                      a repo-ban (pl. egy almappa, vagy egy fájl valahol)
              A git felhasználása VIII.
                      • Ha valamit szeretnénk kivenni a repoból:
                      • git rm --cached 
                      • git reset 
                      • A git reset kiveszi az indexből, de nem távolítja el a repo-ból – tehát
                      innentől nem veszi figyelembe a rendszer, a git rm viszont kitörli a
                      repo-ból.
                      • Mindezek mellett megadható az is, hogy valamit eleve ne
                      vegyen figyelembe a git a jövőben.
              A git felhasználása IX.
                      • A kivétel létrehozása:
                      • Az adott mappában, ahonnan
                      valamilyen szabályt szeretnénk
                      érvényesíteni (pl. az exe fájlok ne
                      kerüljenek a repo-ba innentől lefele)
                      létrehozunk egy .gitignore fájlt.
                      • A .gitignore fájlba megadható, hogy
                      mit és hol ne vegyen figyelme az adott
                      szinten és alatta a git.
                      • Ami elé „!” jelet teszünk az pont az
                      ellentétje, tehát azt ne zárja ki.
                      • Példa a fájl tartalmára:
                      *.exe
                      /debug
                      /config/*.log
                      !/config/main.log
              A git felhasználása X.
                      • Ha már hozzáadtuk a „figyelési listához” a fjálokat amiket
                      most már szeretnénk kivenni, akkor az indexből először is
                      törölni kell őket:
                      • git rm --cached 
                      • Többet nem is fogja feldobni a git, hogy ezek esetleg
                      hozzáadhatók lennének a repo-hoz.
                      • Amíg viszont nem töröljük a gitignore-t nem fogja a rendszer
                      érvényesíteni.
              A git felhasználása XI.
                      • Miután összeállt a végleges fájl/mappa lista amit
                      szeretnénk a repo-ba elrakni akkor létre kell hozni a repo
                      (első) zárását.
                      • git commit –m ””
                      • Ezzel létrejön egy verzió (első esetben az alap verzió).
                      • Innentől természetesen monitorozni lehet, hogy mi lett a
                      végeredmény a status lekérdezésével.
              Git visszavonás I.
                      • Természetesen a verziókezelés mit sem érne, ha nem tudnánk
                      egy előző verzióra visszaállni, vagy kivenni az előzményekből.
                      • A kivételhez, ahol csak valamit ki akarunk hagyni,
                      természetesen a git commit id-ját tudni kell.
                      • Ehhez tudnunk kell a git commit-okat amik eddig megtörténtek:
                      • git log –oneline
                      • Itt látnunk kell az eddigi commit-okat és minden commit az
                      első része maga az ID.
              Git visszavonás II.
                      • A kihagyandó elemet ezek után egyszerűen ki lehet venni:
                      • git revert 
                      • git revert  --no-edit
                      • Így nem kérdez rá a git, hogy egy újabb commit szöveget adj meg.
                      • Ez tehát azt a commit-ot, ami abban a commit-ban történt,
                      eltűntettük, de minden utána lévő commit megmarad.
                      • Természetesen teljesen visszatérhetünk előző változatokhoz,
                      ebben az esetben vagy elemenként visszalépdelünk, vagy
                      eleve visszalépünk valahova.
              Git visszavonás III.
                      • Az commit-onként való lépdelés logikája, ha valamilyen
                      megoldást keresünk, valami egy ideje nem működött pl. és mi
                      azt keressük, hogy ez mióta áll fent.
                      • Amennyiben viszont, csak vissza akarunk lépni egy előző
                      változatra úgy, hogy az összes előző változatot ki akarjuk
                      hagyni, mert pontosan tudjuk, hogy az utolsó N commit-ot
                      kell elhagyjuk:
                      • git reset --soft HEAD~
                      • Ahol a  helyére kell egy számot megadni, hogy az utolsó hány
                      commit legyen visszavonva.
              Git visszavonás IV.
                      • Minden esetre a visszavonással minden esetben vigyázzunk,
                      mert a visszavonás az esetek nagy részében már nem
                      visszavonható!
                      • A legjobb megoldás, hogy egy repo másolatban állunk vissza
                      egy előző változatra és amennyiben úgy találjuk, hogy minden
                      jó a visszaállás után utána törölhetjük a rossz irányba elszaladt
                      repo-nkat.
                      • Illetve fontos, hogy a visszavonás előtt ne legyen módosítás az
                      indexben (git status legyen üres a várakozások tekintetében).
              Git mellékágai I.
                      • A verziókezelés további fontos része a próbálkozás.
                      • Most már oda-vissza tudunk lépdelni a verziókban, de
                      vannak esetek amikor csoportok együtt működése, vagy
                      próbálkozások során előfordulhat olyan, hogy egy
                      mellékágat kell kezeljünk.
                      • A mellékágakkal két feladatunk lehet alapvetően:
                      • Leválasztani
                      • Összefűzni
              Git mellékágai II.
                      • A leválasztás (branching) egy elágazás, melynek
                      keretében egy adott pontról kiindulva tudunk új ágat
                      indítani.
                      • Ebben az ágban bármit csinálunk nem módosítja a
                      kiinduló ágat, így ebben szabadon próbálkozhatunk,
                      szabadon beemelhetünk csapatmunkában elvégzett
                      részeket mindenféle kockázat nélkül.
              Git mellékágai III.
                      • Az ág elindítása egyszerű:
                      • git branch  
                      • Ezzel létrejön egy új branch amelyikből megadjuk, amin
                      tudunk dolgozni attól a ponttól kiindulva.
                      • A létrehozás után természetesen át is kell állni az ágra.
                      • Az ágak között a git checkout segítségével mozoghatunk:
                      • git checkout 
                      • Természetesen a „main” név használatával tudunk a főszálra visszaállni.
              Git mellékágai IV.
                      • A git checkout –b opcióval akár átlépéssel egybekötött
                      átlépést is tudunk tenni:
                      • git checkout –b  
                      • A checkout parancs az adott mappában lévő repo-t arra a
                      branch-re állítja be amit kiválasztunk, így ezzel vigyázni
                      kell mielőtt ide-oda lépdelünk.
                      • Természetesen branch-ből is indítható további branch,
                      tehát nem csak a főág ágaztatható le.
              Git mellékágai V.
                      • Természetesen amikor egy ágban elérünk egy véglegesnek
                      mondható verziót, akkor összeolvaszthatjuk a nyitóággal:
                      • git merge 
                      • A forrás ágon kell álljunk és abba fogja beolvasztani a másik
                      ágat.
                      • Pl.:
                      • git checkout main  átállunk a főágra
                      • git merge mellekag  behúzzuk a mellékágat
              Git mellékágai V.
                      • Az összevonás során egyetlen probléma léphet fel, ha
                      conflict van a két ág között.
                      • A conflict akkor jöhet létre, ha a két ágon közben egymásnak
                      ellentmondó commit-ok mentek le egyező fájlokra
                      vonatkozóan.
                      • Ilyenkor a merge során fel fogja dobni, hogy ezeket látja
                      a két fájlban melyik maradjon meg.
              A Git online eszközei V.
                      • Amikor szeretnénk egy Git commit-ot feltölteni a
                      szerverre azt a push parancs segítségével lehet
                      megoldani.
                      • git push  
                      • A lokális ág megadása nem kötelező, ha a master-t szeretnénk
                      feltölteni.
                      • Amennyiben a célágra mindenképpen szeretnénk feltölteni a
                      commit-ot, akkor is ha bármilyen ütközés lenne:
                      • git push  --force
              A GitHub használata
                      Lehetőség és opciók a GitHub-on
                      Kis Balázs 14
                      A GitHub használata I.
                      • A GitHub a világ egyik legnépszerűbb Git alapú verziókezelő és
                      táv kód menedzsment eszköze.
                      • 2008-as indulását követően gyorsan terjedni kezdett, mivel a
                      nyílt forráskódú projekteknek nyújtott tárolási és verziókezelési
                      szolgáltatásokat.
                      • 2018-ban a Microsoft felvásárolta a GitHub-ot és még
                      népszerűbbé tette azáltal, hogy már zárt projekteket is
                      ingyenesen lehet rajta létrehozni.
                      • Mára több mint 84 millió fejlesztő, több mint 200 millió repo-ja
                      van rajta.
              A GitHub használata II.
                      • A GitHub a szimpla online Git repo tároláson kívül
                      rengeteg opcióval rendelkezik.
                      • A népszerűbbek:
                      • Dokumentáció létrehozása
                      • Projekt fejlesztői oldalának létrehozásával
                      • Probléma kezelési megoldásokkal
                      • Analitikai elemzésekkel
              A GitHub használata III.
                      • A GitHub-on Markdown leíró segítségével lehet
                      dokumentációt létrehozni.
                      • A Markdown egy dokumentum leíró nyelv (célja hasonló mint
                      a HTML-nek volt eredetileg), amely kifejezetten formázott
                      dokumentumok szövegesen jelölt változatát hozza létre.
                      • A projekt fejlesztői oldalát is létrehozhatjuk, ahol
                      alapvető dolgokat, telepítés, felépítés menetét, esetleg
                      tutorial-okat is publikálhatunk.
              A GitHub használata IV.
                      • A probléma kezelés (Issue Handling) is egy fontos része a
                      GitHub-nak.
                      • Lehet felvenni hibajegyet, vagy módosítási igényt, melyről a
                      fejlesztő csapat értesítést kap, majd ezt egy fórum jelleggel át
                      lehet beszélni és lehet jelölni is végül, hogy valami
                      implementálásra, javításra került, vagy nem.
                      • És végül az analitikai elemzések, melyek a kódbázist, a kód
                      tisztaságát, a fejlesztés gördülékenységét és egyéb infókat
                      tudnak elemezni.
              A GitHub használata V.
                      • A GitHub-on alapvetően ma már két fajta repo-t lehet
                      létrehozni:
                      • Privát színterű (Private repository)
                      • Ma már akármennyit létrehozhatunk ebből, de 1GB-nál nagyobb
                      méretű nem lehet ingyenes módban a repo.
                      • Publikus színterű (Public repository)
                      • Ennek nincs kifejezetten korlátja, ellenben ez mindenkinek elérhető,
                      hozzáférhető a teljes forráskód és verziók.