Polish translation of function and array sections.

Author: Lukasz Kufel

doc/pl/array/constructor.md

@@ -0,0 +1,37 @@
+## Konstruktor `Array`
+
+Zaleca się zawsze korzystać z literału tablicy - notacja `[]` - podczas tworzenia 
+nowych tablic, ponieważ konstruktor `Array` niejednoznacznie interpretuje 
+parametry do niego przekazane.
+
+    [1, 2, 3]; // Rezultat: [1, 2, 3]
+    new Array(1, 2, 3); // Rezultat: [1, 2, 3]
+
+    [3]; // Rezultat: [3]
+    new Array(3); // Rezultat: []
+    new Array('3') // Rezultat: ['3']
+
+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 
+zauważyć, że **tylko** właściwość `length` zostanie ustawiona w ten sposób,
+rzeczywiste indeksy w tej tablicy nie zostaną zainicjalizowane.
+
+    var arr = new Array(3);
+    arr[1]; // undefined
+    1 in arr; // zwraca false, indeks nie został ustawiony
+
+Możliwość ustanienia z góry długości tablicy jest użyteczna tylko w kilku 
+przypadkach, jak powtarzanie ciągu znaków, w którym unika się stosowania 
+pętli `for`.
+
+    // count - ilosc powtorzen
+    // stringToRepeat - ciąg znaków do powtórzenia 
+    new Array(count + 1).join(stringToRepeat); 
+
+### Wnioski
+
+W miare możliwości należy unikać używania konstruktora `Array`. Literały są 
+zdecydowanie lepszym rozwiązaniem, są krótsze i mają bardziej precyzyjną składnię.
+Zwiększają również czytelność kodu.
+

doc/pl/array/general.md

@@ -0,0 +1,58 @@
+## Iterowanie po tablicach oraz właściwości tablic
+
+Mimo, że tablice w JavaScript są obiektami, nie ma dobrych powodów do używania 
+[`pętli for in`](#object.forinloop) do iteracji po nich. W rzeczywiści istnieje 
+wiele dobrych powodów **przeciwko** wykorzystania `for in` na tablicach.
+
+> **Uwaga:** Tablice JavaScriptowe **nie** są *tablicami asocjacyjnymi*. JavaScript
+> posiada tylko [obiekty](#object.general) do mapowania kluczy do wartości. Jednakże 
+> 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 to użycie 
+[`hasOwnProperty`](#object.hasownproperty), ale wówczas pętla staje się 
+**dwadzieście razy** wolniejsza od normalnej pętli `for`.
+
+### Iteracja
+
+W celu osiągnięcia najlepszej wydajności podczas iteracji po tablicach należy 
+użyć klasycznej pętli `for`.
+
+    var list = [1, 2, 3, 4, 5, ...... 100000000];
+    for(var i = 0, l = list.length; i < l; i++) {
+        console.log(list[i]);
+    }
+
+Jest tam jeszcze jeden dodatkowy haczyk w przykładzie powyżej. Jest to zbuforowanie 
+długości tablicy poprzez `l = list.length`.
+
+Mimo, że właściwość `length` jest zdefiniowana w 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ć optymalizację w tym 
+przypadku. Nie ma jednak możliwość ustalenia czy kod będzie wykonywany w jednym 
+z tych nowych silników czy też nie.
+
+W rzeczywistości pomijając buforowanie długości tablicy może spowodować, że pętla 
+będzie tylko **w połowie tak szybka** jak ta z buforowaniem długości.
+
+### Właściwość `length`
+
+Mimo, że *getter* właściwości `length` po prostu zwraca liczbę elementów, które są 
+zawarte w tablicy, to *setter* może być użyta do **skracania** tablicy.
+
+    var foo = [1, 2, 3, 4, 5, 6];
+    foo.length = 3;
+    foo; // [1, 2, 3]
+
+    foo.length = 6;
+    foo; // [1, 2, 3]
+
+Przypisanie mniejszej długości spowoduje skrócenie tablicy, ale zwiększenie wartości 
+`length` nie ma żadnego wpływu na tablicę.
+
+### Wnioski
+
+Aby uzyskać najlepszą wydajność zaleca się, aby zawsze używać zwykłej pętli `for`
+i zbuforowanie właściwości `length`. Korzystanie z pętli `for in` na tablicy jest 
+znakiem źle napisanego kodu, który jest podatny na błędy i ma słabą wydajność.
+

doc/pl/full_index.json

@@ -55,7 +55,7 @@
             ]
         },
         {
-            "title": "?Wnętrze?",
+            "title": "Jądro",
             "dir": "core",
             "articles": [
                 "eval",

doc/pl/function/arguments.md

@@ -0,0 +1,122 @@
+## obiekt `arguments`
+
+Każda zasięg funkcyjny w języku JavaScript ma dostęp do specjalnej zmiennej `arguments`. 
+Ta zmienna trzyma listę wszystkich argumentów przekazanych do funkcji.
+
+> **Uwaga:** W przypadku gdy `arguments` zostanie zadeklarowana wewnatrz funkcji
+> poprzez `var` lub jako nazwa jednego z formalnych parametrów, obiekt `arguments` 
+> nie zostanie utworzony.
+
+Obiekt `arguments` **nie** jest typu `Array`. Mimo, że posiada pewne cechy 
+semantyki tablic - właściwość `length` - to nie dziedziczy on z `Array.prototype`,
+ale w rzeczywistości z `Object`.
+
+Ze względu na to **nie** można używać standardowych dla tablic metod takich jak
+`push`, `pop` czy `slice` na obiekcie `arguments`. Mimo, że iteracja przy pomocy 
+pętli `for` działa dobrze, to aby skorzystać ze standardowych metod tablicowych 
+należy skonwertować `arguments` do prawdziwego obiekt `Array`.
+
+### Konwersja do tablicy
+
+Poniższy kod zwróci nowy obiekt `Array` zawierający wszystkie elementy 
+obiektu `arguments`.
+
+    Array.prototype.slice.call(arguments);
+
+Jednakże konwersja ta jest **wolna** i **nie jest zalecana** w sekcjach, 
+które mają duży wpływ na wydajność.
+
+### Przekazywanie argumentów
+
+Zalecany sposób przekazywania argumentów z jednej funkcji do następnej 
+wyglada następująco.
+
+    function foo() {
+        bar.apply(null, arguments);
+    }
+    function bar(a, b, c) {
+        // do stuff here
+    }
+
+Kolejną sztuczką jest użycie razem `call` i `apply` w celu stworzenia 
+szybkich i nieograniczonych wrapperów.  
+
+    function Foo() {}
+
+    Foo.prototype.method = function(a, b, c) {
+        console.log(this, a, b, c);
+    };
+
+    // Stworzenie nieograniczoną wersję metody "method" 
+    // która przyjmuje parametry: this, arg1, arg2...argN
+    Foo.method = function() {
+
+        // Rezultat: Foo.prototype.method.call(this, arg1, arg2... argN)
+        Function.call.apply(Foo.prototype.method, arguments);
+    };
+
+
+### Parametry formalne i indeksy argumentów
+
+Obiekt `arguments` tworzy funckje *getter* i *setter* nie tylko dla swoich 
+właściwości, ale również dla parametrów formalnych funkcji.
+
+W rezultacie zmiana wartości parametru formalnego zmieni również wartość 
+odpowiadającemu mu wpisowi w obiekcie `arguments`, zachodzi to również w drugą stronę.
+
+    function foo(a, b, c) {
+        arguments[0] = 2;
+        a; // 2                                                           
+
+        b = 4;
+        arguments[1]; // 4
+
+        var d = c;
+        d = 9;
+        c; // 3
+    }
+    foo(1, 2, 3);
+
+### Mity i prawdy o wydajności
+
+Obiekt `arguments` jest zawsze tworzony z wyjątkiem dwóch przypadków, gdy
+zmienna o takiej nazwie jest zdefiniowana wewnątrz funkcji lub jeden z parametrów 
+formalnych funkcji ma taką nazwę. Nie ma znaczenia czy obiekt `arguments` jest 
+używany czy nie.
+
+Zarówno *gettery* jak i *settery* są zawsze tworzone, zatem używanie ich nie ma 
+praktycznie żadnego wpływu na wydajność. Zwłaszcza w rzeczywistym kodzie, który 
+wykorzystuje coś więcej niż tylko prosty dostęp do właściwości obiektu `arguments`. 
+
+> **Uwaga ES5:** *gettery* and *settery* nie są tworzone w trybie strict mode
+
+Jednakże, istnieje jeden przypadek w którym wydajność drastycznie spada w 
+nowoczesnych silnikach JavaScript. Ten przypadek to wykorzystanie 
+`arguments.callee`.
+
+    function foo() {
+        arguments.callee; // operowanie na obiekcie funkcji
+        arguments.callee.caller; // i obiekcie funkcji wywołującej
+    }
+
+    function bigLoop() {
+        for(var i = 0; i < 100000; i++) {
+            foo(); // Normalnie zostałaby wykorzystana metoda inline
+        }
+    }
+
+W powyższym przykładzie `foo` nie może zostać wykorzystana metoda [inline][1] 
+ponieważ potrzebne są nie tylko informacje na własny temat ale również 
+na temat funkcji wywołującej. Takie użycie nie tylko uniemożliwia 
+inlining i korzyści z niej wynikające, ale również stanowi złamanie 
+zasad enkapsulacji ponieważ ta funkcja jest zależna od kontekstu 
+w jakim została wywołana.
+
+**Mocno zalecane** jest aby **nigdy** nie korzystać z `arguments.callee` 
+i żadnej jej własności.
+
+> **Uwaga ES5:** W trybie strict mode, `arguments.callee` wyrzuci `TypeError` 
+> ponieważ korzystanie z niej jest przestarzałe.
+
+[1]: http://en.wikipedia.org/wiki/Inlining
+

doc/pl/function/closures.md

@@ -0,0 +1,101 @@
+## Domknięcia i referencje
+
+Jedną z najpotężniejszych funkcjonalności języka JavaScript są *domknięcia*, 
+oznacza to że zasięg **zawsze** posiada dostęp do zewnętrznego zasięgu w którym 
+został zdefiniowany. Ponieważ zasięg w JavaScript można definiować tylko poprzez 
+[funckję](#function.scopes), wszystkie funkcje domyślnie zachowują się jak domknięcia.
+
+### Emulowanie prywatnych zmiennych
+
+    function Counter(start) {
+        var count = start;
+        return {
+            increment: function() {
+                count++;
+            },
+
+            get: function() {
+                return count;
+            }
+        }
+    }
+
+    var foo = Counter(4);
+    foo.increment();
+    foo.get(); // 5
+
+Tutaj `Counter` zwraca **dwa** domknięcia: funkcję `increment` oraz funckję `get`. 
+Obie te funkcję trzymają **referencję** do zasięgu `Counter` a co za tym idzie 
+zawsze posiadają dostęp do zmiennej `count` tak, jakby ta zmienna była zdefiniowana 
+w zasięgu tych funkcji.
+
+### Dlaczego zmienne przywatne działają
+
+Ponieważ nie ma możliwości wskazania lub przypisania zasięgu w JavaScript, to 
+**nie** istnieje sposób aby uzyskać dostęp do zmiennej `count` z zewnątrz. 
+Wykorzystanie tych dwóch domkinęć jest jedynym sposobem na interakcję z tą zmienną.
+
+    var foo = new Counter(4);
+    foo.hack = function() {
+        count = 1337;
+    };
+
+
+Powyższy kod **nie** zmieni wartości zmiennej `count` wewnątrz zasięgu `Counter`, 
+ponieważ `foo.hack` nie została zadeklarowana wewnątrz **tego konkretnego** zasięgu. 
+Zamiast tego funkcja utworzy lub nadpisze *globalną* zmienną `count`.
+
+### Domknięcia wewnątrz pętli
+
+Jednym z częstrzych błędów jest wykorzystywanie domknięć wewnątrz pętli, 
+aby wartość zmiennej po której odbywa się iteracja był kopiowana do 
+wewnętrznej funkcji.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout(function() {
+            console.log(i);  
+        }, 1000);
+    }
+
+Powyższy kod **nie** wypisze numerów od `0` do `9`, ale wypisze 
+dziesięć razy liczbę `10`.
+
+*Anonimowa* funkcja trzyma **wskaźnik** do zmiennej `i` i podczas uruchomienia 
+`console.log`, pętla `for` już zakończyła działanie i wartość zmiennej `i` 
+została ustawiona na `10`.
+
+Aby otrzymać zamierzony efekt, niezbędne jest **skopiowanie** wartości 
+zmiennej `i`.
+
+### Unikanie problemu z referencją
+
+Aby skopiować wartość zmiennej, po której iterujemy w pętli, należy skorzystać 
+z [anonimowego wrappera](#function.scopes).
+
+    for(var i = 0; i < 10; i++) {
+        (function(e) {
+            setTimeout(function() {
+                console.log(e);  
+            }, 1000);
+        })(i);
+    }
+
+Zewnętrzna anonimowa funkcja zostaje wywołana od razu z parametrem `i` 
+jako pierwszym argumentem i otrzyma kopię **wartości** zmiennej `i` jako 
+zmienną `e`.
+
+Anonimowa funkcja która zostaje przekazana do `setTimeout` teraz posiada 
+referencję do zmiennej `e`, która nie zostanie zmieniona przez pętle `for`.
+
+Istnieje jeszcze jeden sposób na osiągnięcie tego samego efektu. Należy zwrócic 
+fukcję z anonimowego wrappera, wówczas kod będzie zachowywał się jak ten 
+wcześniejszy.
+
+    for(var i = 0; i < 10; i++) {
+        setTimeout((function(e) {
+            return function() {
+                console.log(e);
+            }
+        })(i), 1000)
+    }
+

doc/pl/function/general.md

@@ -0,0 +1,52 @@
+## Deklaracje funkcji i wyrażenia funkcyjne
+
+Funcje w języku JavaScript są [typami pierwszoklasowymi][1]. Co oznacza, że mogą 
+być przekazywane jak każda inna wartość. Jednym z typowych zastosowań tej cechy 
+jest przekazywanie *anonimowej funkcji* jako callback do innej, prawdopodobnie 
+asynchronicznej funkcji.
+
+### Deklaracja funckcji
+
+    function foo() {}
+
+Powyższa funkcja zostaje [wyniesiona](#function.scopes) zanim program wystartuje, dzięki temu 
+jest dostępna *wszędzie* w ramach zasięgu, w którym została *zadeklarowana*,
+nawet jeżeli ta funkcja została wywołana przed faktyczną definicją w kodzie źródłowym.
+
+    foo(); // Działa ponieważ definicja funkcji została wyniesiona na początek zasięgu przed uruchomieniem kodu
+    function foo() {}
+
+### Wyrażenie funkcyjne
+
+    var foo = function() {};
+
+Ten przykład przypisuje nienazwaną i *anonimową* funkcję do zmiennej `foo`.  
+
+    foo; // 'undefined'
+    foo(); // wyrzuca błąd TypeError
+    var foo = function() {};
+
+Ze względu na fakt, że deklaracja `var` wynosi zmienną `foo` na początek zasięgu, 
+zanim kod faktycznie zostanie uruchomiony, `foo` będzie zdefiniowane kiedy skrypt 
+będzie wykonywany.
+
+Ale ponieważ przypisania robione są dopiero podczas wykonania, wartość `foo` będzie 
+ustawiona na domyślną wartość [undefined](#core.undefined) zanim powyższy kod 
+zostanie uruchomiony.
+
+### Nazwane wyrażenia funkdyjne
+
+Kolejnym specjalnym przypadkiem jest przypisanie nazwanej funkcji. 
+
+    var foo = function bar() {
+        bar(); // Działa
+    }
+    bar(); // wyrzuca ReferenceError
+
+W zewnętrznym zakresie `bar` nie będzie dostępne, ponieważ funkcja zostaje 
+przypisana do `foo`, jednakże w wewnętrznym zakresie `bar` będzie dostępna.
+Jest to spowodowane tym, jak działa [rozwiązywanie nazw](#function.scopes) 
+w języku JavaScript. Nazwa funkcji jest *zawsze* dostępna w lokalnym 
+zakresie tej funkcji.
+
+[1]: http://pl.wikipedia.org/wiki/Typ_pierwszoklasowy