From fb50a432bcf2955ff99db9e410d85b0f315a3eb8 Mon Sep 17 00:00:00 2001 From: bartek7 Date: Sun, 14 Jul 2019 16:17:19 +0200 Subject: [PATCH 1/4] Translated conversion into PL --- .../solution.md | 12 +- .../1-primitive-conversions-questions/task.md | 8 +- .../06-type-conversions/article.md | 118 +++++++++--------- 3 files changed, 69 insertions(+), 69 deletions(-) diff --git a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md index 7dd0d61c2..e103fa5e3 100644 --- a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md +++ b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md @@ -16,9 +16,9 @@ null + 1 = 1 // (5) undefined + 1 = NaN // (6) ``` -1. The addition with a string `"" + 1` converts `1` to a string: `"" + 1 = "1"`, and then we have `"1" + 0`, the same rule is applied. -2. The subtraction `-` (like most math operations) only works with numbers, it converts an empty string `""` to `0`. -3. The addition with a string appends the number `5` to the string. -4. The subtraction always converts to numbers, so it makes `" -9 "` a number `-9` (ignoring spaces around it). -5. `null` becomes `0` after the numeric conversion. -6. `undefined` becomes `NaN` after the numeric conversion. +1. Dodawanie stringa `"" + 1` konwertuje `1` do stringa: `"" + 1 = "1"` i wtedy mamy zastosowane `"1" + 0`. +2. Odejmowanie `-` (jak większość matematycznych operacji) działa wyłącznie z typami liczbowymi i konwertuje pusty string `""` do `0`. +3. Dodawanie stringa dołącza liczbę `5` do tego stringa. +4. Odejmowanie zawsze konwertuje do liczby, zatem konwertuje `" -9 "` na typ number `-9` (ignoruje spacje dookoła). +5. `null` stanie się `0` po konwersji na liczbę. +6. `undefined` stanie się `NaN` po konwersji na liczbę. diff --git a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md index f17e870de..0423fdebc 100644 --- a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md +++ b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md @@ -1,10 +1,10 @@ -importance: 5 +Ważność: 5 --- -# Type conversions +# Konwersje typów -What are results of these expressions? +Jakie będą rezultaty poniższych wyrażeń? ```js no-beautify "" + 1 + 0 @@ -23,4 +23,4 @@ null + 1 undefined + 1 ``` -Think well, write down and then compare with the answer. +Pomyśl dobrze, zapisz odpowiedzi i porównaj z prawidłowym rozwiązaniem. \ No newline at end of file diff --git a/1-js/02-first-steps/06-type-conversions/article.md b/1-js/02-first-steps/06-type-conversions/article.md index 6ac695e84..859fc11da 100644 --- a/1-js/02-first-steps/06-type-conversions/article.md +++ b/1-js/02-first-steps/06-type-conversions/article.md @@ -1,111 +1,111 @@ -# Type Conversions +# Konwersje typów -Most of the time, operators and functions automatically convert the values given to them to the right type. +W większości przypadków operatory i funkcje automatycznie konwertują przekazywane do nich wartości na właściwy typ. -For example, `alert` automatically converts any value to a string to show it. Mathematical operations convert values to numbers. +Na przykład `alert` automatycznie zmieni typ dowolnej wartości do stringa. Matematyczne operacje konwertują wartości do typu liczbowego. -There are also cases when we need to explicitly convert a value to the expected type. +Istnieją jednak przypadku, w których musimy jawne zmienić typ wartości na inny. -```smart header="Not talking about objects yet" -In this chapter, we won't cover objects. Instead, we'll study primitives first. Later, after we learn about objects, we'll see how object conversion works in the chapter . +```smart header="Nie mówimy jeszcze o obiektach" +W tym rozdziale nie zajmujemy się objektami. In this chapter, we won't cover objects. Zamiast tego nauczymy się najpierw typów prymitywnych. Później nauczymy się co nieco o obiektach i zobaczymy jak działa konwersja obiektów w rozdziale . ``` -## ToString +## ToString (do stringa) -String conversion happens when we need the string form of a value. +Konwersja do stringa następuje kiedy potrzebujemy wartości typu string. -For example, `alert(value)` does it to show the value. +Na przykład `alert(value)` konwertuje do stringa żeby wyświetlić wartość. -We can also call the `String(value)` function to convert a value to a string: +Możemy również wywołać funkcję `String(value)` żeby skonwertować wartość: ```js run let value = true; alert(typeof value); // boolean *!* -value = String(value); // now value is a string "true" +value = String(value); // teraz wartość "true" jest stringiem alert(typeof value); // string */!* ``` -String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc. +Konwersja stringów jest bardzo przewidywalna. `false` zostaje `"false"`, typ boolean `null` jest stringiem `"null"`, etc. -## ToNumber +## ToNumber (do liczby) -Numeric conversion happens in mathematical functions and expressions automatically. +Konwersja do typu liczbowego następuje automatycznie w wyniku matematycznych wyrażeń i funkcji. -For example, when division `/` is applied to non-numbers: +Na przykład dzielenie `/` dla wartości nie będących liczbami: ```js run -alert( "6" / "2" ); // 3, strings are converted to numbers +alert( "6" / "2" ); // 3, stringi są zamienione na liczby ``` -We can use the `Number(value)` function to explicitly convert a `value` to a number: +Możemy użyć funkcji `Number(value)`, aby jawnie przekonwertować `wartość` do liczby. ```js run let str = "123"; alert(typeof str); // string -let num = Number(str); // becomes a number 123 +let num = Number(str); // zostaje typem liczbowym o wartości 123 alert(typeof num); // number ``` -Explicit conversion is usually required when we read a value from a string-based source like a text form but expect a number to be entered. +Jawna konwersja jest zazwyczaj wymagana gdy chcemy odczytać wartość ze źródła będącą stringiem, a oczekujemy wartości liczbowej. -If the string is not a valid number, the result of such a conversion is `NaN`. For instance: +Jeśli string nie jest prawidłową liczbą wynikiem konwersji będzie `NaN`. Dla przykładu: ```js run -let age = Number("an arbitrary string instead of a number"); +let age = Number("dowolny ciąg znaków zamiast typu liczbowego"); -alert(age); // NaN, conversion failed +alert(age); // NaN, konwersja nie powiodła się ``` -Numeric conversion rules: +Zasady konwersji typu liczbowego: -| Value | Becomes... | -|-------|-------------| +| Wartość | Otrzymamy... | +|---------|-------------| |`undefined`|`NaN`| |`null`|`0`| |true and false | `1` and `0` | -| `string` | Whitespaces from the start and end are removed. If the remaining string is empty, the result is `0`. Otherwise, the number is "read" from the string. An error gives `NaN`. | +| `string` | Białe znaki z początku i końca są usunięte. Jeśli pozostała wartość stringa jest pusta wynikiem będzie `0`. W przeciwnym wypadku liczba jest odczytywana ze stringa. Wszystkie nieprawidłowe konwersje dają `NaN`. | -Examples: +Przykłady: ```js run alert( Number(" 123 ") ); // 123 -alert( Number("123z") ); // NaN (error reading a number at "z") +alert( Number("123z") ); // NaN (błąd podczas odczytywania liczby ze stringa "z") alert( Number(true) ); // 1 alert( Number(false) ); // 0 ``` -Please note that `null` and `undefined` behave differently here: `null` becomes zero while `undefined` becomes `NaN`. +Zauważ, że `null` i `undefined` zachowują się inaczej. `null` zostanie przekonwertowany do zera, natomiast `undefined` sprawi, że wynikiem będzie `NaN`. -````smart header="Addition '+' concatenates strings" -Almost all mathematical operations convert values to numbers. A notable exception is addition `+`. If one of the added values is a string, the other one is also converted to a string. +````smart header="'+' konkatenuje stringi" +Większość matematycznych operacji konwertuje wartości do typu liczbowego. Jedynym wyjątkiem jest `+`. Jeśli dodasz jedną z wartości, która będzie stringiem, wtedy wynikiem takiej operacji będzie typ string. -Then, it concatenates (joins) them: +Wtedy operacja je konkatenuje (łączy): ```js run -alert( 1 + '2' ); // '12' (string to the right) -alert( '1' + 2 ); // '12' (string to the left) +alert( 1 + '2' ); // '12' (string po prawej) +alert( '1' + 2 ); // '12' (string po lewej) ``` -This only happens when at least one of the arguments is a string. Otherwise, values are converted to numbers. +Dzieje się to w przypadku gdy przynajmniej jeden z argumentów jest stringiem. W przeciwnym wypadku wartości zostaną przekonwertowane na typ liczbowy. ```` ## ToBoolean -Boolean conversion is the simplest one. +Konwersje typu Boolean są najprostsze. -It happens in logical operations (later we'll meet condition tests and other similar things) but can also be performed explicitly with a call to `Boolean(value)`. +Zachodzą w logicznych operacjach (później poznamy warunki i inne podobne rzeczy) i może zostać wywołana z użyciem funkcji `Boolean(value)`. -The conversion rule: +Zasada konwersji: -- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`. -- Other values become `true`. +- Wartości, które są "puste" np. `0`, pusty string, `null`, `undefined` i `NaN` zostaną przekonwertowane do `false`. +- Inne wartości zostaną przekonwertowane do `true`. -For instance: +Na przykład: ```js run alert( Boolean(1) ); // true @@ -115,46 +115,46 @@ alert( Boolean("hello") ); // true alert( Boolean("") ); // false ``` -````warn header="Please note: the string with zero `\"0\"` is `true`" -Some languages (namely PHP) treat `"0"` as `false`. But in JavaScript, a non-empty string is always `true`. +````warn header="Miej na uwadze, że string z `\"0\"` będzie `true`" +Niektóre języki (np. PHP) traktują `"0"` jako `false`. Ale w JavaScript każdy string z jakąkolwiek wartością jest zawsze `true`. ```js run alert( Boolean("0") ); // true -alert( Boolean(" ") ); // spaces, also true (any non-empty string is true) +alert( Boolean(" ") ); // spacje, również true (jakakolwiek wartość stringowa jest true) ``` ```` -## Summary +## Podsumowanie -The three most widely used type conversions are to string, to number, and to boolean. +Trzy najczęściej używane konwersje dotyczą konwersji do stringu, liczby i typu boolean. -**`ToString`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values. +**`ToString`** -- Zachodzi gdy coś wpisujemy. Może zajść również z użyciem `String(value)`. Konwersja do stringa jest zazwyczaj oczywista dla prymitywnych wartości. -**`ToNumber`** -- Occurs in math operations. Can be performed with `Number(value)`. +**`ToNumber`** -- Zachodzi w matematycznych operacjach. Może zajść również z użyciem `Number(value)`. -The conversion follows the rules: +Konwersja jest zgodna z zasadami: -| Value | Becomes... | +| Wartość | Otrzymamy... | |-------|-------------| |`undefined`|`NaN`| |`null`|`0`| |true / false | `1 / 0` | -| `string` | The string is read "as is", whitespaces from both sides are ignored. An empty string becomes `0`. An error gives `NaN`. | +| `string` | String jest odczytywany taki "jak jest", białe znaki z obu stron są zignorowane. Pusty string staje się `0`. Błąd konwersji zwraca `NaN`.| -**`ToBoolean`** -- Occurs in logical operations. Can be performed with `Boolean(value)`. +**`ToBoolean`** -- Zachodzi w logicznych operacjach. Może zajść również z użyciem `Boolean(value)`. -Follows the rules: +Konwersja jest zgodna z zasadami: -| Value | Becomes... | +| Wartość | Otrzymamy... | |-------|-------------| |`0`, `null`, `undefined`, `NaN`, `""` |`false`| -|any other value| `true` | +|Każda inna wartość| `true` | -Most of these rules are easy to understand and memorize. The notable exceptions where people usually make mistakes are: +Większość z tych zasad jest łatwa do zrozumienia i zapamiętania. Most of these rules are easy to understand and memorize. Wyjątki, które warto wspomnieć, w których ludzie najczęściej popełniają błędy:Warte uwagi najczęściej popełnianie błędy: -- `undefined` is `NaN` as a number, not `0`. -- `"0"` and space-only strings like `" "` are true as a boolean. +- `undefined` to `NaN` jako number, a nie `0`. +- `"0"` i spacja w stringu np. `" "` będzie true jako boolean. -Objects aren't covered here. We'll return to them later in the chapter that is devoted exclusively to objects after we learn more basic things about JavaScript. +Objekty nie są tutaj omówione. Wrócimy do nich później w rozdziale , który jest poświęcony obiektom, gdy poznamy już więcej podstaw JavaScript. \ No newline at end of file From 2acb601ee17ed4532d48c301e118da5de8faad57 Mon Sep 17 00:00:00 2001 From: bartek7 Date: Tue, 23 Jul 2019 08:18:58 +0200 Subject: [PATCH 2/4] fixes typos and clean up the text --- .../1-primitive-conversions-questions/task.md | 2 +- .../06-type-conversions/article.md | 6 +- 1-js/02-first-steps/08-comparison/article.md | 93 ++++++++++--------- 3 files changed, 51 insertions(+), 50 deletions(-) diff --git a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md index 0423fdebc..9c16b43f7 100644 --- a/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md +++ b/1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/task.md @@ -1,4 +1,4 @@ -Ważność: 5 +importance: 5 --- diff --git a/1-js/02-first-steps/06-type-conversions/article.md b/1-js/02-first-steps/06-type-conversions/article.md index 859fc11da..f2dfb08b5 100644 --- a/1-js/02-first-steps/06-type-conversions/article.md +++ b/1-js/02-first-steps/06-type-conversions/article.md @@ -4,10 +4,10 @@ W większości przypadków operatory i funkcje automatycznie konwertują przekaz Na przykład `alert` automatycznie zmieni typ dowolnej wartości do stringa. Matematyczne operacje konwertują wartości do typu liczbowego. -Istnieją jednak przypadku, w których musimy jawne zmienić typ wartości na inny. +Istnieją jednak przypadki, w których musimy jawnie zmienić typ wartości na inny. ```smart header="Nie mówimy jeszcze o obiektach" -W tym rozdziale nie zajmujemy się objektami. In this chapter, we won't cover objects. Zamiast tego nauczymy się najpierw typów prymitywnych. Później nauczymy się co nieco o obiektach i zobaczymy jak działa konwersja obiektów w rozdziale . +W tym rozdziale nie zajmujemy się objektami. Zamiast tego nauczymy się najpierw typów prymitywnych. Później nauczymy się co nieco o obiektach i zobaczymy jak działa konwersja obiektów w rozdziale . ``` ## ToString (do stringa) @@ -28,7 +28,7 @@ alert(typeof value); // string */!* ``` -Konwersja stringów jest bardzo przewidywalna. `false` zostaje `"false"`, typ boolean `null` jest stringiem `"null"`, etc. +Konwersja stringów jest bardzo przewidywalna. `false` zostaje `"false"`, typ boolean `null` staje się stringiem `"null"`, etc. ## ToNumber (do liczby) diff --git a/1-js/02-first-steps/08-comparison/article.md b/1-js/02-first-steps/08-comparison/article.md index 8697076a4..5056dbba9 100644 --- a/1-js/02-first-steps/08-comparison/article.md +++ b/1-js/02-first-steps/08-comparison/article.md @@ -1,95 +1,96 @@ -# Comparisons +# Porównania -We know many comparison operators from maths: +Na matematyce poznaliśmy porównania: -- Greater/less than: a > b, a < b. -- Greater/less than or equals: a >= b, a <= b. -- Equals: `a == b` (please note the double equals sign `=`. A single symbol `a = b` would mean an assignment). -- Not equals. In maths the notation is ≠, but in JavaScript it's written as an assignment with an exclamation sign before it: a != b. +- Większe/mniejsze niż: a > b, a < b. +- Większe/mniejsze niż lub równe: a >= b, a <= b. +- Równe: `a == b` (zauważ, że jest tutaj podwójny znak `=`. Pojedyncze użycie `a = b` oznacza przypisanie). +- Nierówne. W matematyce zapiszemy to jako ≠, ale w JavaScript jest to zapisane jako wykrzyknik przed znakiem równości: a != b. -## Boolean is the result +## Wynikiem jest Boolean -Like all other operators, a comparison returns a value. In this case, the value is a boolean. +Jak wszystkie inne operatory porównanie zwraca wartość. W tym przypadku wartością jest Boolean. - `true` -- means "yes", "correct" or "the truth". - `false` -- means "no", "wrong" or "not the truth". -For example: +Na przykład: ```js run -alert( 2 > 1 ); // true (correct) -alert( 2 == 1 ); // false (wrong) -alert( 2 != 1 ); // true (correct) +alert( 2 > 1 ); // true (prawda) +alert( 2 == 1 ); // false (fałsz) +alert( 2 != 1 ); // true (prawda) ``` -A comparison result can be assigned to a variable, just like any value: +Wynik porównania może być przypisany do zmiennej, jak każda inna wartość: ```js run -let result = 5 > 4; // assign the result of the comparison +let result = 5 > 4; // przypisz wynik porównania alert( result ); // true ``` -## String comparison +## Porównanie stringów -To see whether a string is greater than another, JavaScript uses the so-called "dictionary" or "lexicographical" order. +Aby zobaczyć czy ciąg znaków jest większy niż inny JavaScript używa porównania, które nazywamy "słownikowym" lub "leksykograficznym". -In other words, strings are compared letter-by-letter. +Innymi słowy, stringi porównywane są litera po literze. -For example: +Na przykład: ```js run alert( 'Z' > 'A' ); // true -alert( 'Glow' > 'Glee' ); // true -alert( 'Bee' > 'Be' ); // true +alert( 'Brat' > 'Brak' ); // true +alert( 'Jan' > 'Ja' ); // true ``` -The algorithm to compare two strings is simple: +Algorytm porównuje dwa stringi w prosty sposób: -1. Compare the first character of both strings. -2. If the first character from the first string is greater (or less) than the other string's, then the first string is greater (or less) than the second. We're done. -3. Otherwise, if both strings' first characters are the same, compare the second characters the same way. -4. Repeat until the end of either string. -5. If both strings end at the same length, then they are equal. Otherwise, the longer string is greater. +1. Porównaj pierwszy znak w obu stringach. +2. Jeśli pierwszy znak w pierwszym stringu jest większy (lub mniejszy) niż inny string, wtedy pierwszy string jest większy (lub mniejszy). Porównanie zakończone. +3. Jeśli pierwsze znaki są takie same zrób porównanie dla kolejnego znaku w ten sam sposób jak w punkcie nr 2. +4. Powtarzaj dopóki nie dojdzie do końca stringu. +5. Jeśli oba stringi mają taką samą długość są równe. W przeciwnym przypadku dłuższy string jest większy. -In the examples above, the comparison `'Z' > 'A'` gets to a result at the first step while the strings `"Glow"` and `"Glee"` are compared character-by-character: +W powyższych przypadkach porównanie `'Z' > 'A'` zwróci rezultat w pierwszym podejściu. Porównanie `"Brat"` z `"Brak"` będzie porównywane znak po znaku: -1. `G` is the same as `G`. -2. `l` is the same as `l`. -3. `o` is greater than `e`. Stop here. The first string is greater. +1. `B` jest takie same jak `B`. +2. `r` jest takie same jak `r`. +3. `a` jest takie same jak `a`. +3. `t` jest większe niż `k`. Zatrzymaj tutaj. Pierwszy string jest większy. -```smart header="Not a real dictionary, but Unicode order" -The comparison algorithm given above is roughly equivalent to the one used in dictionaries or phone books, but it's not exactly the same. +```smart header="Nie do końca słownikowa, bo kolejność wg Unicode" +Podany powyżej przykład jest prawie taki sam jak algorytm używany w słownikach lub książkach telefonicznych. Ale nie jest dokładnie taki sam. -For instance, case matters. A capital letter `"A"` is not equal to the lowercase `"a"`. Which one is greater? The lowercase `"a"`. Why? Because the lowercase character has a greater index in the internal encoding table JavaScript uses (Unicode). We'll get back to specific details and consequences of this in the chapter . +Na przykład wielkość ma znaczenie. Duża litera `"A"` nie jest równa małej literze `"a"`. Która jest większa? Mała litera `"a"`. Dlaczego? Ponieważ małe litery mają większy index w wewnętrznej tabeli kodowania znaków (Unicode), której używa JavaScript. Wrócimy do tego w rozdziale . ``` -## Comparison of different types +## Porównania wartości różnego typu -When comparing values of different types, JavaScript converts the values to numbers. +Kiedy porównujemy wartości różnego typu JavaScript konwertuje te wartości na liczby. -For example: +Na przykład: ```js run -alert( '2' > 1 ); // true, string '2' becomes a number 2 -alert( '01' == 1 ); // true, string '01' becomes a number 1 +alert( '2' > 1 ); // true, string '2' staje się numerem 2 +alert( '01' == 1 ); // true, string '01' staje się numerem 1 ``` -For boolean values, `true` becomes `1` and `false` becomes `0`. +Dla wartości Boolean `true` staje się `1`, a `false` staje się `0`. -For example: +Na przykład: ```js run alert( true == 1 ); // true alert( false == 0 ); // true ``` -````smart header="A funny consequence" -It is possible that at the same time: +````smart header="Zabawna zależność" +Jest możliwe, aby w tym samym czasie: -- Two values are equal. -- One of them is `true` as a boolean and the other one is `false` as a boolean. +- Dwie wartości były równe. +- Jedna z nich będzie `true` jako Boolean, natomiast druga jest `false` jako Boolean. -For example: +Na przykład: ```js run let a = 0; @@ -101,7 +102,7 @@ alert( Boolean(b) ); // true alert(a == b); // true! ``` -From JavaScript's standpoint, this result is quite normal. An equality check converts values using the numeric conversion (hence `"0"` becomes `0`), while the explicit `Boolean` conversion uses another set of rules. +Z punkty widzenia JavaScript taki rezultat jest oczekiwany i normalny. Porównanie konwertuje wartości na typ liczbowy (więc string `"0"` zostaje `0`), podczas gdy porównanie `Boolean` konwertuje te wartości w inny sposób. ```` ## Strict equality From 9a0202954472744d718239e99f524a5484fb4007 Mon Sep 17 00:00:00 2001 From: bartek7 Date: Tue, 23 Jul 2019 08:20:31 +0200 Subject: [PATCH 3/4] fix funny 'objekt' in polish --- 1-js/02-first-steps/06-type-conversions/article.md | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/1-js/02-first-steps/06-type-conversions/article.md b/1-js/02-first-steps/06-type-conversions/article.md index f2dfb08b5..f763cf9a1 100644 --- a/1-js/02-first-steps/06-type-conversions/article.md +++ b/1-js/02-first-steps/06-type-conversions/article.md @@ -7,7 +7,7 @@ Na przykład `alert` automatycznie zmieni typ dowolnej wartości do stringa. Mat Istnieją jednak przypadki, w których musimy jawnie zmienić typ wartości na inny. ```smart header="Nie mówimy jeszcze o obiektach" -W tym rozdziale nie zajmujemy się objektami. Zamiast tego nauczymy się najpierw typów prymitywnych. Później nauczymy się co nieco o obiektach i zobaczymy jak działa konwersja obiektów w rozdziale . +W tym rozdziale nie zajmujemy się obiektami. Zamiast tego nauczymy się najpierw typów prymitywnych. Później nauczymy się co nieco o obiektach i zobaczymy jak działa konwersja obiektów w rozdziale . ``` ## ToString (do stringa) @@ -157,4 +157,4 @@ Większość z tych zasad jest łatwa do zrozumienia i zapamiętania. Most of th - `undefined` to `NaN` jako number, a nie `0`. - `"0"` i spacja w stringu np. `" "` będzie true jako boolean. -Objekty nie są tutaj omówione. Wrócimy do nich później w rozdziale , który jest poświęcony obiektom, gdy poznamy już więcej podstaw JavaScript. \ No newline at end of file +Obiekty nie są tutaj omówione. Wrócimy do nich później w rozdziale , który jest poświęcony obiektom, gdy poznamy już więcej podstaw JavaScript. \ No newline at end of file From 2374b9e72991f334cd0a301b085733cdfd46f671 Mon Sep 17 00:00:00 2001 From: bartek7 Date: Tue, 23 Jul 2019 10:58:53 +0200 Subject: [PATCH 4/4] revert changes with another translation in another file --- .../06-type-conversions/article.md | 1 - 1-js/02-first-steps/08-comparison/article.md | 93 +++++++++---------- 2 files changed, 46 insertions(+), 48 deletions(-) diff --git a/1-js/02-first-steps/06-type-conversions/article.md b/1-js/02-first-steps/06-type-conversions/article.md index f763cf9a1..464285b40 100644 --- a/1-js/02-first-steps/06-type-conversions/article.md +++ b/1-js/02-first-steps/06-type-conversions/article.md @@ -8,7 +8,6 @@ Istnieją jednak przypadki, w których musimy jawnie zmienić typ wartości na i ```smart header="Nie mówimy jeszcze o obiektach" W tym rozdziale nie zajmujemy się obiektami. Zamiast tego nauczymy się najpierw typów prymitywnych. Później nauczymy się co nieco o obiektach i zobaczymy jak działa konwersja obiektów w rozdziale . -``` ## ToString (do stringa) diff --git a/1-js/02-first-steps/08-comparison/article.md b/1-js/02-first-steps/08-comparison/article.md index 5056dbba9..8697076a4 100644 --- a/1-js/02-first-steps/08-comparison/article.md +++ b/1-js/02-first-steps/08-comparison/article.md @@ -1,96 +1,95 @@ -# Porównania +# Comparisons -Na matematyce poznaliśmy porównania: +We know many comparison operators from maths: -- Większe/mniejsze niż: a > b, a < b. -- Większe/mniejsze niż lub równe: a >= b, a <= b. -- Równe: `a == b` (zauważ, że jest tutaj podwójny znak `=`. Pojedyncze użycie `a = b` oznacza przypisanie). -- Nierówne. W matematyce zapiszemy to jako ≠, ale w JavaScript jest to zapisane jako wykrzyknik przed znakiem równości: a != b. +- Greater/less than: a > b, a < b. +- Greater/less than or equals: a >= b, a <= b. +- Equals: `a == b` (please note the double equals sign `=`. A single symbol `a = b` would mean an assignment). +- Not equals. In maths the notation is ≠, but in JavaScript it's written as an assignment with an exclamation sign before it: a != b. -## Wynikiem jest Boolean +## Boolean is the result -Jak wszystkie inne operatory porównanie zwraca wartość. W tym przypadku wartością jest Boolean. +Like all other operators, a comparison returns a value. In this case, the value is a boolean. - `true` -- means "yes", "correct" or "the truth". - `false` -- means "no", "wrong" or "not the truth". -Na przykład: +For example: ```js run -alert( 2 > 1 ); // true (prawda) -alert( 2 == 1 ); // false (fałsz) -alert( 2 != 1 ); // true (prawda) +alert( 2 > 1 ); // true (correct) +alert( 2 == 1 ); // false (wrong) +alert( 2 != 1 ); // true (correct) ``` -Wynik porównania może być przypisany do zmiennej, jak każda inna wartość: +A comparison result can be assigned to a variable, just like any value: ```js run -let result = 5 > 4; // przypisz wynik porównania +let result = 5 > 4; // assign the result of the comparison alert( result ); // true ``` -## Porównanie stringów +## String comparison -Aby zobaczyć czy ciąg znaków jest większy niż inny JavaScript używa porównania, które nazywamy "słownikowym" lub "leksykograficznym". +To see whether a string is greater than another, JavaScript uses the so-called "dictionary" or "lexicographical" order. -Innymi słowy, stringi porównywane są litera po literze. +In other words, strings are compared letter-by-letter. -Na przykład: +For example: ```js run alert( 'Z' > 'A' ); // true -alert( 'Brat' > 'Brak' ); // true -alert( 'Jan' > 'Ja' ); // true +alert( 'Glow' > 'Glee' ); // true +alert( 'Bee' > 'Be' ); // true ``` -Algorytm porównuje dwa stringi w prosty sposób: +The algorithm to compare two strings is simple: -1. Porównaj pierwszy znak w obu stringach. -2. Jeśli pierwszy znak w pierwszym stringu jest większy (lub mniejszy) niż inny string, wtedy pierwszy string jest większy (lub mniejszy). Porównanie zakończone. -3. Jeśli pierwsze znaki są takie same zrób porównanie dla kolejnego znaku w ten sam sposób jak w punkcie nr 2. -4. Powtarzaj dopóki nie dojdzie do końca stringu. -5. Jeśli oba stringi mają taką samą długość są równe. W przeciwnym przypadku dłuższy string jest większy. +1. Compare the first character of both strings. +2. If the first character from the first string is greater (or less) than the other string's, then the first string is greater (or less) than the second. We're done. +3. Otherwise, if both strings' first characters are the same, compare the second characters the same way. +4. Repeat until the end of either string. +5. If both strings end at the same length, then they are equal. Otherwise, the longer string is greater. -W powyższych przypadkach porównanie `'Z' > 'A'` zwróci rezultat w pierwszym podejściu. Porównanie `"Brat"` z `"Brak"` będzie porównywane znak po znaku: +In the examples above, the comparison `'Z' > 'A'` gets to a result at the first step while the strings `"Glow"` and `"Glee"` are compared character-by-character: -1. `B` jest takie same jak `B`. -2. `r` jest takie same jak `r`. -3. `a` jest takie same jak `a`. -3. `t` jest większe niż `k`. Zatrzymaj tutaj. Pierwszy string jest większy. +1. `G` is the same as `G`. +2. `l` is the same as `l`. +3. `o` is greater than `e`. Stop here. The first string is greater. -```smart header="Nie do końca słownikowa, bo kolejność wg Unicode" -Podany powyżej przykład jest prawie taki sam jak algorytm używany w słownikach lub książkach telefonicznych. Ale nie jest dokładnie taki sam. +```smart header="Not a real dictionary, but Unicode order" +The comparison algorithm given above is roughly equivalent to the one used in dictionaries or phone books, but it's not exactly the same. -Na przykład wielkość ma znaczenie. Duża litera `"A"` nie jest równa małej literze `"a"`. Która jest większa? Mała litera `"a"`. Dlaczego? Ponieważ małe litery mają większy index w wewnętrznej tabeli kodowania znaków (Unicode), której używa JavaScript. Wrócimy do tego w rozdziale . +For instance, case matters. A capital letter `"A"` is not equal to the lowercase `"a"`. Which one is greater? The lowercase `"a"`. Why? Because the lowercase character has a greater index in the internal encoding table JavaScript uses (Unicode). We'll get back to specific details and consequences of this in the chapter . ``` -## Porównania wartości różnego typu +## Comparison of different types -Kiedy porównujemy wartości różnego typu JavaScript konwertuje te wartości na liczby. +When comparing values of different types, JavaScript converts the values to numbers. -Na przykład: +For example: ```js run -alert( '2' > 1 ); // true, string '2' staje się numerem 2 -alert( '01' == 1 ); // true, string '01' staje się numerem 1 +alert( '2' > 1 ); // true, string '2' becomes a number 2 +alert( '01' == 1 ); // true, string '01' becomes a number 1 ``` -Dla wartości Boolean `true` staje się `1`, a `false` staje się `0`. +For boolean values, `true` becomes `1` and `false` becomes `0`. -Na przykład: +For example: ```js run alert( true == 1 ); // true alert( false == 0 ); // true ``` -````smart header="Zabawna zależność" -Jest możliwe, aby w tym samym czasie: +````smart header="A funny consequence" +It is possible that at the same time: -- Dwie wartości były równe. -- Jedna z nich będzie `true` jako Boolean, natomiast druga jest `false` jako Boolean. +- Two values are equal. +- One of them is `true` as a boolean and the other one is `false` as a boolean. -Na przykład: +For example: ```js run let a = 0; @@ -102,7 +101,7 @@ alert( Boolean(b) ); // true alert(a == b); // true! ``` -Z punkty widzenia JavaScript taki rezultat jest oczekiwany i normalny. Porównanie konwertuje wartości na typ liczbowy (więc string `"0"` zostaje `0`), podczas gdy porównanie `Boolean` konwertuje te wartości w inny sposób. +From JavaScript's standpoint, this result is quite normal. An equality check converts values using the numeric conversion (hence `"0"` becomes `0`), while the explicit `Boolean` conversion uses another set of rules. ```` ## Strict equality