Permalink
Browse files

Polish translation of types section.

  • Loading branch information...
1 parent 33efc05 commit 95f57a73541b8207bbfdd404f76b3c3a0f28ca24 Lukasz Kufel committed May 5, 2011
Showing with 283 additions and 3 deletions.
  1. +10 −0 doc/pl/index.json
  2. +2 −3 doc/pl/intro/translators.md
  3. +72 −0 doc/pl/types/casting.md
  4. +71 −0 doc/pl/types/equality.md
  5. +41 −0 doc/pl/types/instanceof.md
  6. +87 −0 doc/pl/types/typeof.md
View
10 doc/pl/index.json
@@ -43,6 +43,16 @@
"general",
"constructor"
]
+ },
+ {
+ "title": "Typy",
+ "dir": "types",
+ "articles": [
+ "equality",
+ "typeof",
+ "instanceof",
+ "casting"
+ ]
}
]
}
View
5 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
View
72 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
+
+
View
71 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.
+
View
41 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.
+
View
87 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**.
+

0 comments on commit 95f57a7

Please sign in to comment.