Polish translation.

Lukasz Kufel · Lukasz Kufel · commit ea8b09f3913b · 2011-04-04T16:13:26.000+02:00
Intro and object translated.
diff --git a/doc/language.json b/doc/language.json
@@ -1,5 +1,5 @@
 {
     "default": "en",
-    "listed": ["en", "fi", "ru", "zh"]
+    "listed": ["en", "fi", "ru", "zh", "pl"]
 }
 
diff --git a/doc/pl/full_index.json b/doc/pl/full_index.json
@@ -0,0 +1,74 @@
+{
+    "title": "JavaScript Garden",
+    "langTitle": "JavaScript Garden - ogród JavaScript po polsku",
+    "description": "Przewodnik po dziwactwach i wadach języka JavaScript.",
+    "sections": [
+        {
+            "title": "Wstęp",
+            "dir": "intro",
+            "articles": [
+            	"authors",
+                "contributors",
+                "translators",
+                "hosting",
+                "license"
+            ]
+        },
+        {
+            "title": "Obiekty",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        },
+        {
+            "title": "Funkcje",
+            "dir": "function",
+            "articles": [
+                "general",
+                "this",
+                "closures",
+                "arguments",
+                "constructors",
+                "scopes"
+            ]
+        },
+        {
+            "title": "Tablice",
+            "dir": "array",
+            "articles": [
+                "general",
+                "constructor"
+            ]
+        },
+        {
+            "title": "Typy",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
+        },
+        {
+            "title": "?Wnętrze?",
+            "dir": "core",
+            "articles": [
+                "eval",
+                "undefined",
+                "semicolon"
+            ]
+        },
+        {
+            "title": "Inne",
+            "dir": "other",
+            "articles": [
+                "timeouts"
+            ]
+        }
+    ]
+}
diff --git a/doc/pl/index.json b/doc/pl/index.json
@@ -0,0 +1,28 @@
+{
+    "title": "JavaScript Garden",
+    "langTitle": "JavaScript Garden - ogród JavaScript po polsku",
+    "description": "Przewodnik po dziwactwach i wadach języka JavaScript.",
+    "sections": [
+        {
+            "title": "Wstęp",
+            "dir": "intro",
+            "articles": [
+            	"authors",
+                "contributors",
+                "translators",
+                "hosting",
+                "license"
+            ]
+        },
+        {
+            "title": "Obiekty",
+            "dir": "object",
+            "articles": [
+                "general",
+                "prototype",
+                "hasownproperty",
+                "forinloop"
+            ]
+        }
+    ]
+}
diff --git a/doc/pl/intro/authors.md b/doc/pl/intro/authors.md
@@ -0,0 +1,8 @@
+## Autorzy
+
+Ten przewodnik jest dziełem dwóch uroczych użytkowników [Stack Overflow][1],
+[Ivo Wetzel][2] (Treść) oraz [Zhang Yi Jiang][3] (Projekt).
+
+[1]: http://stackoverflow.com/
+[2]: http://stackoverflow.com/users/170224/ivo-wetzel
+[3]: http://stackoverflow.com/users/313758/yi-jiang
diff --git a/doc/pl/intro/contributors.md b/doc/pl/intro/contributors.md
@@ -0,0 +1,7 @@
+## Kontrybutorzy
+
+ - [Caio Romão][1] (Poprawki pisowni)
+ - [Andreas Blixt][2] (Poprawki językowe)
+
+[1]: https://github.com/caio
+[2]: https://github.com/blixt
diff --git a/doc/pl/intro/hosting.md b/doc/pl/intro/hosting.md
@@ -0,0 +1,6 @@
+## Hosting
+JavaScript Garden znajduje się na serwerach GitHub, ale dzięki wsparciu 
+[Cramer Rozwoju] [1] posiadamy mirror na serwerze [JavaScriptGarden.info] [2].
+
+[1]: http://cramerdev.com/
+[2]: http://javascriptgarden.info/
diff --git a/doc/pl/intro/index.md b/doc/pl/intro/index.md
@@ -0,0 +1,13 @@
+## Wstęp
+**JavaScript Garden** jest rosnącą kolekcją dokumentów o najdziwniejszych 
+częściach języka JavaScript. Dokumentacja pomaga uniknąć najczęściej popełnianych
+błędów, sybtelnych bugów, problemów wydajnościowych oraz złych praktyk, na które
+niedoświadczeni programiści JavaScript mogą natrafić próbując poznać tajniki tego 
+języka.
+
+JavaScript Garden **nie** ma na celu nauczyć Cię języka JavaScript. Podstawowa
+wiedza na temat języka jest wymagana do zrozumienia zagadnień poruszanych w tym 
+przewodniku. Aby nauczyć się podstaw jezyka JavaScript, odwiedź znakomity 
+[przewodnik][1] na stronach Mozilla Developer Network.
+
+[1]: https://developer.mozilla.org/en/JavaScript/Guide
diff --git a/doc/pl/intro/license.md b/doc/pl/intro/license.md
@@ -0,0 +1,11 @@
+## Licencja
+
+JavaScript Garden jest publikowany w ramach [licencji MIT] [1] i kod źródłowy znajduje 
+się na serwerze [GitHub] [2]. Jeśli znajdziesz jakieś błędy lub literówek zgłoś proszę 
+[problem] [3] lub rozwiązag go i zglosić pull request ze swojego repozytorium. 
+Możesz nas także znaleźć w pokoju [JavaScript] [4] na chacie Stack Overflow. 
+
+[1]: https://github.com/BonsaiDen/JavaScript-Garden/blob/next/LICENSE
+[2]: https://github.com/BonsaiDen/JavaScript-Garden
+[3]: https://github.com/BonsaiDen/JavaScript-Garden/issues
+[4]: http://chat.stackoverflow.com/rooms/17/javascript
diff --git a/doc/pl/intro/translators.md b/doc/pl/intro/translators.md
@@ -0,0 +1,6 @@
+## Tłumaczenie
+
+ - [Łukasz Kufel][1] ([qfel13.pl][2])
+ 
+[1]: https://github.com/qfel13
+[2]: http://qfel13.pl
diff --git a/doc/pl/object/forinloop.md b/doc/pl/object/forinloop.md
@@ -0,0 +1,50 @@
+## The `for in` Loop
+
+Podobnie jak operator `in`, pętla `for in` przeszukuje łańcuch prototypów 
+podczas iteracji po właściwościach obiektu.
+
+> **Uwaga:** pętla `for in` **nie** będzie iterować po właściwościach, które
+> mają ustawiony atrybut `enumerable` na `false` na przykład właściwość 
+> `length` tablicy.
+    
+    // Zatrucie Object.prototype
+    Object.prototype.bar = 1;
+
+    var foo = {moo: 2};
+    for(var i in foo) {
+        console.log(i); // wyświetla obie właściwości: bar i moo
+    }
+
+Ponieważ nie jest możliwe, aby zmienić zachowanie pętli `for in` to niezbędne 
+jest odfiltrowanie niechcianych właściwości wewnątrz ciała pętli, korzystając 
+z metody [`hasOwnProperty`](#object.hasownproperty) z `Object.prototype`.
+
+> **Uwaga:** Ponieważ pętla `for in` zawsze przeszukuje cały łańcuch prototypów 
+> będzie się ona stawała coraz wolniejsza przy dodaniu każdej kolejnej warstwy 
+> dziedziczenia do obiektu. 
+
+### Korzystanie z `hasOwnProperty` do odfiltrowania
+
+    // foo z przykładu powyżej
+    for(var i in foo) {
+        if (foo.hasOwnProperty(i)) {
+            console.log(i);
+        }
+    }
+
+To jest jedyna poprawna wersja, którą należy używać. Ze względu na użycie 
+`hasOwnProperty` zostanie wypisane **jedynie** `moo`. Gdy opuścimy `hasOwnProperty` 
+kod będzie podatny na błędy, gdy natywne prototypy np. `Object.prototype` 
+zostanie rozszerzony.
+
+[Prototype][1] jest jednym z szeroko rozpowszechniony framework, który dokonuje 
+takiego rozszerzenia. Używanie tego frameworku oraz nie używanie w pętle `for in` 
+metody `hasOwnProperty` gwarantuje błędy w wykonaniu.
+
+### Wnioski
+
+Zaleca się aby zawsze używać metody `hasOwnProperty`. Nigdy nie powinno się dokonywać
+żadnych założeń na temat środowiska, w którym kod będzie wykonywany i czy natywne 
+prototypy zostały rozszerzone czy nie.
+
+[1]: http://www.prototypejs.org/
diff --git a/doc/pl/object/general.md b/doc/pl/object/general.md
@@ -0,0 +1,102 @@
+## Wykorzystanie obiektów i ich właściwości
+
+Wszystko w JavaScripcie zachowuje sie jak obiekt, z dwoma wyjątkami
+[`null`](#core.undefined) oraz [`undefined`](#core.undefined). 
+
+    false.toString() // 'false'
+    [1, 2, 3].toString(); // '1,2,3'
+    
+    function Foo(){}
+    Foo.bar = 1;
+    Foo.bar; // 1
+
+Popularnym błędem jest wykorzystanie literałów liczbowych jako obiektu.
+Spowodowanie jest to usterką w parserze JavaScript, który interpretuje kropkę
+po literale liczbowym jako rozdzielenie części całkowitej od części po przecinku 
+liczby.
+
+    2.toString(); // wyrzuca błąd SyntaxError
+
+Istnieje kilka rozwiązań, dzieki którym literał liczbowy będzie zachowywał się 
+jak obiekt.
+
+    2..toString(); // druga kropka jest poprawnie rozpoznana
+    2 .toString(); // zauważ, że pozostawiona jest spacja przed kropką
+    (2).toString(); // 2 zostanie zewaluowane najpiewr
+
+### Obiekty jako typy danych
+
+Obiekty w języku JavaScript mogą być używana jako [*tablice asocjacyjne*][1]. 
+Ponieważ obiekty głównie składają się z mapowań pomiędzy nazwanymi właściwościami (kluczami)
+a wartościami dla tych atrybutów.
+
+Używając literału obiektu - notacji `{}` - istnieje możliwość stworzenie obiektu prostego.
+Ten nowy obiekt bedzie [dziedziczył](#object.prototype) z `Object.prototype` oraz 
+nie bedzie posiadał żadnych [własnych właściwości](#object.hasownproperty) zdefiniowanych w sobie.
+
+    var foo = {}; // nowy pusty obiekt
+
+    // nowy obiekt z właściwością test o wartości 12
+    var bar = {test: 12}; 
+
+### Dostęp do właściwości
+
+Właściwości obiektu można uzyskać na dwa sposoby, poprzez notację z kropką
+lub notacje z nawiasami kwadratowymi.
+    
+    var foo = {name: 'Kitten'}
+    foo.name; // kitten
+    foo['name']; // kitten
+    
+    var get = 'name';
+    foo[get]; // kitten
+    
+    foo.1234; // wyrzuca błąd SyntaxError
+    foo['1234']; // działa, zwraca undefined
+
+Obie notacje są identyczne w swoim działaniu, z tą tylko różnicą że notacja z nawiasami 
+kwadratowymi pozwala na dynamiczne dodawanie właściwości i nie prowadzi do wyrzycenia
+błędu podczas odczytu nieistniejącej właściwości.
+
+### Usuwanie właściwości
+
+Jedynym sposobem na faktycze usunięcie własności z obiektu jest użycie operatora 
+`delete`. Ustawienie własności na `undefined` lub `null` usunie tylko *wartość* 
+związaną z własnością, ale nie usunie to *klucza* (nazwy własności) z obiektu.
+
+    var obj = {
+        bar: 1,
+        foo: 2,
+        baz: 3
+    };
+    obj.bar = undefined;
+    obj.foo = null;
+    delete obj.baz;
+
+    for(var i in obj) {
+        if (obj.hasOwnProperty(i)) {
+            console.log(i, '' + obj[i]);
+        }
+    }
+
+Powyższy kod wypisuje dwie linie `bar undefined` i `foo null` - tylko własność `baz`
+została usunięta i dlatego nie została wypisana.
+
+### Notacja właściwości
+
+    var test = {
+        'case': 'I am a keyword so I must be notated as a string',
+        delete: 'I am a keyword too so me' // wyrzuca błąd SyntaxError
+    };
+
+Nazwy właściwości obiektu mogą być zarówno zapisane jako tekst(bez cudzysłowów 
+lub apostrofów) lub jako string (w cudzisłowach lub apostrofach). 
+Ze względu na kolejne niedociągnięcie w parserze JavaScript
+powyższy kod wyrzuci błąd `SyntaxError` dla implementacji JavaScript ponizej ECMAScript 5.
+
+Ten błąd wynika z faktu, że `delete` jest *słowem kluczowym*, dlatego musi zostać 
+zapisany jako *string* (z cudzysłowami lub apostrofami), aby zapewnić, że zostanie 
+to poprawnie zinterpretowane przez starsze silniki języka JavaScript.
+
+[1]: http://pl.wikipedia.org/wiki/Tablica_asocjacyjna
+
diff --git a/doc/pl/object/hasownproperty.md b/doc/pl/object/hasownproperty.md
@@ -0,0 +1,52 @@
+## `hasOwnProperty`
+
+W celu sprawdzenia czy dana właściwość została zdefiniowana *w tym* obiekcie a **nie** 
+w [łańcuchu prototypów](#object.prototype) niezbędne jest skorzystanie z metody 
+`hasOwnProperty`, która wszystkie obiekty dziedziczą z `Object.prototype`.
+
+> **Uwaga:** **Nie** jest wystarczające, by sprawdzić, czy właściwość jest `undefined`.
+> Ponieważ właściwość może istnieć, ale jej wartość być ustawiona na `undefined`. 
+
+`hasOwnProperty` jest jedyna metodą w języku JavaScript która operuje na właściwościach 
+i **nie** przegląda całego łańcucha prototypów. 
+
+    // Zatrucie Object.prototype
+    Object.prototype.bar = 1; 
+    var foo = {goo: undefined};
+    
+    foo.bar; // 1
+    'bar' in foo; // true
+
+    foo.hasOwnProperty('bar'); // false
+    foo.hasOwnProperty('goo'); // true
+
+Tylko `hasOwnProperty` da prawidłowy i oczekiwany rezultat. Jest to istotne podczas 
+iteracji po właściwościach obiektu. **Nie** ma innego sposobu na ominięcie
+właściwości, która nie została zdefiniowana przez ten **konkretny** obiekt, 
+ale gdzieś indziej w łańcuchu prototypów. 
+
+### `hasOwnProperty` jako właściwość
+
+JavaScript **nie** chroni właściwości o nazwie `hasOwnProperty`, zatem istnieje 
+możliwość, że obiekt może posiadać tak nazwaną właściwość. Konieczne jest użycie
+*zewnętrznego* `hasOwnProperty`, aby otrzymać poprawne rezultaty.
+
+    var foo = {
+        hasOwnProperty: function() {
+            return false;
+        },
+        bar: 'Here be dragons'
+    };
+
+    foo.hasOwnProperty('bar'); // zawsze zwraca false
+
+    // Została użyta metoda innego obiektu i wywołana z konkekstem `this` ustawionym na foo
+    ({}).hasOwnProperty.call(foo, 'bar'); // true
+
+### Wnioski
+
+**Jedyną** metodą służącą do sprawdzenia zdefiniowania jakiejś właściwości w konkretnym 
+obiekcie jest metoda `hasOwnProperty`. Zaleca się korzystać z `hasOwnProperty` jako część
+**każdej** [pętli `for in`](#object.forinloop), pozwoli to uniknąć błędów pochodzących z 
+rozszerzonych natywnych [prototypów](#object.prototype).
+
diff --git a/doc/pl/object/prototype.md b/doc/pl/object/prototype.md

Original file line number	Diff line number	Diff line change
`@@ -1,5 +1,5 @@`
`1`	`1`	`{`
`2`	`2`	`"default": "en",`
`3`		`- "listed": ["en", "fi", "ru", "zh"]`
	`3`	`+ "listed": ["en", "fi", "ru", "zh", "pl"]`
`4`	`4`	`}`
`5`	`5`