Merge pull request BonsaiDen#371 from munkacsimark/hungarian-typo-fixes

hungarian typos fixed

Author: peterjwest

doc/hu/array/constructor.md

@@ -10,7 +10,7 @@ ajánlott mindig a tömb literált - `[]` jelölés - használni új tömbök l
     new Array(3); // Eredmény: []
     new Array('3') // Eredmény: ['3']
 
-Abban az esetben, hogyha ez a konstruktor csak egy `szám` paramétert kap, akkor
+Abban az esetben, ha ez a konstruktor csak egy `szám` paramétert kap, akkor
 visszatérési értékül egy olyan tömböt fog létrehozni amelynek a `length` mezője
 akkorára van beállítva, ahogy azt megadtuk az argumentumban. Megjegyzendő hogy
 **csak** a `length` tulajdonság lesz ekkor beállítva; az egyes indexek külön-külön

doc/hu/array/general.md

@@ -13,7 +13,7 @@ lassabb mint egy sima `for` ciklus.
 
 ### Iteráció
 
-Annak érdekébern hogy a legjobb teljesítményt érjük el a tömbökön való iteráció során,
+Annak érdekében, hogy a legjobb teljesítményt érjük el a tömbökön való iteráció során,
 a legjobb hogyha a klasszikus `for` ciklust használjuk.
 
     var list = [1, 2, 3, 4, 5, ...... 100000000];
@@ -27,7 +27,7 @@ a `l = list.length` kifejezés használatával.
 Habár a `length` tulajdonság mindig magán a tömbön van definiálva, még mindig
 lehet egy kis teljesítmény kiesés amiatt hogy minden iterációban újra meg kell
 keresni ezt a tulajdonságot. Persze a legújabb JavaScript motorok **talán**
-használnak erre optimalizációt, de nem lehet biztosan megmondani hogy ahol a kódunk
+használnak erre optimalizációt, de nem lehet biztosan megmondani, hogy ahol a kódunk
 futni fog, az egy ilyen motor-e vagy sem.
 
 Valójában, a cachelés kihagyása azt eredményezheti, hogy a ciklusunk csak 

doc/hu/core/delete.md

@@ -41,7 +41,7 @@ Az expliciten beállított mezőket persze normálisan lehet törölni.
     obj.y; // undefined
 
 
-A fenti példábna az `obj.x` és `obj.y` törölhető, mivel nincs `DontDelete`
+A fenti példában az `obj.x` és `obj.y` törölhető, mivel nincs `DontDelete`
 attribútuma egyik mezőnek sem. Ezért működik az alábbi példa is.
 
     // működik, kivéve IE-ben
@@ -52,7 +52,7 @@ attribútuma egyik mezőnek sem. Ezért működik az alábbi példa is.
     GLOBAL_OBJECT.a; // undefined
 
 Itt egy trükköt használunk az `a` törlésére. A [`this`](#function.this) itt 
-a Globális objektumra mutat, és expliciten bezetjük rajta az `a` változót, mint
+a Globális objektumra mutat, és expliciten bevezetjük rajta az `a` változót, mint
 egy mezőjét, így törölni is tudjuk.
 
 Mint az szokás, a fenti kód egy kicsit bugos IE-ben (legalábbis 6-8-ig).
@@ -88,4 +88,4 @@ meghatározva az ES aktuális verziójú specifikációjában, pl. a window)
 ### Összegzésképp
 
 A `delete` működése helyenként megjósolhatatlan, így biztonsággal csak olyan
-objektumok mezőin használhatjuk amelyeket expliciten mi állítottunk be.
+objektumok mezőin használhatjuk, amelyeket expliciten mi állítottunk be.

doc/hu/core/eval.md

@@ -44,6 +44,6 @@ nem megbízható/ismeretlen.
 ### Összegzésül
 
 Soha ne használjunk `eval`t. Bármilyen kód működése, teljesítménye, ill. biztonsága
-megkérdőjelezhető amely használja ezt a nyelvi elemet. Semmilyen megoldás
+megkérdőjelezhető, amely használja ezt a nyelvi elemet. Semmilyen megoldás
 használata **nem ajánlott** amely első sorban `eval`ra épül. Ekkor egy *jobb
 megoldás* szükségeltetik, amely nem függ az `eval`tól.

doc/hu/core/semicolon.md

@@ -93,7 +93,7 @@ Az értelmező drasztikusan megváltoztatta a fenti kódot. A legtöbb esetben a
 beillesztő **rosszul** tippel.
 
 (A ford.: Semmilyen nyelvben sem jó, hogyha hagyjuk hogy a gép találja ki mit
-szerettünk volna írni. Néma gyereknek az anyja sem érti a kódját ugye)
+szerettünk volna írni. Néma gyereknek az anyja sem érti a kódját ugye.)
 
 ### Kezdő Zárójelek
 

doc/hu/function/arguments.md

@@ -22,12 +22,12 @@ Ez a kódrészlet egy új `Array` objektummá varázsolja az emlegetett `argumen
 
     Array.prototype.slice.call(arguments);
 
-De, ez a konverzió meglehetősen **lassú** így egyáltalán **nem ajánlott** teljesítmény kirtikus
+De, ez a konverzió meglehetősen **lassú**, így egyáltalán **nem ajánlott** teljesítmény kirtikus
 alkalmazások írásakor.
 
 ### Argumentumok kezelése
 
-A következő módszer ajánlott arra az esetre hogyha az egyik függvény paramétereit egy-az-egyben
+A következő módszer ajánlott arra az esetre, hogy ha az egyik függvény paramétereit egy-az-egyben
 át szeretnénk adni egy másik függvény számára.
 
     function foo() {
@@ -37,7 +37,7 @@ A következő módszer ajánlott arra az esetre hogyha az egyik függvény param
         // sok okos kód ide
     }
 
-Egy másik trükk arra hogy teljesen független wrapper függvényeket gyártsunk, a `call`
+Egy másik trükk arra, hogy teljesen független wrapper függvényeket gyártsunk, a `call`
 és `apply` együttes használata.
 
     function Foo() {}
@@ -83,7 +83,7 @@ egyik paraméterének ezt a nevet választjuk.
 
 Azonban a *getterek* és *setterek* mindig létrejönnek, de ez ne zavarjon meg minket, mert
 semmiféle befolyása nincs a teljesítményre, pláne olyan kódban ahol sokkal több mindennel
-is foglalkozunk mint az `arguments` objetkumhoz való hozzáférés.
+is foglalkozunk, mint az `arguments` objetkumhoz való hozzáférés.
 
 > **ES5 Megjegyzés:** Ezek a **getterek** és **setterek** nem jönnek létre strict módban.
 

doc/hu/function/closures.md

@@ -3,7 +3,7 @@
 A JavaScript nyelv egyik legerőteljesebb tulajdonsága a *closure*-ök használatában rejlik.
 Ezek használatával a hatókörök egymásba ágyazhatóak, és egy belső hatókör mindig hozzáfér
 az őt körülvevő, külső hatókör változóihoz. Miután JavaScriptben egyetlen dologgal lehet
-hatóköröket kifejezni, és ez a [funkció](#function.scopes) (bizony az if, try/catch és hasonló blokkok **nem** jelentenek új hatókört, mint pl. a Javaban), az összes funkció closure-ként szerepel.
+hatóköröket kifejezni, és ez a [függvény](#function.scopes) (bizony az if, try/catch és hasonló blokkok **nem** jelentenek új hatókört, mint pl. a Javaban), az összes funkció closure-ként szerepel.
 
 ### Privát változók emulálása
 
@@ -25,7 +25,7 @@ hatóköröket kifejezni, és ez a [funkció](#function.scopes) (bizony az if, t
     foo.get(); // 5
 
 Ebben a példában a `Counter` **két** closure-rel tér vissza: az `increment` és
-a `get` funkcióval. Mind a két funkció **referenciát** tárol a `Counter` hatókörre,
+a `get` függvénnyel. Mind a két függvény **referenciát** tárol a `Counter` hatókörre,
 és így mindketten hozzáférnek a `count` változóhoz, ami ebben a hatókörben lett
 definiálva.
 
@@ -46,7 +46,7 @@ létre fogja hozni, vagy felül fogja írni a *globális* `count` változót (wi
 
 ### Closure-ök használata ciklusokban
 
-Az egyik leggyakoribb hiba amit el lehet követni, az a closure-ök ciklusokban való használata.
+Az egyik leggyakoribb hiba, amit el lehet követni, az a closure-ök ciklusokban való használata.
 Annak is azon speciális esete amikor a ciklus indexváltozóját szeretnénk lemásolni a closure-ön belül.
 
     for(var i = 0; i < 10; i++) {
@@ -82,7 +82,7 @@ függvénnyel](#function.scopes).
 A külső (wrapper) névtelen függvény így azonnal meghívódik az `i` ciklusváltozóval, mint paraméterrel,
 és így mindig egy másolatot fog kapni az `i` változó **értékéről**, amit ő `e` néven emészt tovább.
 
-Így a `setTimeout`ban lévő névtelen fgv. mindig az `e` nevű referenciára fog mutatni, aminek az értéke így már **nem** változik meg a ciklus futása során.
+Így a `setTimeout`ban lévő névtelen függvény mindig az `e` nevű referenciára fog mutatni, aminek az értéke így már **nem** változik meg a ciklus futása során.
 
 Egy másik lehetséges út a megoldáshoz az, hogy egy wrapper függvényt visszatérítünk a setTimeoutból, aminek ugyanaz lesz a hatása, mint a fentebbi példának.
 

doc/hu/function/constructors.md

@@ -1,6 +1,6 @@
 ## Konstruktorok
 
-Csak úgy mint minden más, a konstruktorok működése szintén különbözik 
+Csak úgy, mint minden más, a konstruktorok működése szintén különbözik 
 a megszokottól. Itt minden függvényhívás amelyet a `new` kulcsszó előz meg, 
 konstruktor hívásnak számít.
 
@@ -19,7 +19,7 @@ Ha a konstruktor függvényben nincs `return` utasítás, akkor automatikusan a
 
     var test = new Foo();
 
-A fenti kódban a `Foo` függvényt mint konstruktort hívjuk meg, ami a test változóban
+A fenti kódban a `Foo` függvényt, mint konstruktort hívjuk meg, ami a test változóban
 egy új objektumot fog eredményezni. Ennek az objektumnak a `prototípusa` a Foo prototípusa lesz.
 
 Trükkös ugyan, de ha mégis van `return` utasítás az éppen konstruált függvényben, akkor
@@ -47,12 +47,12 @@ Hogyha kihagyjuk a `new` kulcsszó használatát, a függvény **nem** egy új o
     }
     Foo(); // undefined
 
-A [`this`](#function.this) JavaScript beli működésének köszönhetően, mégha le is
+A [`this`](#function.this) JavaScript beli működésének köszönhetően, még ha le is
 fut az előbbi kód, akkor a `this` helyére a *globális objektumot* képzeljük.
 
 ### Gyárak (Factory-k)
 
-Ahhoz, hogy teljesen eltudjuk hagyni a `new` kulcsszó használatát, a konstruktor
+Ahhoz, hogy teljesen el tudjuk hagyni a `new` kulcsszó használatát, a konstruktor
 függvény explicit értékkel kell visszatérjen.
 
     function Bar() {

doc/hu/function/general.md

@@ -1,7 +1,7 @@
 ## Függvény deklarációk és kifejezések
 
 A függvények JavaScriptben egyben objektumok is. Ez azt jelenti, hogy
-ugyanúgy lehet őket passzolgatni mint bármelyik más értékeket. Ezt a featuret
+ugyanúgy lehet őket passzolgatni, mint bármelyik más értékeket. Ezt a featuret
 gyakran használják arra, hogy egy *névtelen (callback) függvényt* átadjunk 
 egy másik -aszinkron- függvény paramétereként.
 
@@ -30,7 +30,7 @@ Habár ebben a példában a `var` deklaráció futás előtt a kód tetejére k
 ettől függetlenül a foo mint függvény meghívásakor hibát fogunk kapni.
 
 Ugyanis a deklaráció felkúszott, azonban az értékadás csak futásidőben fog megtörténni,
-addig is a foo változó értéke [undefined](#core.undefined) marad. Az undefinedet pedig hiába hívjuk függvényként, TypeErrort kapunk végeredményül.
+addig is a foo változó értéke [undefined](#core.undefined) marad. Az undefinedot pedig hiába hívjuk függvényként, TypeErrort kapunk végeredményül.
 
 ### Névvel ellátott függvény kifejezés
 

doc/hu/function/scopes.md

@@ -214,8 +214,8 @@ ahhoz hogy meghívhatóak legyenek, először ki kell értékelni őket.
     ) // a függvény objektum visszatérítése
     () // az eredmény meghívása
 
-Persze más kifejezések is használhatóak arra hogy kiértékeljük és meghívjuk
-a függvény kifejezést, amelyek habár szintaxisukban eltérnek, ugyanazt eredményezik.
+Persze más kifejezések is használhatóak arra, hogy kiértékeljük és meghívjuk
+a függvény kifejezést, amelyek habár szintaxisukban eltérnek, ugyan azt eredményezik.
 
     // Még több stílus anonymus függvények azonnali hívásához...
     !function(){}()

doc/hu/function/this.md

@@ -1,7 +1,7 @@
 ## A `this` mágikus működése
 
 A `this` kicsit másképp működik a JavaScriptben, mint ahogy azt megszokhattuk
-más nyelvekben. Ugyanis pontosan **ötféle** módja lehet annak, hogy a `this` 
+más nyelvekben. Ugyanis pontosan **öt féle** módja lehet annak, hogy a `this` 
 éppen mire utal a nyelvben.
 
 ### A Globális hatókör
@@ -40,7 +40,7 @@ az *újonnan létrehozott* `Objektumra` fog hivatkozni.
     foo.apply(bar, [1, 2, 3]); // ugyanaz mint egy sorral lejjebb
     foo.call(bar, 1, 2, 3); // argumentumok: a = 1, b = 2, c = 3
 
-A `Function.prototype`-ban levő `call` vagy `apply` használatakor aztán elszabadul a pokol :).
+A `Function.prototype`-ban levő `call` vagy `apply` használatakor aztán elszabadul a pokol 😀.
 Ezekben az esetekben ugyanis a this a foo hívásakor **egzaktan** be lesz állítva az apply/call
 első argumentumára. 
 

doc/hu/intro/index.md

@@ -2,7 +2,7 @@
 
 A **JavaScript Garden** egy folytonosan növekvő kódgyűjtemény amely a nyelv kihívást okozó részeit hivatott tisztázni. Itt tanácsokat kaphatsz afelől, hogyan kerüld el a leggyakoribb programozási- valamint nyelvi hibákat, hogyan írj gyorsabb kódot, és mik a legsűrűbben elkövetett *bad practice*k amelyekkel egy átlagos JavaScript programozó (nem) mindennapi útján találkozhat a nyelv megismerése közben. 
 
-A JavaScript Gardennek **nem** célja hogy megtanítsa a JavaScript nyelvet!
+A JavaScript Gardennek **nem** célja, hogy megtanítsa a JavaScript nyelvet!
 Az itt felsorolt témák megértéséhez mindenképp szükséges némi tapasztalat. Ha a nyelv alapjait szeretnéd elsajátítani, először nézd át ezt a kiváló [tutorialt][1] a Mozilla Developer Networkön.
 
 ## Szerzők

doc/hu/object/general.md

@@ -2,7 +2,7 @@
 
 A JavaScriptben minden objektumként működik, a [`null`](#core.undefined) és az [`undefined`](#core.undefined) kivételével.
 
-    false.toString(); // 'hamis'
+    false.toString(); // 'false'
     [1, 2, 3].toString(); // '1,2,3'
 
     function Foo(){}

doc/hu/object/hasownproperty.md

@@ -1,8 +1,8 @@
 ## `hasOwnProperty`
 
-Hogy megtudjuk nézni egy adott objektum saját mezőit - azokat a mezőket amelyek
+Hogy meg tudjuk nézni egy adott objektum saját mezőit - azokat a mezőket, amelyek
 az objektumon *közvetlenül* vannak definiálva, és nem valahol a 
-[prototípus láncon](#object.prototype) -, a `hasOwnProperty` függvényt használata 
+[prototípus láncon](#object.prototype) -, a `hasOwnProperty` függvény használata 
 ajánlott, amelyet az összes objektum amúgy is örököl az `Object.prototype`-ból.
 
 > **Megj.:** Vicces programozók miatt, **nem** biztos hogy elég lesz megnézni hogy 
@@ -58,4 +58,4 @@ A `hasOwnProperty` használata az **egyetlen** megbízható módszer annak eldö
 hogy egy mező közvetlenül az objektumon lett-e létrehozva. Melegen ajánlott a 
 `hasOwnProperty`-t **minden** [`for in` ciklusban](#object.forinloop) használni.
 Használatával ugyanis elkerülhetjük a kontár módon kiegészített natív prototípusokból
-fakadó esetleges hibákat, amire példát az imént láttunk.
+fakadó esetleges hibákat, amire az imént láttunk példát.

doc/hu/object/prototype.md

@@ -73,7 +73,7 @@ visszatérni.
 
 Alapjáraton, a JavaScript a prototype nevű mezőt használja a prototípus láncok
 kialakításához, de ettől függetlenül ez is ugyanolyan mező mint a többi, és 
-**bármilyen** értéket belehet neki állítani. Viszont a primitív típusokat egyszerűen
+**bármilyen** értéket be lehet neki állítani. Viszont a primitív típusokat egyszerűen
 figyelmen kívül fogja hagyni a feldolgozó.
 
     function Foo() {}
@@ -84,9 +84,9 @@ mezőkre és ezeknek az átállításával bele lehet szólni a prototípus lán
 
 ### Teljesítmény
 
-Értelemszerűen, minnél nagyobb a prototípus lánc, annál tovább tart egy-egy mező
+Értelemszerűen, minél nagyobb a prototípus lánc, annál tovább tart egy-egy mező
 felkeresése, és ez rossz hatással lehet a kód teljesítményére. Emellett, ha egy
-olyan mezőt próbálunk elérni amely nincs az adott objektum példányban, az mindig
+olyan mezőt próbálunk elérni, amely nincs az adott objektum példányban, az mindig
 a teljes lánc bejárását fogja eredményezni.
 
 Vigyázat! Akkor is bejárjuk a teljes láncot, amikor egy objektum mezőin próbálunk [iterálni](#object.forinloop).
@@ -98,7 +98,7 @@ definiált prototípust próbálunk kiegészíteni új kóddal.
 
 Ezt [monkey patching][1]-nek is hívják, és aktívan kerülendő, mivel megtöri 
 az *egységbe zárás* elvét. Habár ezt a technikát olyan népszerű framework-ök
-is használják mint a [Prototype][2], ettől függetlenül ne hagyjuk magunkat csőbe húzni;
+is használják, mint a [Prototype][2], ettől függetlenül ne hagyjuk magunkat csőbe húzni;
 nincs ésszerű indok arra, hogy összezavarjuk a beépített típusokat, további 
 *nem standard* saját funkcionalitással.