merging all conflicts

Author: iliakan

1-js/01-getting-started/4-devtools/article.md

@@ -29,10 +29,19 @@ Dokładny widok narzędzi deweloperskich zależy od wersji Chrome'a. Narzędzia
 - Widzimy treść błędu zapisaną kolorem czerwonym. W tym przypadku skrypt zawiera nieznaną komendę "lalala".
 - Po prawej stronie jest klikalny link do źródła `bug.html:12`, z numerem linii kodu, w której błąd wystąpił.
 
+<<<<<<< HEAD
 Poniżej treści błędu znajduje się niebieski symbol `>`. Oznacza linię, w której możemy pisać kod JavaScript. Naciśnij `key:Enter`, aby ten kod uruchomić (`key:Shift+Enter` dodaje nowy wiersz).
+=======
+Below the error message, there is a blue `>` symbol. It marks a "command line" where we can type JavaScript commands. Press `key:Enter` to run them.
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 Widzisz już komunikaty błędów i na początek powinno to wystarczyć. W rozdziale pt. "<info:debugging-chrome>" wrócimy do narzędzi deweloperskich, by poznać więcej tajników debuggowania.
 
+```smart header="Multi-line input"
+Usually, when we put a line of code into the console, and then press `key:Enter`, it executes.
+
+To insert multiple lines, press `key:Shift+Enter`. This way one can enter long fragments of JavaScript code.
+```
 
 ## Firefox, Edge i inne
 
@@ -50,11 +59,15 @@ Otwórz Preferencje i przejdź do zakładki "Zaawansowane". Zaznacz na samym dol
 
 Teraz, gdy naciśniesz `key:Cmd+Opt+C`, otworzysz konsolę. Warto dodać, że w górnym pasku menu pojawiła się nowa pozycja o nazwie "Programowanie". Ma w sobie wiele funkcji i opcji konfiguracyjnych.
 
+<<<<<<< HEAD
 ## Wpisywanie w wielu wierszach
 
 Zazwyczaj gdy wprowadzamy kod JavaScript w konsoli i naciśniemy klawisz `key:Enter`, wykona się on od razu.
 
 Aby wstawić kod, który ma kilka linii, wystarczy wcisnąć na końcu linii klawisz `key:Shift+Enter`, aby przejść do następnej.
+=======
+## Summary
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 ## Podsumowanie
 

1-js/02-first-steps/03-strict-mode/article.md

@@ -42,7 +42,11 @@ Tylko komentarze mogą znajdować się powyżej deklaracji `"use strict"`.
 ```warn header="Nie ma możliwości anulowania `use strict`"
 Nie ma takiej dyrektywy jak `"no use strict"`, która przywraca wcześniejsze działanie silnika JavaScript.
 
+<<<<<<< HEAD
 Jeśli włączysz tryb ścisły, nie ma już odwrotu.
+=======
+Once we enter strict mode, there's no going back.
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 ```
 
 ## Konsola przeglądarki

1-js/02-first-steps/05-types/article.md

@@ -10,9 +10,15 @@ message = 123456;
 
 Część języków programowania stosuje tak zwane "dynamiczne typowanie", które oznacza, że typy danych zmiennych mogą zmienić się w trakcie działania programu.
 
+<<<<<<< HEAD
 Wyróżniamy 7 podstawowych typów danych w JavaScripcie. Przedstawimy je teraz ogólnie, w następnych rozdziałach omówimy bardziej szczegółowo.
 
 ## Typ liczbowy
+=======
+There are eight basic data types in JavaScript. Here, we'll cover them in general and in the next chapters we'll talk about each of them in detail.
+
+## Number
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 ```js
 let n = 123;
@@ -62,14 +68,43 @@ Specjalne wartości liczbowe formalnie należą do typu "liczbowego". Oczywiści
 
 Więcej informacji o pracy z liczbami zawarte jest w rozdziale pt. "<info:number>".
 
+<<<<<<< HEAD
 ## Typ tekstowy
+=======
+## BigInt
+
+In JavaScript, the "number" type cannot represent integer values larger than <code>2<sup>53</sup></code> (or less than <code>-2<sup>53</sup></code> for negatives), that's a technical limitation caused by their internal representation. That's about 16 decimal digits, so for most purposes the limitation isn't a problem, but sometimes we need really big numbers, e.g. for cryptography or microsecond-precision timestamps.
+
+`BigInt` type was recently added to the language to represent integers of arbitrary length.
+
+A `BigInt` is created by appending `n` to the end of an integer literal:
+
+```js
+// the "n" at the end means it's a BigInt
+const bigInt = 1234567890123456789012345678901234567890n;
+```
+
+As `BigInt` numbers are rarely needed, we devoted them a separate chapter <info:bigint>.
+
+```smart header="Compatability issues"
+Right now `BigInt` is supported in Firefox and Chrome, but not in Safari/IE/Edge.
+```
+
+## String
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 Ciąg znaków (ang. *string*), zwany także "literałem znakowym" lub "napisem", to typ tekstowy, który zapisujemy przy użyciu cudzysłowów.
 
 ```js
+<<<<<<< HEAD
 let str = "Witaj";
 let str2 = 'Można użyć także apostrofów';
 let phrase = `Można dołączyć zmienną ${str}`;
+=======
+let str = "Hello";
+let str2 = 'Single quotes are ok too';
+let phrase = `can embed another ${str}`;
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 ```
 
 W JavaScripcie istnieją 3 typy cudzysłowów.
@@ -78,7 +113,11 @@ W JavaScripcie istnieją 3 typy cudzysłowów.
 2. Apostrofy: `'Witaj'`.
 3. Grawisy (ang. *backtick*): <code>&#96;Witaj&#96;</code>.
 
+<<<<<<< HEAD
 W JavaScripcie nie ma różnicy między cudzysłowami a apostrofami.
+=======
+Double and single quotes are "simple" quotes. There's practically no difference between them in JavaScript.
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 Grawisy są "rozszerzeniem funkcjonalności" zwykłych apostrofów i cudzysłowów. Pozwalają na dodanie zmiennej i wyrażeń do ciągu znaków poprzez umieszczenie ich wewnątrz `${…}`, przykładowo:
 
@@ -101,13 +140,22 @@ alert( "Wynik to ${1 + 2}" ); // Wynik to ${1 + 2} (cudzysłów traktuje ${…}
 
 Więcej o ciągach znaków można przeczytać w rozdziale pt. "<info:string>".
 
+<<<<<<< HEAD
 ```smart header="JavaScript nie posiada typu *znakowego*."
 W niektórych językach istnieje specjalny typ "znakowy", używany do przechowywania pojedynczych znaków. Przykładowo, w językach C i Java możemy użyć typu `char`.
+=======
+```smart header="There is no *character* type."
+In some languages, there is a special "character" type for a single character. For example, in the C language and in Java it is called "char".
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 W JavaScripcie nie ma takiego typu. Mamy do dyspozycji jedynie `string`. Ciąg znaków może być pusty albo zawierać jeden i więcej znaków.
 ```
 
+<<<<<<< HEAD
 ## Typ logiczny
+=======
+## Boolean (logical type)
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 Typ logiczny (ang. *boolean*) posiada dwie wartości: `true` (prawda) lub `false` (fałsz).
 
@@ -198,6 +246,8 @@ typeof undefined // "undefined"
 
 typeof 0 // "number"
 
+typeof 10n // "bigint"
+
 typeof true // "boolean"
 
 typeof "coś" // "string"
@@ -223,6 +273,7 @@ Ostatnie trzy linijki wymagają dodatkowego wyjaśnienia.
 2. Wynikiem wywołania `typeof null` jest `object`. Jest to znany błąd związany z `typeof`, nie został on jednak poprawiony ze względu na wsteczną kompatybilność. Oczywiście `null` nie jest obiektem - posiada własny typ.
 3. Wynikiem wywołania `typeof alert` jest `"function"` ze względu na to, że `alert` jest po prostu funkcją. O funkcjach napisaliśmy więcej w następnych rozdziałach, gdzie zauważamy, że tak naprawdę nie ma typu "function" w JavaScripcie. Funkcje należą do typu "object". Jednak `typeof` traktuje funkcje inaczej, zwracając `"function"`, co nie jest do końca poprawne, lecz bardzo wygodne w praktyce.
 
+<<<<<<< HEAD
 
 ## Podsumowanie
 
@@ -235,6 +286,20 @@ W JavaScripcie wyróżniamy 7 podstawowych typów danych.
 - `undefined` dla niezdefiniowanych wartości -- autonomiczny typ, który posiada jedną wartość: `undefined`.
 - `object` dla bardziej złożonych struktur danych.
 - `symbol` dla unikalnych identyfikatorów.
+=======
+## Summary
+
+There are 8 basic data types in JavaScript.
+
+- `number` for numbers of any kind: integer or floating-point, integers are limited by ±2<sup>53</sup>.
+- `bigint` is for integer numbers of arbitrary length.
+- `string` for strings. A string may have one or more characters, there's no separate single-character type.
+- `boolean` for `true`/`false`.
+- `null` for unknown values -- a standalone type that has a single value `null`.
+- `undefined` for unassigned values -- a standalone type that has a single value `undefined`.
+- `object` for more complex data structures.
+- `symbol` for unique identifiers.
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 Operator `typeof` pozwala na sprawdzenie typu zmiennej.
 

1-js/02-first-steps/06-type-conversions/article.md

@@ -1,6 +1,10 @@
 # Rzutowanie typów
 
+<<<<<<< HEAD
 W większości przypadków operatory i funkcje automatycznie rzutują przekazywane do nich wartości na właściwy typ.
+=======
+Most of the time, operators and functions automatically convert the values given to them to the right type.
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 Na przykład `alert` automatycznie zmieni typ dowolnej wartości do typu tekstowego. Matematyczne operacje rzutują wartości do typów liczbowych.
 
@@ -80,6 +84,7 @@ alert( Number(false) );       // 0
 
 Zauważ, że `null` i `undefined` zachowują się inaczej. `null` jest konwertowany do zera, a `undefined` do `NaN`.
 
+<<<<<<< HEAD
 ````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.
 
@@ -92,6 +97,9 @@ alert( '1' + 2 ); // '12' (tekst po lewej)
 
 Dzieje się tak w sytuacji, gdy przynajmniej jeden z argumentów jest typu tekstowego. W przeciwnym wypadku wartości są rzutowane na typ liczbowy.
 ````
+=======
+Most mathematical operators also perform such conversion, we'll see that in the next chapter.
+>>>>>>> 5b195795da511709faf79a4d35f9c5623b6dbdbd
 
 ## Rzutowanie do typu logicznego
 

…mitive-conversions-questions/solution.md …mitive-conversions-questions/solution.md1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md renamed to 1-js/02-first-steps/07-operators/3-primitive-conversions-questions/solution.md 1-js/02-first-steps/06-type-conversions/1-primitive-conversions-questions/solution.md renamed to 1-js/02-first-steps/07-operators/3-primitive-conversions-questions/solution.md

@@ -13,7 +13,7 @@ null === +"\n0\n" → false
 Some of the reasons:
 
 1. Obviously, true.
-2. Dictionary comparison, hence false.
+2. Dictionary comparison, hence false. `"a"` is smaller than `"p"`.
 3. Again, dictionary comparison, first char of `"2"` is greater than the first char of `"1"`.
 4. Values `null` and `undefined` equal each other only.
 5. Strict equality is strict. Different types from both sides lead to false.