Polish translation of types section.

Author: Lukasz Kufel

doc/pl/index.json

@@ -43,6 +43,16 @@
                 "general",
                 "constructor"
             ]
+        },
+        {
+            "title": "Typy",
+            "dir": "types",
+            "articles": [
+                "equality",
+                "typeof",
+                "instanceof",
+                "casting"
+            ]
         }
     ]
 }

doc/pl/intro/translators.md

@@ -1,6 +1,5 @@
 ## Tłumaczenie
 
- - [Łukasz Kufel][1] ([qfel13.pl][2])
+ - [Łukasz Kufel][1]
 
-[1]: https://github.com/qfel13
-[2]: http://qfel13.pl
+[1]: http://qfel13.pl

doc/pl/types/casting.md

@@ -0,0 +1,72 @@
+## Rzutowanie typów
+
+JavaScript jest językiem słabo typowanym, co za tym idzie będzie stosować koercję 
+typów **gdziekolwiek** jest to możliwe.
+
+    // These are true
+    new Number(10) == 10; // Number.toString() zostanie przekształcone
+                          // z powrotem do liczby
+
+    10 == '10';           // Stringi zostaną przekształcone do typu Number
+    10 == '+10 ';         // Kolejne wariacje
+    10 == '010';          // i następne
+    isNaN(null) == false; // null zostanie przekształcony do 0
+                          // który oczywiście nie jest NaN
+    
+    // Poniższe zwracają false
+    10 == 010;
+    10 == '-10';
+
+> **Uwaga ES5: Literały licznowe zaczynające sie od `0` są interpretowane jako
+> liczby w systemie ósemkowym. W trybie strict mode w ECMAScript 5 wsparcie dla 
+> liczb ósemkowych zostało porzucone.
+
+Aby uniknąć powyższych problemów, należy **koniecznie** skorzystać ze 
+[ściełego operatora równości](#types.equality). Mimo, że pozwala to uniknąć wiele 
+typowych problemów to nadal istnieje wiele innych, które powstają na bazie słabego 
+typowania języka JavaScript.
+
+### Konstruktory typów wbudowanych
+
+Konstruktory typów wbudowanych takich, jak `Number` lub `String` zachowują się 
+inaczej jeżeli są poprzedzone słowem kluczowym `new` a inaczej jeżeli nie są.
+
+    new Number(10) === 10;     // False, Object i Number
+    Number(10) === 10;         // True, Number i Number
+    new Number(10) + 0 === 10; // True, ponieważ dokonana została jawna konwersja
+
+Korzystanie z wbudowanych typów jak `Number` jako konstruktor utworzy nowy obiekt 
+typu `Number`, natomiast opuszczenie słowa kluczowego `new` spowoduje, że funkcja 
+`Number` zachowa się jak konwerter.
+
+Ponadto, użycie literałów lub wartości nieobiektowych zaowocuje jeszcze większą 
+ilością rzutowań (koercją) typów.
+
+Najlepszym rozwiązaniem jest **jawne** rzutowanie do jednego z trzech typów.
+
+### Rzutowanie do typu String
+
+    '' + 10 === '10'; // true
+
+Konkatenacja pustego stringu i wartości powoduje rzutowanie do typu String. 
+
+### Rzutowanie do typu Number
+
+    +'10' === 10; // true
+
+Zastosowanie **unarnego** operatora + spowoduje rzutowanie do typu Number.
+
+### Rzutowanie do typu Boolean
+
+Używając dwukrotnie operatora **negacji** dowolna wartość może zostać zrzutowana 
+do typu Boolean
+
+    !!'foo';   // true
+    !!'';      // false
+    !!'0';     // true
+    !!'1';     // true
+    !!'-1'     // true
+    !!{};      // true
+    !!true;    // true
+
+

doc/pl/types/equality.md

@@ -0,0 +1,71 @@
+## Równość i porównania
+
+JavaScript posiada dwa różne sposoby równościowego porównywania obiektów. 
+
+### Operator równości
+
+Operator równości składa się z dwóch znaków "równa się": `==`
+
+JavaScript jest słabo typowanym językiem. Oznacza to, że operator równości 
+**konwertuje** typy (dokonuje **koercji**), aby wykonać porównanie.
+    
+    ""           ==   "0"           // false
+    0            ==   ""            // true
+    0            ==   "0"           // true
+    false        ==   "false"       // false
+    false        ==   "0"           // true
+    false        ==   undefined     // false
+    false        ==   null          // false
+    null         ==   undefined     // true
+    " \t\r\n"    ==   0             // true
+
+Powyższa tabela przedstawia wyniki koercji typów. Nieprzewidywalne wyniki 
+porównania są głównym powodem, że stosowanie `==` jest powszechnie uważane za złą 
+praktykę. Skomplikowane reguły konwersji są powodem trudnych do wyśledzenia błędy.
+
+Ponadto koercja ma również wpływ na wydajność na przykład gdy typ String musi zostać 
+przekształcony na typ Number przed porównaniem z drugą liczbą.
+
+### Operator ścisłej równości
+
+Operator ścisłej równości składa się z **trzech** znaków "równa się": `===`
+
+Działa on dokładnie tak jak normalny operator równości, z jednym wyjątkiem nie 
+dokonuje koercji typów przed porównaniem.
+
+    ""           ===   "0"           // false
+    0            ===   ""            // false
+    0            ===   "0"           // false
+    false        ===   "false"       // false
+    false        ===   "0"           // false
+    false        ===   undefined     // false
+    false        ===   null          // false
+    null         ===   undefined     // false
+    " \t\r\n"    ===   0             // false
+
+Powyższe rezultaty są o wiele bardziej przejrzyste. Powoduje to "ustatycznienie"
+języka do pewnego stopnia oraz pozwala na wprowadzenie optymalizacji porównań 
+obiektów o różnych typach.
+
+### Porównywanie obiektów
+
+Mimo, że oba operatory `==` i `===` nazywane są operatorami **równościowymi**, 
+to zachowują się różnie gdy jednym z operandów jest obiekt typu `Object`.
+
+    {} === {};                   // false
+    new String('foo') === 'foo'; // false
+    new Number(10) === 10;       // false
+    var foo = {};
+    foo === foo;                 // true
+
+Oba operatory porównują **toższmość** a **nie** równość, czyli będą porównywać czy 
+jeden i drugi operand jest tą samą **instancją** obiektu, podobnie jak operator 
+`is` w Pythonie i porównanie wskaźników w C.  
+
+### Wnioski
+
+Zaleca się aby używać tylko operatora **ścisłej równości**. W sytuacjach gdy 
+potrzebna jest koercja (porównanie obiektów różnych typów), konwersja powinna 
+być dokonana [jawnie](#types.casting) a nie pozostawiona trudnym regułom koercji 
+obowiązującym w języku.
+

doc/pl/types/instanceof.md

@@ -0,0 +1,41 @@
+## Operator `instanceof`
+
+Operator `instanceof` porównuje konstruktory obiektów przekazanych jako operendy. 
+Jest on jedynie użyteczny do porównywania obiektów utworzonych klas. Stosowanie 
+go na wbudowanych typach jest praktycznie tak samo bezużyteczne jak operatora
+[typeof](#types.typeof).
+
+### Porównywanie obiektów utworzonych klas
+
+    function Foo() {}
+    function Bar() {}
+    Bar.prototype = new Foo();
+
+    new Bar() instanceof Bar; // true
+    new Bar() instanceof Foo; // true
+
+    // Poniżej kod który przypisuje do Bar.prototype obiekt funkcji Foo
+    // a nie faktyczną instancję Foo
+    Bar.prototype = Foo;
+    new Bar() instanceof Foo; // false
+
+### Stosowanie `instanceof` na natywnych typach
+
+    new String('foo') instanceof String; // true
+    new String('foo') instanceof Object; // true
+
+    'foo' instanceof String; // false
+    'foo' instanceof Object; // false
+
+Jedną ważną rzeczą, którą należy zauważyć jest to, że `instanceof` nie zadziała 
+na obiektach, które pochodzą z różnych kontekstów JavaScript (np. z różnych 
+dokumentów wewnątrz przeglądarki), ponieważ ich konstruktory nie będą tymi 
+samymi obiektami.
+
+### Wnioski
+
+Operator `instanceof` powinien być **tylko** używany podczas korzystania z obiektów 
+klas utworzonych, które były zdefiniowane w tym samym kontekscie JavaScriptowym. 
+Podobnie jak operator [`typeof`](#types.typeof), należy **unikać** korzystania 
+z tego operatora w innych sytuacjach.
+

doc/pl/types/typeof.md

@@ -0,0 +1,87 @@
+## Operator `typeof` 
+
+Operator `typeof` (razem z operatorem [`instanceof`](#types.instanceof)) jest 
+prawdopodobnie najwiekszą wadą konstrukcji języka JavaScript, jest on praktycznie 
+**całkowicie wadliwy**.
+
+Mimo, że `instanceof` ma swoje wady to nadal ma ograniczone zastosowanie w praktyce, 
+natomiast `typeof` ma tylko jeden praktyczny przypadek użycia, który na dodatek 
+**nie** jest związany z sprawdzaniem typu obiektu.
+
+> **Uwaga:** Do wywołania operatora `typeof` może zostać użyta składnia funkcyjna np. 
+> `typeof(obj)`, ale nie jest to wywołanie funkcji. Dwa nawiasy zwrócą obiekt 
+> znajdujący się wewnątrz i zwrócona wartość stanie się operandem operatora 
+> `typeof`. **Nie istnieje** funkcja `typeof`. 
+
+### Tablica typów JavaScript
+
+    Wartość             Klasa      Typ
+    -------------------------------------
+    "foo"               String     string
+    new String("foo")   String     object
+    1.2                 Number     number
+    new Number(1.2)     Number     object
+    true                Boolean    boolean
+    new Boolean(true)   Boolean    object
+    new Date()          Date       object
+    new Error()         Error      object
+    [1,2,3]             Array      object
+    new Array(1, 2, 3)  Array      object
+    new Function("")    Function   function
+    /abc/g              RegExp     object (function w Nitro i V8)
+    new RegExp("meow")  RegExp     object (function w Nitro i V8)
+    {}                  Object     object
+    new Object()        Object     object
+
+W powyższej tabeli *Typ* odnosi się do wartości zwracanej przez operator `typeof`. 
+Wyraźnie widać, że zwracane wartości w ogóle nie są spójne.
+
+*Klasa* odnosi sie do wartości wewnętrznej właściwości `[[Class]]` obiektu.
+
+> **Fragment Specyfikacji:** Wartość `[[Class]]` może być jednym z poniższych 
+> stringów. `Arguments`, `Array`, `Boolean`, `Date`, `Error`, 
+> `Function`, `JSON`, `Math`, `Number`, `Object`, `RegExp`, `String`.
+
+W celu uzyskania wartości właściwości `[[Class]]` trzeba skorzystać z metody
+`toString` z `Object.prototype`. 
+
+### Klasa obiektu
+
+Specyfikacja zawiera dokładnie jeden sposób dostepu do wartości `[[Class]]`, 
+wykorzystując `Object.prototype.toString`. 
+
+    function is(type, obj) {
+        var clas = Object.prototype.toString.call(obj).slice(8, -1);
+        return obj !== undefined && obj !== null && clas === type;
+    }
+    
+    is('String', 'test'); // true
+    is('String', new String('test')); // true
+
+Powyższy przykład wywołuje `Object.prototype.toString` z wartością 
+[this](#function.this) ustawioną na obiekt, dla której wartość właściwości 
+`[[Class]]` ma zostać odczytana. 
+
+> **Uwaga ES5:** Dla zwiększenia wygody wartość zwracana przez 
+> `Object.prototype.toString` dla `null` i `undefined` została zmieniona 
+> z `Object` na `Null` i `Undefined` w ECMAScript 5.
+
+### Testowanie niezdefiniowania zmiennej
+
+    typeof foo !== 'undefined'
+
+Powyższy kod sprawdza czy `foo` została faktycznie zadeklarowana czy też nie. 
+Próba odwołania się do zmiennej spowodowała by wyrzucenie błędu `ReferenceError`. 
+Jest to jedyne praktyczne wykorzystanie operatora `typeof`.
+
+### Wnioski
+
+W celu sprawdzenia typu obiektu zalecane jest skorzystanie z 
+`Object.prototype.toString`, ponieważ jest to jedyny wiarygodny sposób. Jak 
+pokazano w powyższej tabeli typów, niektóre wartości zwracane przez `typeof` nie 
+są zdefiniowane w specyfikacji, co za tym idzie mogą się różnić w różnych 
+implementacjach.
+
+O ile nie operator `typeof` nie jest użyty do sprawdzania czy zmienna została 
+zdefiniowana, powinien być unikany **o ile to tylko możliwe**.
+