From 3ba3f9a7cd7a595ab24e4423405bf4df6c827727 Mon Sep 17 00:00:00 2001 From: Zoltan Sebestyen Date: Sat, 21 Jan 2017 16:39:07 +0100 Subject: [PATCH 01/13] various typo fixes --- doc/hu/function/general.md | 4 ++-- doc/hu/function/this.md | 14 +++++++------- doc/hu/object/forinloop.md | 8 ++++---- doc/hu/object/general.md | 8 ++++---- doc/hu/object/prototype.md | 2 +- 5 files changed, 18 insertions(+), 18 deletions(-) diff --git a/doc/hu/function/general.md b/doc/hu/function/general.md index 4392060e..4921d83e 100644 --- a/doc/hu/function/general.md +++ b/doc/hu/function/general.md @@ -9,7 +9,7 @@ egy másik -aszinkron- függvény paramétereként. function foo() {} -Ez a függvény felkerül a scope tetejére ([hoisting](#function.scopes)), mielőtt a kód végrehajtása megtörténne. Így abban a scopeban ahol *definiálták*, *mindenhol* elérhető, +Ez a függvény felkerül a scope tetejére ([hoisting](#function.scopes)), mielőtt a kód végrehajtása megtörténne. Így abban a scope-ban, ahol *definiálták*, *mindenhol* elérhető, még abban a trükkös esetben is, hogyha a kód azon pontján hívjuk ezt a függvényt, mielőtt definiáltuk volna (látszólag). @@ -41,7 +41,7 @@ Egy másik érdekes eset, amikor névvel ellátott függvényeket adunk érték } bar(); // ReferenceError -Ebben a példában a `bar`t önmagában nem lehet elérni egy külső scopeból (utolsó sor), +Ebben a példában a `bar`t önmagában nem lehet elérni egy külső scope-ból (utolsó sor), mivel egyből értékül adtuk a `foo` változónak. Ennek ellenére a `bar`on belül elérhető a `bar` név. A tanulság az, hogy a függvény önmagát *mindig* eléri a saját scopeján belül, és ez a JavaScriptben található [névfeloldásnak](#function.scopes) köszönhető. diff --git a/doc/hu/function/this.md b/doc/hu/function/this.md index 4b2efd74..b85a1819 100644 --- a/doc/hu/function/this.md +++ b/doc/hu/function/this.md @@ -1,20 +1,20 @@ ## 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` +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` éppen mire utal a nyelvben. ### A Globális hatókör this; -Amikor globális hatókörben van használva a this, akkor pontosan a *globális* objektumra utal. +Amikor globális hatókörben van használva a `this`, akkor pontosan a *globális* objektumra utal. ### Függvény híváskor foo(); -Itt, a `this` megint a *globális* objektumra fog utalni. +Itt a `this` megint a *globális* objektumra fog utalni. > **ES5 Megjegyzés:** Strict módban a globális eset **nem létezik** többé. > Ezekben az esetekben a `this` értéke undefined lesz. @@ -80,8 +80,8 @@ lokálisan elhelyezni a `method`-on belül, ami már valóban a kívánt `this`- }; A `that` tuladjonképpen egy mezei változónév (nem kulcsszó), de sokszor használják arra, -hogy egy másik `this`-re hivatkozzanak vele. A [colsureökkel](#function.closures) kombinálva -ez a módszer arra is használható hogy `this`-eket passzolgassunk a vakvilágban és mégtovább. +hogy egy másik `this`-re hivatkozzanak vele. A [closure-ökkel](#function.closures) kombinálva +ez a módszer arra is használható, hogy `this`-eket passzolgassunk a vakvilágban és még tovább. ### Eljárások értékül adása @@ -107,4 +107,4 @@ ami a nyelv egyik fő erőssége. new Bar().method(); Amikor a `method` meghívódik a `Bar` példányaként, a `this` pontosan a `Bar` -megfelelő példányára fog mutatni. \ No newline at end of file +megfelelő példányára fog mutatni. diff --git a/doc/hu/object/forinloop.md b/doc/hu/object/forinloop.md index b004e557..642dc265 100644 --- a/doc/hu/object/forinloop.md +++ b/doc/hu/object/forinloop.md @@ -1,13 +1,13 @@ ## A `for in` ciklus -Csak úgy mint a jó öreg `in` operátor, a `for in` is bejárja az egész +Csak úgy, mint a jó öreg `in` operátor, a `for in` is bejárja az egész prototípus láncot, amikor egy objektum mezőin próbálnánk iterálni. > **Megjegyzés:** A `for in` ciklus **nem** fog iterálni azokon a mezőkön, > amelyeknek az `enumerable` tulajdonsága `false`-ra van állítva. Például a > `length` mező nem kerül az iterációba amikor egy tömbön iterálnánk végig. - // Mérgezzük Object.prototypeot! + // Mérgezzük Object.prototype-ot! Object.prototype.bar = 1; var foo = {moo: 2}; @@ -32,10 +32,10 @@ lakó [`hasOwnProperty`](#object.hasownproperty) függvény használatával érh } } -Ez az egyetlen helyes útja annak hogy az objektum saját mezőin iteráljunk csak végig. +Ez az egyetlen helyes útja annak, hogy az objektum saját mezőin iteráljunk csak végig. Mivel a `hasOwnProperty`-t használjuk, így csak a várt `moo`-t fogja kiírni. Tehén jó kódunk van! Hogyha a `hasOwnProperty`-t kihagynánk, a kódunk ki lenne téve nem várt -hibáknak, amik pl. abból fakadnak hogy valaki ocsmányul kiterjesztette az +hibáknak, amik pl. abból fakadnak, hogy valaki ocsmányul kiterjesztette az `Object.prototype`-t. Például, ha a [Prototype][1] frameworköt használjuk, és nem ilyen stílusban írjuk a diff --git a/doc/hu/object/general.md b/doc/hu/object/general.md index 8f396de4..296ddf3c 100644 --- a/doc/hu/object/general.md +++ b/doc/hu/object/general.md @@ -1,6 +1,6 @@ ## Objektumok és mezők használata -A JavaSciprtben minden objektumként működik, a [`null`](#core.undefined) és az [`undefined`](#core.undefined) kivételével. +A JavaScriptben minden objektumként működik, a [`null`](#core.undefined) és az [`undefined`](#core.undefined) kivételével. false.toString(); // 'hamis' [1, 2, 3].toString(); // '1,2,3' @@ -47,11 +47,11 @@ Egy objektum mezői kétféle módon érhetőek el, vagy az 'objektum.mezőnév' foo.1234; // SyntaxError foo['1234']; // működik -A két jelölés majdnem egyenértékűen használható, kivéve, hogy a szögletes zárójelekkel dinamkusan állíthatunk be mezőket és olyan neveket is választhatunk, amik amúgy szintaxis hibához vezetnének (Fordító: mivel a neveket stringbe kell rakni, megadhatunk a JS által "lefoglalt" kulcsszavakat is mezőnévként, habár ennek használata erősen kerülendő). +A két jelölés majdnem egyenértékűen használható, kivéve, hogy a szögletes zárójelekkel dinamikusan állíthatunk be mezőket és olyan neveket is választhatunk, amik amúgy szintaxis hibához vezetnének (Fordító: mivel a neveket stringbe kell rakni, megadhatunk a JS által "lefoglalt" kulcsszavakat is mezőnévként, habár ennek használata erősen kerülendő). ### Mezők törlése -Egyetlen módon lehet mezőt törölni egy objektumból ez pedig a `delete` operátor +Egyetlen módon lehet mezőt törölni egy objektumból, ez pedig a `delete` operátor használata; a mező értékének `undefined`-ra vagy `null`-ra való állítása csak magára az értékre van kihatással, de a kulcs ugyanúgy megmarad az objektumban. @@ -84,7 +84,7 @@ Az objektumok mezőnevei mind stringként, mind egyszerű szövegként (Ford.: a leírhatóak. A JavaScript értelmező hibája miatt, a fenti kód azonban `SyntaxErrort` eredményez ECMAScript 5 előtti verzió esetén. Ez a hiba onnan ered, hogy a `delete` egy *kulcsszó*, viszont érdemes *string literálként* -leírni hogy helyesen megértsék a régebbi JavaScript motorok is. +leírni, hogy helyesen megértsék a régebbi JavaScript motorok is. [1]: http://en.wikipedia.org/wiki/Hashmap diff --git a/doc/hu/object/prototype.md b/doc/hu/object/prototype.md index 95e45b3c..8d86f42a 100644 --- a/doc/hu/object/prototype.md +++ b/doc/hu/object/prototype.md @@ -4,7 +4,7 @@ A JavaScript nem a klasszikus öröklődést használja, hanem egy ún. *protot származtatást használ. Míg ezt gyakran a JavaScript legnagyobb hibái között tartják számon, valójában -ez a származtatási modell jóval kifejezőbb mint klasszikus barátja. +ez a származtatási modell jóval kifejezőbb, mint klasszikus barátja. Ezt jelzi, hogy például sokkal könnyebb megépíteni a klasszikus modellt, alapul véve a prototípusos modellt, míg a fordított irány kivitelezése igencsak nehézkes lenne. From cdfd71d8659010f9b8cbbf7bad1d369f2b71d999 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=92=9F=E6=99=93=E4=BB=95?= Date: Mon, 13 Feb 2017 21:16:27 -0600 Subject: [PATCH 02/13] fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 这里应该是 “未”，而不是 “为” --- doc/zh/types/typeof.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/zh/types/typeof.md b/doc/zh/types/typeof.md index f7a6cc1e..fec6fcf7 100755 --- a/doc/zh/types/typeof.md +++ b/doc/zh/types/typeof.md @@ -75,7 +75,7 @@ JavaScript 标准文档只给出了一种获取 `[[Class]]` 值的方法，那 Object.prototype.toString.call(undefined) // "[object Undefined]" -###测试为定义变量 +###测试未定义变量 typeof foo !== 'undefined' From ea285dafe028fcccb3f77d0b225c46b4d522a1ef Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?=E9=92=9F=E6=99=93=E4=BB=95?= Date: Tue, 14 Feb 2017 02:43:24 -0600 Subject: [PATCH 03/13] fix typo MIME-Version: 1.0 Content-Type: text/plain; charset=UTF-8 Content-Transfer-Encoding: 8bit 这里应该用 “到” 更加准确 --- doc/zh/other/timeouts.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/zh/other/timeouts.md b/doc/zh/other/timeouts.md index 7810b39f..4b2cc5d0 100755 --- a/doc/zh/other/timeouts.md +++ b/doc/zh/other/timeouts.md @@ -101,7 +101,7 @@ } bar(); -由于 `eval` 在这种情况下不是被[直接](#core.eval)调用，因此传递到 `setTimeout` 的字符串会自*全局作用域*中执行； +由于 `eval` 在这种情况下不是被[直接](#core.eval)调用，因此传递到 `setTimeout` 的字符串会到*全局作用域*中执行； 因此，上面的回调函数使用的不是定义在 `bar` 作用域中的局部变量 `foo`。 建议**不要**在调用定时器函数时，为了向回调函数传递参数而使用字符串的形式。 From dc21512f72fe664d1b96d502eaa70f81aaf6d0df Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Munk=C3=A1csi=20M=C3=A1rk?= Date: Thu, 27 Jul 2017 17:31:40 +0200 Subject: [PATCH 04/13] hungarian typos fixed --- doc/hu/array/constructor.md | 2 +- doc/hu/array/general.md | 4 ++-- doc/hu/core/delete.md | 6 +++--- doc/hu/core/eval.md | 2 +- doc/hu/core/semicolon.md | 2 +- doc/hu/function/arguments.md | 8 ++++---- doc/hu/function/closures.md | 8 ++++---- doc/hu/function/constructors.md | 8 ++++---- doc/hu/function/general.md | 4 ++-- doc/hu/function/scopes.md | 4 ++-- doc/hu/function/this.md | 4 ++-- doc/hu/intro/index.md | 2 +- doc/hu/object/general.md | 2 +- doc/hu/object/hasownproperty.md | 6 +++--- doc/hu/object/prototype.md | 8 ++++---- doc/hu/other/timeouts.md | 24 ++++++++++++------------ doc/hu/types/casting.md | 6 +++--- doc/hu/types/equality.md | 12 ++++++------ doc/hu/types/instanceof.md | 4 ++-- doc/hu/types/typeof.md | 2 +- 20 files changed, 59 insertions(+), 59 deletions(-) diff --git a/doc/hu/array/constructor.md b/doc/hu/array/constructor.md index 444644a0..57a5a9ca 100644 --- a/doc/hu/array/constructor.md +++ b/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 diff --git a/doc/hu/array/general.md b/doc/hu/array/general.md index 660bb3b3..f7fa98e4 100644 --- a/doc/hu/array/general.md +++ b/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 diff --git a/doc/hu/core/delete.md b/doc/hu/core/delete.md index 859a3537..89b95b41 100644 --- a/doc/hu/core/delete.md +++ b/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. \ No newline at end of file +objektumok mezőin használhatjuk, amelyeket expliciten mi állítottunk be. \ No newline at end of file diff --git a/doc/hu/core/eval.md b/doc/hu/core/eval.md index b2c83d45..9de5d3b3 100644 --- a/doc/hu/core/eval.md +++ b/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. \ No newline at end of file diff --git a/doc/hu/core/semicolon.md b/doc/hu/core/semicolon.md index 0241234f..fddd1acf 100644 --- a/doc/hu/core/semicolon.md +++ b/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 diff --git a/doc/hu/function/arguments.md b/doc/hu/function/arguments.md index d7b77ec0..0a0a1e6f 100644 --- a/doc/hu/function/arguments.md +++ b/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. diff --git a/doc/hu/function/closures.md b/doc/hu/function/closures.md index 436f58e2..33d4e3bd 100644 --- a/doc/hu/function/closures.md +++ b/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. diff --git a/doc/hu/function/constructors.md b/doc/hu/function/constructors.md index e48e0b60..c955cce1 100644 --- a/doc/hu/function/constructors.md +++ b/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() { diff --git a/doc/hu/function/general.md b/doc/hu/function/general.md index 4921d83e..9b62b0ee 100644 --- a/doc/hu/function/general.md +++ b/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 diff --git a/doc/hu/function/scopes.md b/doc/hu/function/scopes.md index 71c99902..7e75a0b5 100644 --- a/doc/hu/function/scopes.md +++ b/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(){}() diff --git a/doc/hu/function/this.md b/doc/hu/function/this.md index b85a1819..8c363873 100644 --- a/doc/hu/function/this.md +++ b/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. diff --git a/doc/hu/intro/index.md b/doc/hu/intro/index.md index 911baf61..83bb9b94 100644 --- a/doc/hu/intro/index.md +++ b/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 diff --git a/doc/hu/object/general.md b/doc/hu/object/general.md index 296ddf3c..0032e735 100644 --- a/doc/hu/object/general.md +++ b/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(){} diff --git a/doc/hu/object/hasownproperty.md b/doc/hu/object/hasownproperty.md index 46d713e8..245a3287 100644 --- a/doc/hu/object/hasownproperty.md +++ b/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. \ No newline at end of file +fakadó esetleges hibákat, amire az imént láttunk példát. \ No newline at end of file diff --git a/doc/hu/object/prototype.md b/doc/hu/object/prototype.md index 8d86f42a..27a533b4 100644 --- a/doc/hu/object/prototype.md +++ b/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. diff --git a/doc/hu/other/timeouts.md b/doc/hu/other/timeouts.md index 36c17e56..7ad37665 100644 --- a/doc/hu/other/timeouts.md +++ b/doc/hu/other/timeouts.md @@ -3,16 +3,16 @@ Mivel a JavaScript aszinkron, a `setTimeout` és `setInterval` használatával lehetséges késleltetni a kódok lefutási idejét. -> **Megjegyzés:** A timeout fv.-ek **nem** részei az ECMAScript Standardnek. +> **Megjegyzés:** A timeout függvények **nem** részei az ECMAScript Standardnek. > Mivel a [DOM][1] részeként lettek implementálva. function foo() {} var id = setTimeout(foo, 1000); // Egy számmal (> 0) tér vissza -Amikor a `setTimeout` függvényt meghívjuk, válaszul egy timeout ID-t kapunk +Amikor a `setTimeout` függvényt meghívjuk, válaszul egy timeout ID-t kapunk, valamint be lesz ütemezve a `foo` függvényhívás, hogy **körülbelül** 1000 miliszekundum múlva fusson le a jövőben. A `foo` **egyszer** lesz végrehajtva. -Az aktuális JavaScript motor időzítésétől függően, és annak figyelembe vételével +Az aktuális JavaScript motor időzítésétől függően, és annak figyelembe vételével, hogy a JavaScript mindig egyszálú, tehát a megelőző kódok blokkolhatják a szálat, **soha** nem lehet biztonságosan meghatározni hogy valóban a kért időzítéssel fog lefutni a kód amit megadtunk a `setTimeout`ban. Erre semmilyen biztosíték nincs. @@ -40,8 +40,8 @@ utal. ### Híváshalmozás a `setInterval`al -Míg a `setTimeout` csak egyszer futtatja le a megadott függvényt, a `setInterval` -- ahogy a neve is mutatja - **minden** `X` miliszekundumban végrehajtja a +Míg a `setTimeout` csak egyszer futtatja le a megadott függvényt, a `setInterval` - +ahogy a neve is mutatja - **minden** `X` miliszekundumban végrehajtja a neki átadott kódot, használata pedig erősen kerülendő. Nagy hátulütője, hogy még akkor is ütemezi az újabb és újabb @@ -62,7 +62,7 @@ futtatása először végzett. ### Hogyan Bánjunk El a Blokkolással -A legkönnyebb és kontrollálhatóbb megoldásnak az bizonyul, hogyha a `setTimeout` +A legkönnyebb és kontrollálhatóbb megoldásnak az bizonyul, ha a `setTimeout` függvényt a rögtön a foo-n belül használjuk. function foo(){ @@ -72,13 +72,13 @@ függvényt a rögtön a foo-n belül használjuk. foo(); Ez nem csak egységbe zárja a `setTimeout` hívást, de meggátolja a felesleges hívások -felhalmozását, és több irányítást ad a kezünkbe. A `foo` így magától eltudja +felhalmozását, és több irányítást ad a kezünkbe. A `foo` így magától el tudja dönteni, hogy akarja-e újra futtatni önmagát vagy sem. ### Timeout Tisztogatás Kézzel A `clearTimeout` vagy `clearInterval` hívással tudjuk a timeoutjainkat -megszüntetni, természetesen attól függ hogy melyiket használjuk, +megszüntetni, természetesen attól függ, hogy melyiket használjuk, hogy melyik `set` függvénnyel indítottuk útjára a timeoutunkat. var id = setTimeout(foo, 1000); @@ -94,7 +94,7 @@ hívás törlésére, ezért bruteforce módszerekhez kell folyamodjunk. clearTimeout(i); } -Persze ez csak véletlenszerű lövöldözés, semmi sem garantálja hogy a fenti +Persze ez csak véletlenszerű lövöldözés, semmi sem garantálja, hogy a fenti módszerrel nem marad timeout a rendszerben (A ford.: például az ezredik timeout vagy afelett). Szóval egy másik módszer ennek megoldására, hogy feltételezzük hogy minden `setTimeout` hívással az azonosítók száma egyel növekszik. @@ -106,8 +106,8 @@ minden `setTimeout` hívással az azonosítók száma egyel növekszik. clearTimeout(i); } -Habár ez a megoldás minden böngészőben megy (egyenlőre), ez az azonosítókról született mondás nincs specifikációban rögzítve, és ennek megfelelően változhat. -Az ajánlott módszer továbbra is az, hogy kövessük nyomon az összes timeout azonosítót amit generáltunk, és így ki is tudjuk őket rendesen törölni. +Habár ez a megoldás minden böngészőben megy (egyelőre), ez az azonosítókról született mondás nincs specifikációban rögzítve, és ennek megfelelően változhat. +Az ajánlott módszer továbbra is az, hogy kövessük nyomon az összes timeout azonosítót, amit generáltunk, és így ki is tudjuk őket rendesen törölni. ### `eval` A Színfalak Mögött @@ -158,7 +158,7 @@ a timeout függvények által meg lesz hívva a későbbiekben. **Soha** ne használjunk stringeket a `setTimeout` vagy `setInterval` első paramétereiként. Ha argumentumokat kell átadni a meghívandó függvénynek, az egyértelműen **rossz** kódra utal. Ebben az esetben a függvényhívás -lebonyolításához egy *anoním* függvény használata ajánlott. +lebonyolításához egy *anonim* függvény használata ajánlott. Továbbá, mivel az ütemező kódja nem blokkolódik a JavaScript futás által, a `setInterval` használata úgy általában kerülendő. diff --git a/doc/hu/types/casting.md b/doc/hu/types/casting.md index b5066ca5..ee604410 100644 --- a/doc/hu/types/casting.md +++ b/doc/hu/types/casting.md @@ -26,14 +26,14 @@ meglepetéseket. ### Natív típusok konstruktorai -A jó hír az, hogy a natív típusok mint a `Number` és a `String` különféle -módon viselkednek hogyha a `new` kulcsszóval avagy anélkül vannak inicializálva. +A jó hír az, hogy a natív típusok, mint a `Number` és a `String` különféle +módon viselkednek, hogy ha a `new` kulcsszóval avagy anélkül vannak inicializálva. new Number(10) === 10; // Hamis, Objektum vs. Szám Number(10) === 10; // Igaz, Szám vs. szám new Number(10) + 0 === 10; // Igaz, az implicit konverziónak hála -Ha egy natív típust mint a `Number` konstruktorként kezelünk, akkor egy új +Ha egy natív típust, mint a `Number` konstruktorként kezelünk, akkor egy új `Number` objektumot kapunk. De ha kihagyjuk a `new` kulcsszót akkor a `Number` egy egyszerű konverter függvényként fog viselkedni. diff --git a/doc/hu/types/equality.md b/doc/hu/types/equality.md index 0b503294..d627e86c 100644 --- a/doc/hu/types/equality.md +++ b/doc/hu/types/equality.md @@ -7,7 +7,7 @@ vizsgálatára Az egyenlőség vizsgálatot végző (egyik) operátort így jelöljük: `==` -A JavaScript egy *gyengén típusos* nyelv. Ez azt jelenti hogy az egyenlőség +A JavaScript egy *gyengén típusos* nyelv. Ez azt jelenti, hogy az egyenlőség operátor **típuskényszerítést** alkalmaz ahhoz, hogy össze tudjon hasonlítani két értéket. @@ -21,9 +21,9 @@ két értéket. null == undefined // igaz " \t\r\n" == 0 // igaz -A fenti táblázat szépen mutatja hogy mi a típuskényszerítés eredménye, és egyben +A fenti táblázat szépen mutatja, hogy mi a típuskényszerítés eredménye, és egyben azt is, hogy miért rossz szokás a `==` használata. Szokás szerint, ez megint -olyan fícsör ami nehezen követhető kódhoz vezethet a komplikált konverziós +olyan fícsör, ami nehezen követhető kódhoz vezethet a komplikált konverziós szabályai miatt. Pláne, hogy a kényszerítés teljesítmény problémákhoz is vezet; ugyanis, mielőtt @@ -34,7 +34,7 @@ a megfelelő típusra. Ez az operátor már **három** egyenlőségjelből áll: `===`. -Ugyanúgy működik mint az előbbi, kivéve hogy ez a változat **nem** alkalmaz +Ugyanúgy működik, mint az előbbi, kivéve hogy ez a változat **nem** alkalmaz típuskényszerítést az operandusai között. "" === "0" // hamis @@ -49,12 +49,12 @@ típuskényszerítést az operandusai között. A felső eredmények sokkal egyértelműbbek és ennek köszönhetően sokkal hamarabb eltörik a kód egy-egy ellenőrzésen. Ettől sokkal hibatűrőbb lesz -a produktumunk, és ráadásul teljesítménybeli gondjaink sem lesznek. +a produktumunk, ráadásul teljesítménybeli gondjaink sem lesznek. ### Objektumok összehasonlítása Habár mind a `==`-t és a `===`-t is egyenlőség operátornak hívjuk, eltérően -viselkednek hogyha legalább az egyik operandusuk egy objektum. +viselkednek, hogy ha legalább az egyik operandusuk egy objektum. {} === {}; // hamis new String('foo') === 'foo'; // hamis diff --git a/doc/hu/types/instanceof.md b/doc/hu/types/instanceof.md index 82f5942d..50dbd489 100644 --- a/doc/hu/types/instanceof.md +++ b/doc/hu/types/instanceof.md @@ -2,7 +2,7 @@ Az `instanceof` operátor a két operandusának konstruktorait hasonlítja össze. Csak akkor bizonyul hasznosnak, amikor saját készítésű objektumokon alkalmazzuk. -Beépített típusokon ugyanolyan hasztalan alkalmazni mint a [typeof operátort](#types.typeof). +Beépített típusokon ugyanolyan hasztalan alkalmazni, mint a [typeof operátort](#types.typeof). ### Saját objektumok összehasonlítása @@ -32,4 +32,4 @@ a böngészőn belül), mivel a konstruktoruk nem pontosan ugyanaz az objektum l ### Összegzésül -Az `instanceof`-ot tehát **csak** megegyező JS kontextusból származó, saját készítésű objektumoknál használjuk. Minden más felhasználása kerülendő, csak úgy mint a [`typeof`](#types.typeof) operátor esetén. \ No newline at end of file +Az `instanceof`-ot tehát **csak** megegyező JS kontextusból származó, saját készítésű objektumoknál használjuk. Minden más felhasználása kerülendő, csak úgy, mint a [`typeof`](#types.typeof) operátor esetén. \ No newline at end of file diff --git a/doc/hu/types/typeof.md b/doc/hu/types/typeof.md index b39070fd..556543dc 100644 --- a/doc/hu/types/typeof.md +++ b/doc/hu/types/typeof.md @@ -5,7 +5,7 @@ lehetőség szerint a JavaScript nyelv egyik legnagyobb buktatója, mivel majdne teljesen **rosszul működik**. Habár az `instanceof`-nak korlátozottan még lehet értelme, a `typeof` operátor -tényleg csak egyetlen praktikus use case-zel rendelkezik és ez **nem** az hogy egy +tényleg csak egyetlen praktikus use case-el rendelkezik és ez **nem** az, hogy egy objektum típusvizsgálatát elvégezzük. > **Megjegyzés:** Mivel a `typeof` vizsgálatot ravaszul úgy is le lehet írni, From 0fa71491cfd2142152913f50edae94a42981802f Mon Sep 17 00:00:00 2001 From: Siddharth Kshetrapal Date: Mon, 9 Oct 2017 15:47:03 +0530 Subject: [PATCH 05/13] Change foobar to slightly better variables --- doc/en/object/general.md | 38 +++++++++++++++++++------------------- 1 file changed, 19 insertions(+), 19 deletions(-) diff --git a/doc/en/object/general.md b/doc/en/object/general.md index 5ee2e0de..864dda5a 100644 --- a/doc/en/object/general.md +++ b/doc/en/object/general.md @@ -6,9 +6,9 @@ Everything in JavaScript acts like an object, with the only two exceptions being false.toString(); // 'false' [1, 2, 3].toString(); // '1,2,3' - function Foo(){} - Foo.bar = 1; - Foo.bar; // 1 + function sayHello(){} + sayHello.bar = 1; + sayHello.bar; // 1 A common misconception is that number literals cannot be used as objects. That is because a flaw in JavaScript's parser tries to parse the *dot @@ -32,25 +32,25 @@ Using an object literal - `{}` notation - it is possible to create a plain object. This new object [inherits](#object.prototype) from `Object.prototype` and does not have [own properties](#object.hasownproperty) defined. - var foo = {}; // a new empty object + var names = {}; // a new empty object - // a new object with a 'test' property with value 12 - var bar = {test: 12}; + // a new object with a 'name' property with value 'Rob' + var rob = {name: 'Rob'}; ### Accessing Properties The properties of an object can be accessed in two ways, via either the dot notation or the square bracket notation. - var foo = {name: 'kitten'} - foo.name; // kitten - foo['name']; // kitten + var pet = {name: 'kitten'} + pet.name; // kitten + pet['name']; // kitten var get = 'name'; - foo[get]; // kitten + pet[get]; // kitten - foo.1234; // SyntaxError - foo['1234']; // works + pet.1234; // SyntaxError + pet['1234']; // works The notations work almost identically, with the only difference being that the square bracket notation allows for dynamic setting of properties and @@ -63,13 +63,13 @@ operator; setting the property to `undefined` or `null` only removes the *value* associated with the property, but not the *key*. var obj = { - bar: 1, - foo: 2, - baz: 3 + a: 1, + b: 2, + c: 3 }; - obj.bar = undefined; - obj.foo = null; - delete obj.baz; + obj.a = undefined; + obj.b = null; + delete obj.c; for(var i in obj) { if (obj.hasOwnProperty(i)) { @@ -77,7 +77,7 @@ operator; setting the property to `undefined` or `null` only removes the } } -The above outputs both `bar undefined` and `foo null` - only `baz` was +The above outputs both `a undefined` and `b null` - only `c` was removed and is therefore missing from the output. ### Notation of Keys From ebcf110edcbaffe2febe2be9fe0e51b0138400f2 Mon Sep 17 00:00:00 2001 From: Siddharth Kshetrapal Date: Mon, 9 Oct 2017 20:25:27 +0530 Subject: [PATCH 06/13] Missed a bar --- doc/en/object/general.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/en/object/general.md b/doc/en/object/general.md index 864dda5a..41450da2 100644 --- a/doc/en/object/general.md +++ b/doc/en/object/general.md @@ -7,8 +7,8 @@ Everything in JavaScript acts like an object, with the only two exceptions being [1, 2, 3].toString(); // '1,2,3' function sayHello(){} - sayHello.bar = 1; - sayHello.bar; // 1 + sayHello.numberOfTimes = 1; + sayHello.numberOfTimes; // 1 A common misconception is that number literals cannot be used as objects. That is because a flaw in JavaScript's parser tries to parse the *dot From 624a9e62d649ab9b0fed39ed7f78c350316b6cf4 Mon Sep 17 00:00:00 2001 From: Siddharth Kshetrapal Date: Mon, 9 Oct 2017 23:00:58 +0530 Subject: [PATCH 07/13] replace numberOfTimes to count --- doc/en/object/general.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/doc/en/object/general.md b/doc/en/object/general.md index 41450da2..89589229 100644 --- a/doc/en/object/general.md +++ b/doc/en/object/general.md @@ -7,8 +7,8 @@ Everything in JavaScript acts like an object, with the only two exceptions being [1, 2, 3].toString(); // '1,2,3' function sayHello(){} - sayHello.numberOfTimes = 1; - sayHello.numberOfTimes; // 1 + sayHello.count = 1; + sayHello.count; // 1 A common misconception is that number literals cannot be used as objects. That is because a flaw in JavaScript's parser tries to parse the *dot From ee3407cd3b38e06c7f2bad1b61c3c0feb744cf7f Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?J=C3=A9r=C3=A9my=20Mouzin?= Date: Fri, 30 Mar 2018 17:57:56 +0200 Subject: [PATCH 08/13] Fix missing spaces in the footer --- garden.jade | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/garden.jade b/garden.jade index bd191d39..bb67c1d1 100644 --- a/garden.jade +++ b/garden.jade @@ -79,10 +79,10 @@ html(lang=language) footer p Copyright ©. Built with | - a(href='http://nodejs.org/') Node.js - | using a - a(href='https://github.com/visionmedia/jade/') jade - | template. + a(href='http://nodejs.org/') Node.js + | using a + a(href='https://github.com/visionmedia/jade/') jade + | template. script(src='http://ajax.googleapis.com/ajax/libs/jquery/1.5.1/jquery.min.js') From 2c7a3a61148c2d41ed07c76b12b410880e22883a Mon Sep 17 00:00:00 2001 From: a90100 Date: Sat, 14 Mar 2020 15:32:50 +0800 Subject: [PATCH 09/13] Fixed zhtw typo & translated chapter this into zhtw --- doc/zhtw/array/constructor.md | 2 +- doc/zhtw/array/general.md | 6 ++--- doc/zhtw/core/undefined.md | 2 +- doc/zhtw/function/arguments.md | 4 ++-- doc/zhtw/function/scopes.md | 2 +- doc/zhtw/function/this.md | 41 +++++++++++++--------------------- doc/zhtw/object/general.md | 2 +- doc/zhtw/types/instanceof.md | 4 ++-- doc/zhtw/types/typeof.md | 6 ++--- 9 files changed, 29 insertions(+), 40 deletions(-) diff --git a/doc/zhtw/array/constructor.md b/doc/zhtw/array/constructor.md index 6c66656d..fd952497 100644 --- a/doc/zhtw/array/constructor.md +++ b/doc/zhtw/array/constructor.md @@ -10,7 +10,7 @@ new Array('3') // 結果: ['3'] 在上面的範例 `new Array(3)` 當只有一個參數傳入到 `Array` 的建構函數 -且那個參數事宜個數字，建構函數會回傳空值 +且那個參數是一個數字，建構函數會回傳空值 但是 `Array` 長度的屬性會變成跟那個參數一樣（以此範例來看他回傳的長度為 3） **注意** 只有他長度的屬性會被設定，整個 Array裡面的數值都不會初始化 diff --git a/doc/zhtw/array/general.md b/doc/zhtw/array/general.md index e9de8782..1a59d72e 100644 --- a/doc/zhtw/array/general.md +++ b/doc/zhtw/array/general.md @@ -7,7 +7,7 @@ > 只有 [objects](#object.general) 來管理建值的相對應關係 > Arrays 是**保持** 順序的，Objects **則沒有** -因為 `for in` 迴圈會列舉所有在原型 Array 上的屬性因為他會使用[`hasOwnProperty`](#object.hasownproperty), 這會使得 Array 比原本的 `for` 迴圈慢上二十幾倍 +因為 `for in` 迴圈會使用[`hasOwnProperty`](#object.hasownproperty)，所以它會列舉所有在原型 Array 上的屬性，這會使得 Array 比原本的 `for` 迴圈慢上二十幾倍 ### 迴圈 @@ -20,8 +20,8 @@ 在上面的例子中利用 `l = list.length` 來處理 Array 的長度問題。 -雖然 `length` 屬性是屬於 Array 中其中一個屬性，但是他還使有一定的性能消耗在每次循環的訪問。 -近期 Javascript 使用 **may** 來解決在這上面的效率問題，但是在現在的引擎上還不一定有支援。 +雖然 `length` 屬性是屬於 Array 中其中一個屬性，但是他在每次循環還是有一定的性能消耗。 +近期 Javascript **可能**使用來解決在這上面的效率問題，但是在現在的引擎上還不一定有支援。 實際上，不使用暫存 Array 長度的方式比使用暫存的版本還要慢很多。 diff --git a/doc/zhtw/core/undefined.md b/doc/zhtw/core/undefined.md index 491f8528..501dfb95 100644 --- a/doc/zhtw/core/undefined.md +++ b/doc/zhtw/core/undefined.md @@ -1,6 +1,6 @@ ## `undefined` 和 `null` -JavaScript 中有兩個表示空值的方式， `null` 和 `undefined` ， `undefined`式比較常用的一種。 +JavaScript 中有兩個表示空值的方式， `null` 和 `undefined` ， `undefined`是比較常用的一種。 ### `undefined` 的值 diff --git a/doc/zhtw/function/arguments.md b/doc/zhtw/function/arguments.md index 7cb76032..39aa58f0 100644 --- a/doc/zhtw/function/arguments.md +++ b/doc/zhtw/function/arguments.md @@ -18,7 +18,7 @@ Array.prototype.slice.call(arguments); -這種轉化方式比較 **慢** ，不建議使用這種作法如果再追求效率的程式中。 +這種轉化方式比較 **慢** ，如果在追求效率的程式中，不建議使用這種作法。 ### 傳遞參數 @@ -53,7 +53,7 @@ 在 `Arguments` 物件創造的 *getter* 和 *setter* 的函數方法，可以被視為原本函數的變數。 -因此，改變了一個變數會跟著改變它的值而且也間接的改變稻香對應的 `arguments` 的物件，反之亦然。 +因此，改變了一個形式參將數會跟著改變對應的 `arguments` 的屬性，反之亦然。 function foo(a, b, c) { arguments[0] = 2; diff --git a/doc/zhtw/function/scopes.md b/doc/zhtw/function/scopes.md index 3e151282..d443656f 100644 --- a/doc/zhtw/function/scopes.md +++ b/doc/zhtw/function/scopes.md @@ -160,7 +160,7 @@ JavaScript 中所有的作用區，包括 *全域作用域*，都有一個特殊 1. 當作用域內是否有 `var foo` 的定義。 2. 函式形式參數是否有使用 `foo` 名稱定義。 - 3. 函式自身是剖叫做 `foo`。 + 3. 函式自身是否叫做 `foo`。 4. 回溯到上一個層級然後再從第一個開始往下去查。 > **注意: ** 自定義 `arguments` 參數會阻止原生的 `arguments` 的物件創立 diff --git a/doc/zhtw/function/this.md b/doc/zhtw/function/this.md index 116a70df..361a06c4 100644 --- a/doc/zhtw/function/this.md +++ b/doc/zhtw/function/this.md @@ -1,6 +1,6 @@ ## `this` 的工作原理 -JavaScript 有移到完全部屬於其他語言處理 `this` 的處理機制。 +JavaScript 有一道完全不屬於其他語言處理 `this` 的處理機制。 在 **五** 種不同的情況下， `this` 指向的各不相同 ### 全域變數 @@ -42,8 +42,7 @@ JavaScript 有移到完全部屬於其他語言處理 `this` 的處理機制。 當使用 `function.prototype` 上的 `call` 或只 `apply` 方法時，函式內的 `this` 將會被 **顯示設置** 為函式調用的第一個參數。 -As a result, in the above example the *method case* does **not** apply, and `this` -inside of `foo` will be set to `bar`. +因此，在以上的例子中已不適用*函式調用*的原則，而且`this`會被設定指向`bar`。 > **Note:** `this` **cannot** be used to refer to the object inside of an `Object` > literal. So `var obj = {me: this}` will **not** result in `me` referring to @@ -51,56 +50,48 @@ inside of `foo` will be set to `bar`. ### 常見誤解 -While most of these cases make sense, the first can be considered another -mis-design of the language because it **never** has any practical use. +儘管大部分的例子都合理，但第一個例子(譯者注: 應該是指前面呼叫一個函式的那個例子)可以被視為一個語言的不良設計，因為它**從來**就沒有實際用途。 Foo.method = function() { function test() { - // this is set to the global object + // this 設定為全域 } test(); }; -A common misconception is that `this` inside of `test` refers to `Foo`; while in -fact, it **does not**. +一個常見的誤解是 `test` 中的 `this` 指向 `Foo` 物件，但實際上並**不是**。 -In order to gain access to `Foo` from within `test`, it is necessary to create a -local variable inside of `method` that refers to `Foo`. +為了在 `test` 中使用 `Foo` 物件，我們需要在 `method` 函式内部建立一個區域變數指向 `Foo`。 Foo.method = function() { var that = this; function test() { - // Use that instead of this here + // 這裡使用 that 而非 this } test(); }; -`that` is just a normal variable name, but it is commonly used for the reference to an -outer `this`. In combination with [closures](#function.closures), it can also -be used to pass `this` values around. +`that` 只是普通的名字，不過這個名字常被用用來指向外部的 `this`。 在 [閉包](#function.closures) 一節，可以看到它(`that`)可以取代 `this` 傳遞。 -As of ECMAScript 5 you can use the `bind` method combined with an anonymous function to achieve the same result. +在 ECMAScript 5 ，你可以使用 `bind` 結合匿名函式達到相同結果。 Foo.method = function() { var test = function() { - // this now refers to Foo + // this 指向 Foo }.bind(this); test(); }; -### Assigning Methods +### 函式表達式 -Another thing that does **not** work in JavaScript is function aliasing, which is -**assigning** a method to a variable. +另一個在 JavaScript 中**不會**運作的就是 function aliasing，也就是函式**賦值**給一個變數。 var test = someObject.methodTest; test(); -Due to the first case, `test` now acts like a plain function call; therefore, -`this` inside it will no longer refer to `someObject`. +上例中，`test` 就像一個普通的函式被调用；因此，函式内的 this 將不再指向 `someObject`。 -While the late binding of `this` might seem like a bad idea at first, in -fact, it is what makes [prototypal inheritance](#object.prototype) work. +雖然起初 `this` 的绑定特性似乎像是個壞主意，但事實上，它使得 [原型繼承](#object.prototype)得以運作。 function Foo() {} Foo.prototype.method = function() {}; @@ -110,7 +101,5 @@ fact, it is what makes [prototypal inheritance](#object.prototype) work. new Bar().method(); -When `method` gets called on an instance of `Bar`, `this` will now refer to that -very instance. - +當 `method` 被呼叫時，`this` 將會指向 `Bar` 的實體物件。 diff --git a/doc/zhtw/object/general.md b/doc/zhtw/object/general.md index aee1885c..6cd56600 100644 --- a/doc/zhtw/object/general.md +++ b/doc/zhtw/object/general.md @@ -69,7 +69,7 @@ JavaScript 的物件可以作為 [*Hashmaps*][1]使用，主要用來保存命 只有 `baz` 真正被刪除而已，所以從輸出結果中消失。 -### 屬姓名的語法 +### 屬性名的語法 var test = { 'case': 'I am a keyword, so I must be notated as a string', diff --git a/doc/zhtw/types/instanceof.md b/doc/zhtw/types/instanceof.md index 5bdb00d2..fa5e8c30 100644 --- a/doc/zhtw/types/instanceof.md +++ b/doc/zhtw/types/instanceof.md @@ -1,6 +1,6 @@ ## `instanceof` 操作符 -`instanceof` 操作符用來比較兩個建構函數的操作數。只有在比較字定義的物件時才有意義。這和 [typeof operator](#types.typeof)一樣用處不大。 +`instanceof` 操作符用來比較兩個建構函數的操作數。只有在比較自定義的物件時才有意義。這和 [typeof operator](#types.typeof)一樣用處不大。 ### 比較定意義物件 @@ -24,7 +24,7 @@ 'foo' instanceof String; // false 'foo' instanceof Object; // false -有一點需要注意的， `instanceof` 不能用來物件來自上下文不同的屬性（例如：瀏覽器中不同的文檔結構），因為它的建構函數不一樣。 +有一點需要注意的， `instanceof` 不會在來自不同的上下文的物件運作（例如：瀏覽器中不同的文檔結構），因為它的建構函數不一樣。 ### In Conclusion diff --git a/doc/zhtw/types/typeof.md b/doc/zhtw/types/typeof.md index 7058e55b..0a0908b0 100644 --- a/doc/zhtw/types/typeof.md +++ b/doc/zhtw/types/typeof.md @@ -3,7 +3,7 @@ `typeof` 操作符 (和 [`instanceof`](#types.instanceof)) 可能是最大的設計錯誤在 JavaScript，因為它幾乎不可能從它們那裡得到想要的結果。 -雖然 `instanceof` 還是有一些限制上的使用， `typeof` 只有一個實際上的運傭情形，但是 **不是** 用在檢查物件的類型。 +雖然 `instanceof` 還是有一些限制上的使用， `typeof` 只有一個實際上的運用情形，但是 **不是** 用在檢查物件的類型。 > **注意:** 由於 `typeof` 也可以像函式的語法被調用，例如 `typeof(obj)`，但這並是一個函數調用。 > 那兩個小括號只是用來計算一個表達式的值，這個返回值會作為 `typeof` 操作符的一個操作數。 @@ -67,8 +67,8 @@ JavaScript 標準文檔只給出了一種獲取 `[[Class]]` 值的方法，那 ### 結語 為了去檢查一個物件，強烈建議去使用 `Object.prototype.toString` 因為這是唯一可以依賴的方式。 -正如上面所看到的 `typeof` 的亦先返回值在標準文檔中未定義，因此不同的引擎可能不同。 +正如上面所看到的 `typeof` 的事先返回值在標準文檔中未定義，因此不同的引擎可能不同。 -除非為了檢測一個變數是否定義，我們應該避免是用 `typeof` 操作符。 +除非為了檢測一個變數是否定義，我們應該避免使用 `typeof` 操作符。 From 8f02c2f361c33164e2fe244f935a0c153de7c011 Mon Sep 17 00:00:00 2001 From: camilobernal Date: Fri, 15 May 2020 07:51:26 -0500 Subject: [PATCH 10/13] Fix word in functions-constructors (ES) --- doc/es/function/constructors.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/es/function/constructors.md b/doc/es/function/constructors.md index 0850cb4b..9c4e2946 100644 --- a/doc/es/function/constructors.md +++ b/doc/es/function/constructors.md @@ -48,7 +48,7 @@ Cuando una `nueva` keyword es omitidad, la función **no** devuelve un nuevo obj } Foo(); // undefined -Auqnue el ejemplo anterior puede parecer que trabaja en algunos casos, debido +Aunque el ejemplo anterior puede parecer que trabaja en algunos casos, debido a los trabajos de [`this`](#function.this) en JavaScript, que usará el *objeto global* como valor de `this`. From 3de9dc4d039ec5be4876f3e32896446219d55952 Mon Sep 17 00:00:00 2001 From: camilobernal Date: Fri, 15 May 2020 07:52:24 -0500 Subject: [PATCH 11/13] Fix word in functions-scopes (ES) --- doc/es/function/scopes.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/es/function/scopes.md b/doc/es/function/scopes.md index d641a939..c6bfb8e0 100644 --- a/doc/es/function/scopes.md +++ b/doc/es/function/scopes.md @@ -47,7 +47,7 @@ mayor implicación. test(); foo; // 21 -Dejando de lador la sentencia `var` dentro de la función `test` sobre escribiría el +Dejando de lado la sentencia `var` dentro de la función `test` sobre escribiría el valor de `foo`. Si bien al principio puede parecer un gran cambio, se tiene miles de líneas de código en JavaScript y no se usaría `var` introduciendose en un horrible y difícil detección de errores. From 78c0862ddae8e3b6b7f4b9a5b35f0fdfe5fdbd69 Mon Sep 17 00:00:00 2001 From: camilobernal Date: Fri, 15 May 2020 07:53:35 -0500 Subject: [PATCH 12/13] Fix word in functions-scopes (ES) --- doc/es/function/scopes.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/doc/es/function/scopes.md b/doc/es/function/scopes.md index c6bfb8e0..00ed940c 100644 --- a/doc/es/function/scopes.md +++ b/doc/es/function/scopes.md @@ -68,7 +68,7 @@ horrible y difícil detección de errores. El bucle externo terminará después de la primera llamada a `subLoop`, desde `subLoop` sobreescribe el valor global de `i`. Usando `var` para el segundo bucle `for` se hace fácil evitar este error. La sentencia `var` no debe **nunca** dejarse a menos que -el *efecto deseado* es afectado por el ámbito exteriror. +el *efecto deseado* es afectado por el ámbito exterior. ### Variables locales From 06a3882008ef0704258f808d76bf2211c7db7e7a Mon Sep 17 00:00:00 2001 From: Tim Ruffles Date: Wed, 19 Jun 2024 16:11:30 +0100 Subject: [PATCH 13/13] Update README.md --- README.md | 14 +++++++++++++- 1 file changed, 13 insertions(+), 1 deletion(-) diff --git a/README.md b/README.md index cb9cb3d4..be02cfd5 100644 --- a/README.md +++ b/README.md @@ -1,6 +1,18 @@ JavaScript Garden ================= +2024 update: this project has not been actively maintained in years. The original author +[took the site down](https://github.com/BonsaiDen/JavaScript-Garden/commit/93278fbcafa569fd193f8784abc267e9db09c645) +in 2022 (no judgement - updating it would be a big project!). At that point it was already long out of date, e.g. missing +the new language features from ES6 onwards. + +Many excellent modern guides exist, e.g. [Eloquent Javascript](https://eloquentjavascript.net/), or +the [MDN guide](https://developer.mozilla.org/en-US/docs/Web/JavaScript). + +Thanks for all the maintainers and translators over the years! + +----- + **JavaScript Garden** is a growing collection of documentation about the most quirky parts of the JavaScript programming language. It gives advice to avoid common mistakes, subtle bugs, as well as performance issues and bad @@ -19,7 +31,7 @@ This guide is the work of two lovely Stack Overflow users, [Ivo Wetzel][6] [many others](https://github.com/BonsaiDen/JavaScript-Garden/graphs/contributors) who've worked hard to provide translations or fixes. -It's currently maintained by [Tim Ruffles](http://twitter.com/timruffles). +It was maintained by [Tim Ruffles](http://twitter.com/timruffles) from 2013-2020ish. ## Contributing