Corrections in Polish translation (Object section).

Author: ciembor

doc/pl/object/forinloop.md

@@ -1,11 +1,11 @@
-## The `for in` Loop
+## Pętla `for in`
 
 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.
+> mają ustawiony atrybut `enumerable` na `false` (na przykład właściwość 
+> `length` tablicy).
     
     // Zatrucie Object.prototype
     Object.prototype.bar = 1;
@@ -15,15 +15,15 @@ podczas iteracji po właściwościach obiektu.
         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 
+Ponieważ zmiana zachowania pętli `for in` nie jest możliwa, 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 
+> **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
+### Filtrowania przy użyciu `hasOwnProperty`
 
     // foo z przykładu powyżej
     for(var i in foo) {
@@ -32,19 +32,19 @@ z metody [`hasOwnProperty`](#object.hasownproperty) z `Object.prototype`.
         }
     }
 
-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.
+To jest jedyna poprawna wersja, której 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`) 
+zostaną rozszerzone.
 
-[Prototype][1] jest jednym z szeroko rozpowszechniony frameworków, który dokonuje 
-takiego rozszerzenia. Używanie tego frameworku oraz nie używanie w pętle `for in` 
+[Prototype][1] jest jednym z popularniejszych frameworków, które dokonują 
+takiego rozszerzenia. Używanie tego frameworku oraz nie stosowanie w pętli `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.
+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 ani tego, czy 
+natywne prototypy zostały rozszerzone, czy nie.
 
 [1]: http://www.prototypejs.org/

doc/pl/object/general.md

@@ -10,9 +10,9 @@ Wszystko w JavaScripcie zachowuje sie jak obiekt, z dwoma wyjątkami
     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 
+Popularnym błędem jest traktowanie literałów liczbowych jak obiektu.
+Spowodowane jest to specyfiką parsera JavaScript, który interpretuje kropkę
+po literale liczbowym jako rozdzielenie części całkowitej od części ułamkowej 
 liczby.
 
     2.toString(); // wyrzuca błąd SyntaxError
@@ -22,27 +22,27 @@ jak obiekt.
 
     2..toString(); // druga kropka jest poprawnie rozpoznana
     2 .toString(); // zauważ, że pozostawiona jest spacja przed kropką
-    (2).toString(); // 2 zostanie zewaluowane najpiewr
+    (2).toString(); // 2 zostanie najpierw zewaluowane
 
 ### 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)
+Obiekty w języku JavaScript mogą być używana jako [*tablice asocjacyjne*][1], 
+ponieważ obiekty składają się głównie 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.
+Używając literału obiektu - notacji `{}` - istnieje możliwość stworzenia 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.
+nie bedzie posiadał żadnych [własnych właściwości](#object.hasownproperty).
 
-    var foo = {}; // nowy pusty obiekt
+    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.
+Właściwości obiektu można uzyskać na dwa sposoby - poprzez notację z kropką
+lub z nawiasami kwadratowymi.
 
     var foo = {name: 'Kitten'}
     foo.name; // kitten
@@ -54,8 +54,8 @@ lub notacje z nawiasami kwadratowymi.
     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
+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 wyrzucenia
 błędu podczas odczytu nieistniejącej właściwości.
 
 ### Usuwanie właściwości
@@ -79,19 +79,19 @@ związaną z własnością, ale nie usunie to *klucza* (nazwy własności) z obi
         }
     }
 
-Powyższy kod wypisuje dwie linie `bar undefined` i `foo null` - tylko własność `baz`
+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
+        'case': 'jestem zastrzeżonym słowem kluczowym, więc muszę być w cudzysłowie',
+        delete: 'tak samo jak ja' // wyrzuca błąd SyntaxError
     };
 
-Nazwy właściwości obiektu mogą być zarówno zapisane jako tekst(bez cudzysłowów 
+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
+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ć 

doc/pl/object/hasownproperty.md

@@ -1,13 +1,13 @@
 ## `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`.
+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órej 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`. 
+> **Uwaga:** **Nie** wystarczy 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 
+`hasOwnProperty` jest jedyną 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
@@ -28,7 +28,7 @@ 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
+możliwość, że obiekt będzie posiadać tak nazwaną właściwość. Konieczne jest użycie
 *zewnętrznego* `hasOwnProperty`, aby otrzymać poprawne rezultaty.
 
     var foo = {
@@ -46,8 +46,8 @@ możliwość, że obiekt może posiadać tak nazwaną właściwość. Konieczne
 
 ### 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).
+**Jedyną** metodą służącą do sprawdzenia istnienia jakiejś właściwości w konkretnym 
+obiekcie jest metoda `hasOwnProperty`. Zaleca się korzystać z `hasOwnProperty` w 
+**każdej** [pętli `for in`](#object.forinloop). Pozwoli to uniknąć błędów pochodzących 
+z rozszerzonych natywnych [prototypów](#object.prototype).
 

doc/pl/object/prototype.md

@@ -1,23 +1,23 @@
 ## Prototyp
 
-JavaScript nie posiada klasycznego modelu dziedziczenia, lecz zamiast tego 
+JavaScript nie posiada klasycznego modelu dziedziczenia. Zamiast tego 
 dziedziczenie jest realizowane poprzez *prototypy*.
 
 Choć jest to często uważane za jedną ze słabości języka JavaScript,
 prototypowy model dziedziczenia, jest w rzeczywistości potężniejszy od klasycznego
-modelu. Na przykład stworzenia klasycznego modelu na podstawie modelu prototypowym 
-jest dość proste, podczas gdy zrobienie odwrotnie to już o wiele trudniejsze zadanie.
+modelu. Na przykład stworzenia klasycznego modelu na podstawie modelu prototypowego 
+jest dość proste, podczas gdy zrobienie odwrotnego przekształcenie to o wiele trudniejsze zadanie.
 
 Ze względu na fakt, że w JavaScript jest w zasadzie jedynym powszechnie stosowanym 
-językiem, któy posiada prototypowy model dziedziczenia, to wymaga troche czasu aby
-dostosować się do różnic pomiędzy tymi dwoma modelami. 
+językiem, któy posiada prototypowy model dziedziczenia, dostosowanie się do różnic pomiędzy
+tymi dwoma modelami wymaga trochę czasu. 
 
 Pierwszą znaczącą różnicą jest to, że dziedziczenie w JavaScript odbywa się za pomocą
 tak zwanych *łańcuchów prototypów*.
 
-> **Uwaga:** Używanie po prosstu `Bar.prototype = Foo.prototype` spowoduje, że oba obiekty 
-> będą korzystały z **tego samego** prototypu. W związku z tym zmiany na prototypie jednego
-> obiektu będą również zmieniały prototyp drugiego obiektu, co jest w wiekszości przypadków 
+> **Uwaga:** Używanie po prostu `Bar.prototype = Foo.prototype` spowoduje, że oba obiekty 
+> będą korzystały z **tego samego** prototypu. W związku z tym zmiany w prototypie jednego
+> obiektu będą również zmieniały prototyp drugiego obiektu, co jest ,w wiekszości przypadków, 
 > niepożądanym efektem.
 
     function Foo() {
@@ -47,25 +47,25 @@ tak zwanych *łańcuchów prototypów*.
                 Object.prototype
                     { toString: ... /* etc. */ }
 
-W powyższym przykładzie obiekt `test` będzie dziedziczył z obydwu tj. 
+W powyższym przykładzie obiekt `test` będzie dziedziczył z obydwu, tj. 
 `Bar.prototyp` i `Foo.prototyp`, stąd będzie miał dostęp do funkcji `method`,
 która była zdefiniowana w `Foo`. Ponadto obiekt będzie miał dostęp do 
 właściwości `value`, która jest jednyną instancją `Foo` i stała się jego prototypem.
-Ważne jest, aby pamiętać `new Bar` **nie** tworzy nowej instancji `Foo`, 
-ale wykorzystuje instancje, którą jest przypisana do własności `prototype`. 
+Należy pamiętać, że `new Bar` **nie** tworzy nowej instancji `Foo`, 
+tylko wykorzystuje instancję, która jest przypisana do własności `prototype`. 
 Zatem Wszystkie instancje `Bar` będą dzieliły tą samą własność `value`.
 
 > **Uwaga:** **Nie** należy używać konstrukcji `Bar.prototype = Foo`, 
-> ponieważ nie spowoduje ona przypisania prototypu `Foo` a raczej obiektu 
+> ponieważ nie spowoduje ona przypisania prototypu `Foo` tylko obiektu 
 > funckji `Foo`. Zatem łańcuch prototypów nie bedzie zawierał `Foo.prototype`,
-> ale `Function.prototype`, więc metoda `method` nie będzie w łańcuchu prototypów. 
+> tylko `Function.prototype`, więc metoda `method` nie będzie w łańcuchu prototypów. 
 
 ### Wyszukiwanie własności
 
-Podczas dostępu do właściwości obiektu, JavaScript przejdzie w górę łańcucha 
-prototypów dopóki nie znajdzie właściwości z żądaną nazwą.
+Podczas dostępu do właściwości obiektu JavaScript przejdzie w górę łańcucha 
+prototypów, dopóki nie znajdzie właściwości bez nazwy.
 
-Gdy przeszukiwanie dotrze do końca (szczytu) łańcucha mianowicie `Object.prototype` 
+Gdy przeszukiwanie dotrze do końca (szczytu) łańcucha, mianowicie `Object.prototype` 
 i nadal nie znajdzie określonej właściwości, to zwróci wartość 
 [undefined](#core.undefined).    
 
@@ -85,31 +85,31 @@ na dynamiczne tworzenie łańcuchów prototypów.
 
 Czas wyszukiwania właściwości, które są na końcu łańcucha prototypów może mieć 
 negatywny wpływ na wydajność krytycznych części kodu. Dodatkowo, próba dostępu 
-do nieistniejącej właściwości powoduje zawsze przeszukanie całego łańcucha prototypów.
+do nieistniejącej właściwości zawsze spowoduje przeszukanie całego łańcucha prototypów.
 
-Również, podczas [iteracji](#object.forinloop) po właściwościach obiektu
-**każda** właściwość, która znajduje się w łańcuchu prototypów niezależnie 
-na jakim znajduje się poziomie zostanie wyliczona.
+Również podczas [iteracji](#object.forinloop) po właściwościach obiektu
+**każda** właściwość, która znajduje się w łańcuchu prototypów (niezależnie 
+na jakim znajduje się poziomie) zostanie wyliczona.
 
 ### Rozszerzanie natywnych prototypów
 
 Rozszerzanie `Object.prototype` lub innego prototypu wbudowanych typów jest jednym z 
-najczęściej używanych niedoskonałej częsci języka JavaScript.
+najczęściej nadużywanej częsci języka JavaScript.
 
 Technika ta nazywana jest [monkey patching][1] i łamie zasady *enkapsulacji*.
-Jednak jest szeroko rozpowszechniona w frameworkach takich jak [Prototype][2].
-Nie ma jednak dobrego powodu, aby zaśmiecać wbudowane typy poprzez dodawanie do nich
-*niestandardowych* funkcjonalności.
+Mimo to jest szeroko rozpowszechniona w frameworkach takich jak [Prototype][2].
+Nie ma jednak dobrego powodu, aby zaśmiecać wbudowane typy poprzez wzbogacanie ich o 
+*niestandardowe* funkcjonalności.
 
 **Jedynym** dobrym powodem do rozszerzania wbudowanych prototypów jest portowanie  
-funkcjonalności znajdujących sie w nowszych silnikach JavaScript np. [`Array.forEach`][3]
+funkcjonalności znajdujących sie w nowszych silnikach JavaScript, np. [`Array.forEach`][3]
 
 ### Wnioski
 
-Zanim przystąpi się do pisania skomplikowanego kodu korzystającego z dziedziczanie 
-należy **całkowicie** rozumieć prototypowy model dziedziczenia. Ponadto należy uważać 
-na długość łańcucha prototypów i w razie potrzeby zmniejszać ilość dziedziczeń 
-aby uniknąć problemów z wydajnością. Natywne prototypy nie powinny **nigdy** być 
+Zanim przystąpi się do pisania skomplikowanego kodu korzystającego z dziedziczania,  
+należy **całkowicie** zrozumieć prototypowy model dziedziczenia. Ponadto trzeba uważać 
+na długość łańcucha prototypów i w razie potrzeby zmniejszać ilość dziedziczeń, 
+aby uniknąć problemów z wydajnością. Natywne prototypy **nigdy** nie powinny być 
 rozszerzane, chyba że ze względu na wprowadzanie kompatybilności z nowszymi silnikami 
 JavaScript.