Merge pull request BonsaiDen#275 from 108adams/Polish-translation-updates

Polish translation updates

Author: timruffles

doc/pl/array/constructor.md

@@ -11,9 +11,9 @@ przekazane do niego parametry.
     new Array(3); // Rezultat: []
     new Array('3') // Rezultat: ['3']
 
-W przypadku gdy tylko jeden argument zostanie przekazany do kostruktora `Array` i 
+W przypadku, gdy tylko jeden argument zostanie przekazany do kostruktora `Array` i 
 ten argument jest typu `Number`, konstruktor zwróci nową *dziwną* tablicę 
-z ustawioną właściwością `length` na wartość przekazaną jako argument. Należy 
+z właściwością `length` ustawioną na wartość przekazaną jako argument. Należy 
 zauważyć, że **tylko** właściwość `length` zostanie ustawiona w ten sposób.
 Rzeczywiste indeksy w tej tablicy nie zostaną zainicjalizowane.
 

doc/pl/array/general.md

@@ -1,6 +1,6 @@
 ## Iterowanie po tablicach oraz właściwościach tablic
 
-Mimo że tablice w JavaScript są obiektami, nie ma dobrych powodów aby używać 
+Mimo, że tablice w JavaScript są obiektami, nie ma dobrych powodów, aby używać 
 [`pętli for in`](#object.forinloop) do iteracji po nich. W rzeczywstości istnieje 
 wiele dobrych powodów **przeciwko** wykorzystaniu `for in` na tablicach.
 
@@ -9,9 +9,9 @@ wiele dobrych powodów **przeciwko** wykorzystaniu `for in` na tablicach.
 > tablice asocjacyjne **zachowują** porządek, natomiast obiekty **nie zachowują**.
 
 Ponieważ pętla `for in` wylicza wszystkie właściwości, które są wewnątrz 
-łańcucha prototypów i jedynym sposobem aby wykluczyć te właściwości jest użycie 
-[`hasOwnProperty`](#object.hasownproperty), ale wówczas pętla staje się 
-**dwadzieście razy** wolniejsza od normalnej pętli `for`.
+łańcucha prototypów, jedynym sposobem, aby wykluczyć te właściwości, jest użycie 
+[`hasOwnProperty`](#object.hasownproperty). Wówczas pętla staje się jednak
+**dwadzieścia razy** wolniejsza od normalnej pętli `for`.
 
 ### Iteracja
 
@@ -26,10 +26,10 @@ użyć klasycznej pętli `for`.
 W powyższym przykładzie jest jeszcze jeden dodatkowy haczyk. Jest to zbuforowanie 
 długości tablicy poprzez `l = list.length`.
 
-Mimo że właściwość `length` jest zdefiniowana wewnątrz tablicy, istnieje nadal 
-dodatkowy koszt na wyszukiwanie tej właściwości przy każdej iteracji w pętli. 
-Chociaż najnowsze silniki JavaScript **mogą** zastosować w tym 
-przypadku optymalizację. Nie ma jednak możliwość ustalenia czy kod będzie wykonywany w jednym 
+Mimo, że właściwość `length` jest zdefiniowana wewnątrz tablicy, istnieje nadal 
+dodatkowy koszt wyszukiwania tej właściwości przy każdej iteracji w pętli. 
+Najnowsze silniki JavaScript **mogą** zastosować w tym 
+przypadku optymalizację. Nie ma jednak możliwości ustalenia, czy kod będzie wykonywany w jednym 
 z tych nowych silników, czy też nie.
 
 W rzeczywistości pominięcie buforowania długości tablicy może spowodować, że pętla 

doc/pl/function/scopes.md

@@ -21,7 +21,7 @@ definiowane w jednej *globalnie współdzielonej* przestrzeni nazw.
 
 Z każdym odwołaniem do zmiennej, JavaScript przeszukuje w górę wszystkie zasięgi 
 dopóki nie znajdzie tej zmiennej. W przypadku, gdy przeszukiwanie dotrze do globalnego 
-zasięgu i nadal nie znajdzie żądanej nazwy, to wyrzuca błąd `ReferenceError`.
+zasięgu i nadal nie znajdzie żądanej nazwy, wyrzuca błąd `ReferenceError`.
 
 ### Zmora globalnych zmiennych
 
@@ -35,7 +35,7 @@ Powyższe dwa skrypty **nie** dają tego samego efektu. Skrypt A definiuje zmien
 nazwaną `foo` w *globalnym* zasięgu, natomiast skrypt B definiuje `foo` 
 w *aktualnym* zasięgu.
 
-Jeszcze raz, to wcale nie daje *tego samego efektu*. Nie użycie `var` może mieć 
+Jeszcze raz, to wcale nie daje *tego samego efektu*. Brak użycia `var` może mieć 
 poważne konsekwencje.
 
     // globalny zasięg
@@ -48,8 +48,8 @@ poważne konsekwencje.
     foo; // 21
 
 Pominięcie słowa `var` w deklaracji wewnątrz funkcji `test` nadpisze wartość 
-zmiennej globalnej `foo`. Mimo że nie wygląda to na początku na duży problem, 
-posiadanie wielu tysięcy linii kodu w JavaScript i nie korzystanie z `var` 
+zmiennej globalnej `foo`. Mimo, że nie wygląda to na początku na duży problem, 
+w przypadku kodu, który posiada wielu tysięcy linii, brak `var` 
 wprowadzi straszne i trudne do wyśledzenia błędy.
 
     // globalny zasięg 
@@ -68,8 +68,8 @@ wprowadzi straszne i trudne do wyśledzenia błędy.
 Zewnętrzna pętla zakończy działanie po pierwszym wywołaniu `subLoop`, ponieważ 
 `subLoop` nadpisuje wartość globalnej zmiennej `i`. Użycie `var` w drugiej pętli 
 `for` pozwoliłoby łatwo uniknąć problemu. Słowo kluczowe `var` nie powinno być 
-**nigdy** pominięte w deklaracji, chyba że *pożądanym skutkiem* jest wpłynięcie na 
-zewnętrzny zasięg.
+**nigdy** pominięte w deklaracji, chyba że *pożądanym skutkiem* jest modyfikacja  
+zewnętrznego zasięgu.
 
 ### Lokalne zmienne
 
@@ -150,10 +150,10 @@ W oryginalnym kodzie instrukcja warunkowa `if` zdaje się modyfikować *zmienną
 globalną* `goo`, podczas gdy faktycznie modyfikuje ona *zmienną lokalną* - po tym 
 jak zostało zastosowane windowanie (hoisting).
 
-Bez wiedzy na temat podnoszenia (hoistingu), poniższy kod może sprawiać wrażenie,
+Analizując poniższy kod bez wiedzy na temat hoistingu możemy odnieść wrażenie,
 że zobaczymy błąd `ReferenceError`.
 
-    // sprawdz czy SomeImportantThing zostało zainicjalizowane
+    // sprawdź, czy SomeImportantThing zostało zainicjalizowane
     if (!SomeImportantThing) {
         var SomeImportantThing = {};
     }
@@ -163,9 +163,9 @@ przeniesiona na początek *globalnego zasięgu*.
 
     var SomeImportantThing;
 
-    // inny kod który może ale nie musi zainicjalizować SomeImportantThing
+    // inny kod, który może, ale nie musi zainicjalizować SomeImportantThing
 
-    // upewnienie się, że SomeImportantThing zostało zainicjalizowane
+    // upewnij się, że SomeImportantThing zostało zainicjalizowane
     if (!SomeImportantThing) {
         SomeImportantThing = {};
     }
@@ -182,19 +182,21 @@ funkcji.
 
 Na przykład, kiedy próbujemy odczytać zmienną `foo` wewnątrz zasięgu funkcji, 
 JavaScript będzie szukać nazwy w określonej kolejności:
- 1. Jeżeli wewnątrz aktualnego zasięgu znajduje się deklaracja `var foo` skorzystaj z niej.
- 2. Jeżeli jeden z parametrów fukcji został nazwany `foo` użyj go.
- 3. Jeżeli fukcja została nazwana `foo` skorzystaj z tego.
- 4. Przejdz do zewnętrznego zasięgu i przejdz do kroku **#1**.
 
-> **Uwaga:** Jeżeli jeden z parametrów fukcji został nazwany `arguments`, zapobiegnie 
-> to utworzeniu domyślnego obiektu `arguments`.
+ 1. Jeżeli wewnątrz aktualnego zasięgu znajduje się deklaracja `var foo`, skorzystaj z niej.
+ 2. Jeżeli jeden z parametrów fukcji został nazwany `foo`, użyj go.
+ 3. Jeżeli funkcja została nazwana `foo`, skorzystaj z tego.
+ 4. Przejdź do zewnętrznego zasięgu i przejdź do kroku **#1**.
+
+> **Uwaga:** Jeżeli jeden z parametrów fukcji został nazwany `arguments`, 
+> nie zostanie utworzony domyślny obiekt `arguments`.
 
 ### Przestrzenie nazw
 
 Powszechnym problemem posiadania tylko jednej globalnej przestrzeni nazw jest 
 prawdopodobieństwo wystąpienia kolizji nazw. W JavaScripcie, można łatwo uniknąć 
-tego problemu korzystając z *anonimowych wrapperów*.
+tego problemu korzystając z *anonimowych wrapperów* (inaczej: Immediately-Invoked 
+Function Expression - IIFE).
 
     (function() {
         // autonomiczna "przestrzeń nazw"