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 4964a623a..cc3445b63 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 @@ -17,10 +17,10 @@ undefined + 1 = NaN // (6) " \t \n" - 2 = -2 // (7) ``` -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. -7. Space characters, are trimmed off string start and end when a string is converted to a number. Here the whole string consists of space characters, such as `\t`, `\n` and a "regular" space between them. So, similarly to an empty string, it becomes `0`. +1. Dodawanie ciągu znaków `"" + 1` rzutuje `1` do typu tekstowego: `"" + 1 = "1"`, a później analogicznie `"1" + 0`. +2. Odejmowanie `-` (jak większość operacji matematycznych) działa wyłącznie z typami liczbowymi i konwertuje pusty napis `""` do `0`. +3. Dodawanie ciągu znaków dołącza (konkatenuje) liczbę `5` do zmiennej. +4. Odejmowanie zawsze rzutuje wartości do liczby, zatem konwertuje `" -9 "` na liczbę `-9` (ignoruje spacje dookoła). +5. `null` rzutowany na liczbę stanie się `0`. +6. `undefined` rzutowany na liczbę stanie się `NaN`. +7. Podczas rzutowania typu tekstowego na liczbowy ignorowane są białe znaki po obydwóch stronach tekstu. W tym przypadku cały tekst składa się z białych znaków: `\t`, `\n` i "zwykłych" spacji pomiędzy nimi. W rezultacie powstały pusty ciąg znaków po rzutowaniu na liczbę da wartość `0`. 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 930c71514..f0d686f7e 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 @@ -2,9 +2,9 @@ importance: 5 --- -# Type conversions +# Rzutowanie typów -What are results of these expressions? +Jakie będą wyniki poniższych wyrażeń? ```js no-beautify "" + 1 + 0 @@ -24,4 +24,4 @@ undefined + 1 " \t \n" - 2 ``` -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 20d093ea4..78d9f85f8 100644 --- a/1-js/02-first-steps/06-type-conversions/article.md +++ b/1-js/02-first-steps/06-type-conversions/article.md @@ -1,159 +1,158 @@ -# Type Conversions +# Rzutowanie 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 rzutują 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 typu tekstowego. Matematyczne operacje rzutują wartości do typów liczbowych. -There are also cases when we need to explicitly convert a value to the expected type. +Istnieją jednak przypadki, w których musimy jawnie 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ę obiektami. Zamiast tego nauczymy się najpierw typów prostych. Później nauczymy się co nieco o obiektach i w rozdziale pt. "" zobaczymy, jak działa rzutowanie obiektów. -## String Conversion +## Rzutowanie do typu tekstowego -String conversion happens when we need the string form of a value. +Rzutowanie do typu tekstowego następuje, kiedy potrzebujemy wartości zmiennej w formie tekstowej. -For example, `alert(value)` does it to show the value. +Na przykład, funkcja `alert(value)` rzutuje wyświetlaną wartość do typu tekstowego. -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 jawnie rzutować wartość na tekst: ```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 ciągiem znaków alert(typeof value); // string */!* ``` -String conversion is mostly obvious. A `false` becomes `"false"`, `null` becomes `"null"`, etc. +Rzutowanie wartości do tekstu jest bardzo przewidywalne. `false` zostaje `"false"`, typ `null` staje się napisem `"null"` itd. -## Numeric Conversion +## Rzutowanie do typu liczbowego -Numeric conversion happens in mathematical functions and expressions automatically. +Rzutowanie 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 przy dzieleniu (`/`) z udziałem wartości nie będących liczbami: ```js run -alert( "6" / "2" ); // 3, strings are converted to numbers +alert( "6" / "2" ); // 3, wartości tekstowe są zamienane 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 rzutować zmienną `value` na liczbę. ```js run let str = "123"; alert(typeof str); // string -let num = Number(str); // becomes a number 123 +let num = Number(str); // staje się 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. +Jawne rzutowanie jest zazwyczaj wymagane, gdy chcemy odczytać wartość ze źródła tekstowego, a w kodzie oczekujemy wartości liczbowej. -If the string is not a valid number, the result of such a conversion is `NaN`. For instance: +Jeśli podana wartość tekstowa 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, rzutowanie nie powiodło się ``` -Numeric conversion rules: +Zasady rzutowania do 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`. | +|true i false | `1` i `0` | +| `string` | Białe znaki z początku i końca są usuwane. Jeśli pozostała wartość napisu jest pusta, wynikiem będzie `0`. W przeciwnym wypadku liczba jest odczytywana z tekstu. Wszystkie nieprawidłowe rzutowania 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 rzutowania "z" na liczbę) 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` jest konwertowany do zera, a `undefined` do `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="Operator '+' łączy ciągi znaków" +Większość operacji matematycznych rzutuje wartości do typu liczbowego. Jedynym wyjątkiem jest `+`. Jeśli jedna z dodawanych wartości będzie typu tekstowego, druga również jest rzutowana do typu tekstowego. -Then, it concatenates (joins) them: +Wtedy następuje ich konkatenacja (połączenie): ```js run -alert( 1 + '2' ); // '12' (string to the right) -alert( '1' + 2 ); // '12' (string to the left) +alert( 1 + '2' ); // '12' (tekst po prawej) +alert( '1' + 2 ); // '12' (tekst po lewej) ``` -This only happens when at least one of the arguments is a string. Otherwise, values are converted to numbers. +Dzieje się tak w sytuacji, gdy przynajmniej jeden z argumentów jest typu tekstowego. W przeciwnym wypadku wartości są rzutowane na typ liczbowy. ```` -## Boolean Conversion +## Rzutowanie do typu logicznego -Boolean conversion is the simplest one. +Rzutowania do typu logicznego 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 operacjach logicznych (później poznamy instrukcje warunkowe i inne podobne rzeczy), ale także mogą zostać wywołane z użyciem funkcji `Boolean(value)`. -The conversion rule: +Zasada rzutowania: -- Values that are intuitively "empty", like `0`, an empty string, `null`, `undefined`, and `NaN`, become `false`. -- Other values become `true`. +- Wartości "puste", np. `0`, pusty ciąg znaków, `null`, `undefined` i `NaN`, są konwertowane do `false`. +- Inne wartości są konwertowane do `true`. -For instance: +Na przykład: ```js run alert( Boolean(1) ); // true alert( Boolean(0) ); // false -alert( Boolean("hello") ); // true +alert( Boolean("witaj") ); // 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 tekst zawierający cyfrę 0 (`\"0\"`) da `true`" +Niektóre języki (np. PHP) traktują `"0"` jako `false`. Ale w JavaScripcie każdy niepusty ciąg znaków daje 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 (każdy niepusty ciąg znaków daje true) ``` ```` -## Summary +## Podsumowanie -The three most widely used type conversions are to string, to number, and to boolean. +Trzy najczęściej używane rzutowania dotyczą ciągów znaków, liczb i typów logicznych. -**`String Conversion`** -- Occurs when we output something. Can be performed with `String(value)`. The conversion to string is usually obvious for primitive values. +**`Rzutowanie do typu tekstowego`** -- Zachodzi, gdy coś wypisujemy na ekranie. Może zajść również przy użyciu funkcji `String(value)`. Wynik rzutowania do tekstu jest zazwyczaj oczywisty dla typów prostych. -**`Numeric Conversion`** -- Occurs in math operations. Can be performed with `Number(value)`. +**`Rzutowanie do typu liczbowego`** -- Zachodzi w operacjach matematycznych. Może zajść również przy użyciu funkcji `Number(value)`. -The conversion follows the rules: +Rzutowanie to jest zgodne 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` | Tekst jest odczytywany "jak leci", białe znaki na obydwóch końcach są ignorowane. Pusty ciąg znaków staje się `0`. Błąd konwersji zwraca `NaN`.| -**`Boolean Conversion`** -- Occurs in logical operations. Can be performed with `Boolean(value)`. +**`Rzutowanie do typu logicznego`** -- Zachodzi w operacjach logicznych. Może zajść również przy użyciu funkcji `Boolean(value)`. -Follows the rules: +Rzutowanie jest zgodne 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. Warte uwagi, najczęściej popełnianie błędy to: -- `undefined` is `NaN` as a number, not `0`. -- `"0"` and space-only strings like `" "` are true as a boolean. +- `undefined` rzutowane na typ liczbowy daje `NaN`, a nie `0`. +- `"0"` i spacja w ciągu znaków np. `" "` rzutowane na typ logiczny dadzą `true`. -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. +Nie omówiliśmy tu obiektów. Wrócimy do nich później w rozdziale pt. "", gdy już poznamy więcej podstaw JavaScriptu. \ No newline at end of file diff --git a/1-js/02-first-steps/08-comparison/article.md b/1-js/02-first-steps/08-comparison/article.md index d889b1328..244204797 100644 --- a/1-js/02-first-steps/08-comparison/article.md +++ b/1-js/02-first-steps/08-comparison/article.md @@ -74,7 +74,7 @@ alert( '2' > 1 ); // true, string '2' becomes a number 2 alert( '01' == 1 ); // true, string '01' becomes a number 1 ``` -For boolean values, `true` becomes `1` and `false` becomes `0`. +For boolean values, `true` becomes `1` and `false` becomes `0`. For example: