Skip to content

Commit a665b9e

Browse files
Add 10 translated questions | Total translated: 60
1 parent b6f9bfc commit a665b9e

File tree

1 file changed

+344
-0
lines changed

1 file changed

+344
-0
lines changed

pl-PL/README.md

Lines changed: 344 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1550,5 +1550,349 @@ Podczas mapowania tablicy, wartość `num` jest równa elementowi, nad którym a
15501550

15511551
Nie zwracamy jednak żadnej wartości. Gdy nie zwracamy wartości z funkcji, funkcja zwraca `undefined`. Dla każdego elementu w tablicy wywoływany jest blok funkcji, więc dla każdego elementu zwracamy `undefined`.
15521552

1553+
</p>
1554+
</details>
1555+
1556+
---
1557+
1558+
###### 51. Jaki jest wynik?
1559+
1560+
```javascript
1561+
function getInfo(member, year) {
1562+
member.name = 'Lydia';
1563+
year = '1998';
1564+
}
1565+
1566+
const person = { name: 'Sarah' };
1567+
const birthYear = '1997';
1568+
1569+
getInfo(person, birthYear);
1570+
1571+
console.log(person, birthYear);
1572+
```
1573+
1574+
- A: `{ name: "Lydia" }, "1997"`
1575+
- B: `{ name: "Sarah" }, "1998"`
1576+
- C: `{ name: "Lydia" }, "1998"`
1577+
- D: `{ name: "Sarah" }, "1997"`
1578+
1579+
<details><summary><b>Odpowiedź</b></summary>
1580+
<p>
1581+
1582+
#### Odpowiedź: A
1583+
1584+
Argumenty są przekazywane przez _wartość_, chyba że ich wartość jest obiektem, wtedy są przekazywane przez _referencję_. Argument `birthYear` jest przekazywany przez wartość, ponieważ jest ciągiem znaków, a nie obiektem. Kiedy przekazujemy argumenty przez wartość, tworzona jest _kopia_ tej wartości (patrz pytanie 46).
1585+
1586+
Zmienna `birthYear` posiada referencję do wartości `"1997"`. Argument `year` również posiada referencję do wartości `"1997"`, ale nie jest to ta sama wartość, do której odnosi się `birthYear`. Kiedy aktualizujemy wartość `year` ustawiając `year` na `"1998"`, aktualizujemy tylko wartość `year`. Wartość `birthYear` jest wciąż równa `1997`.
1587+
1588+
Wartość `person` jest obiektem. Argument `member` posiada (skopiowaną) referencję do _tego samego_ obiektu. Gdy zmodyfikujemy właściwość obiektu, do którego odwołuje się `member`, wartość `person` również zostanie zmodyfikowana, ponieważ oba mają odwołanie do tego samego obiektu. Właściwość `name` obiektu `person` jest teraz równa wartości `"Lydia"`.
1589+
1590+
</p>
1591+
</details>
1592+
1593+
---
1594+
1595+
###### 52. Jaki jest wynik?
1596+
1597+
```javascript
1598+
function greeting() {
1599+
throw 'Hello world!';
1600+
}
1601+
1602+
function sayHi() {
1603+
try {
1604+
const data = greeting();
1605+
console.log('It worked!', data);
1606+
} catch (e) {
1607+
console.log('Oh no an error:', e);
1608+
}
1609+
}
1610+
1611+
sayHi();
1612+
```
1613+
1614+
- A: `It worked! Hello world!`
1615+
- B: `Oh no an error: undefined`
1616+
- C: `SyntaxError: can only throw Error objects`
1617+
- D: `Oh no an error: Hello world!`
1618+
1619+
<details><summary><b>Odpowiedź</b></summary>
1620+
<p>
1621+
1622+
#### Odpowiedź: D
1623+
1624+
Za pomocą instrukcji `throw` możemy tworzyć niestandardowe błędy. Za pomocą tej instrukcji można rzucać wyjątki <b>string</b>, <b>number</b>, <b>boolean</b> lub <b>object</b>. W tym przypadku, naszym wyjątkiem jest ciąg znaków `'Hello world!".`
1625+
1626+
Za pomocą instrukcji `catch` możemy określić, co należy zrobić, jeśli wyjątek zostanie rzucony w bloku `try`. Wyjątkiem może być: string `'Hello world!'`. `e` jest teraz równe temu ciągowi, który wyświetlamy w konsoli. Skutkuje to `'Oh an error: Hello world!'`.
1627+
1628+
</p>
1629+
</details>
1630+
1631+
---
1632+
1633+
###### 53. Jaki jest wynik?
1634+
1635+
```javascript
1636+
function Car() {
1637+
this.make = 'Lamborghini';
1638+
return { make: 'Maserati' };
1639+
}
1640+
1641+
const myCar = new Car();
1642+
console.log(myCar.make);
1643+
```
1644+
1645+
- A: `"Lamborghini"`
1646+
- B: `"Maserati"`
1647+
- C: `ReferenceError`
1648+
- D: `TypeError`
1649+
1650+
<details><summary><b>Odpowiedź</b></summary>
1651+
<p>
1652+
1653+
#### Odpowiedź: B
1654+
1655+
Kiedy zwracasz właściwość, wartość właściwości jest równa _zwróconej_ wartości, a nie wartości ustawionej w funkcji konstruktora. Zwracamy ciąg `"Maserati"`, więc `myCar.make` jest równe `"Maserati"`.
1656+
1657+
</p>
1658+
</details>
1659+
1660+
---
1661+
1662+
###### 54. Jaki jest wynik?
1663+
1664+
```javascript
1665+
(() => {
1666+
let x = (y = 10);
1667+
})();
1668+
1669+
console.log(typeof x);
1670+
console.log(typeof y);
1671+
```
1672+
1673+
- A: `"undefined", "number"`
1674+
- B: `"number", "number"`
1675+
- C: `"object", "number"`
1676+
- D: `"number", "undefined"`
1677+
1678+
<details><summary><b>Odpowiedź</b></summary>
1679+
<p>
1680+
1681+
#### Odpowiedź: A
1682+
1683+
`let x = (y = 10);` jest w rzeczywistości skrótem od:
1684+
1685+
```javascript
1686+
y = 10;
1687+
let x = y;
1688+
```
1689+
1690+
Kiedy ustawiamy `y` równe `10`, w rzeczywistości dodajemy właściwość `y` do globalnego obiektu (`window` w przeglądarce, `global` w Node). W przeglądarce, `window.y` jest teraz równe `10`.
1691+
1692+
Następnie deklarujemy zmienną `x` z wartością `y`, która wynosi `10`. Zmienne zadeklarowane za pomocą słowa kluczowego `let`_block scoped_ i są definiowane tylko w bloku, w którym zostały zadeklarowane; w tym przypadku natychmiast wywołane wyrażenie funkcji (IIFE). Kiedy używamy operatora `typeof`, operand `x` nie jest zdefiniowany: próbujemy uzyskać dostęp do `x` poza blokiem, w którym został zadeklarowany. Oznacza to, że `x` nie jest zdefiniowane. Wartości, które nie zostały przypisane lub zadeklarowane są typu "undefined". `console.log(typeof x)` zwraca `"undefined"`.
1693+
1694+
Jednakże, utworzyliśmy globalną zmienną `y` podczas ustawiania `y` równego `10`. Wartość ta jest dostępna w dowolnym miejscu naszego kodu. Zmienna `y` jest zdefiniowana i przechowuje wartość typu `"number"`. `console.log(typeof y)` zwraca `"number"`.
1695+
1696+
</p>
1697+
</details>
1698+
1699+
---
1700+
1701+
###### 55. Jaki jest wynik?
1702+
1703+
```javascript
1704+
class Dog {
1705+
constructor(name) {
1706+
this.name = name;
1707+
}
1708+
}
1709+
1710+
Dog.prototype.bark = function() {
1711+
console.log(`Woof I am ${this.name}`);
1712+
};
1713+
1714+
const pet = new Dog('Mara');
1715+
1716+
pet.bark();
1717+
1718+
delete Dog.prototype.bark;
1719+
1720+
pet.bark();
1721+
```
1722+
1723+
- A: `"Woof I am Mara"`, `TypeError`
1724+
- B: `"Woof I am Mara"`, `"Woof I am Mara"`
1725+
- C: `"Woof I am Mara"`, `undefined`
1726+
- D: `TypeError`, `TypeError`
1727+
1728+
<details><summary><b>Odpowiedź</b></summary>
1729+
<p>
1730+
1731+
#### Odpowiedź: A
1732+
1733+
Możemy usuwać właściwości z obiektów za pomocą słowa kluczowego `delete`, również na prototypie. Usuwając właściwość z prototypu, nie jest ona już dostępna w łańcuchu prototypów. W tym przypadku funkcja `bark` nie jest już dostępna w prototypie po `delete Dog.prototype.bark`, a mimo to wciąż próbujemy uzyskać do niej dostęp.
1734+
1735+
Kiedy próbujemy wywołać coś, co nie jest funkcją, rzucany jest `TypeError`. W tym przypadku `TypeError: pet.bark is not a function`, ponieważ `pet.bark` jest `undefined`.
1736+
1737+
</p>
1738+
</details>
1739+
1740+
---
1741+
1742+
###### 56. Jaki jest wynik?
1743+
1744+
```javascript
1745+
const set = new Set([1, 1, 2, 3, 4]);
1746+
1747+
console.log(set);
1748+
```
1749+
1750+
- A: `[1, 1, 2, 3, 4]`
1751+
- B: `[1, 2, 3, 4]`
1752+
- C: `{1, 1, 2, 3, 4}`
1753+
- D: `{1, 2, 3, 4}`
1754+
1755+
<details><summary><b>Odpowiedź</b></summary>
1756+
<p>
1757+
1758+
#### Odpowiedź: D
1759+
1760+
Obiekt `Set` jest zbiorem _unikalnych_ wartości: wartość może wystąpić tylko raz w zbiorze.
1761+
1762+
Przekazaliśmy iterowalne `[1, 1, 2, 3, 4]` ze zduplikowaną wartością `1`.Ponieważ nie możemy mieć dwóch takich samych wartości w zbiorze, jedna z nich jest usuwana. Wynikiem jest `{1, 2, 3, 4}`.
1763+
1764+
</p>
1765+
</details>
1766+
1767+
---
1768+
1769+
###### 57. Jaki jest wynik?
1770+
1771+
```javascript
1772+
// counter.js
1773+
let counter = 10;
1774+
export default counter;
1775+
```
1776+
1777+
```javascript
1778+
// index.js
1779+
import myCounter from './counter';
1780+
1781+
myCounter += 1;
1782+
1783+
console.log(myCounter);
1784+
```
1785+
1786+
- A: `10`
1787+
- B: `11`
1788+
- C: `Error`
1789+
- D: `NaN`
1790+
1791+
<details><summary><b>Odpowiedź</b></summary>
1792+
<p>
1793+
1794+
#### Odpowiedź: C
1795+
1796+
Zaimportowany moduł jest _tylko do odczytu_: nie można modyfikować zaimportowanego modułu. Tylko moduł, który go eksportuje może zmienić jego wartość.
1797+
1798+
Kiedy próbujemy zwiększyć wartość `myCounter`, wyrzuca błąd: `myCounter` jest tylko do odczytu i nie może być modyfikowany.
1799+
1800+
</p>
1801+
</details>
1802+
1803+
---
1804+
1805+
###### 58. Jaki jest wynik?
1806+
1807+
```javascript
1808+
const name = 'Lydia';
1809+
age = 21;
1810+
1811+
console.log(delete name);
1812+
console.log(delete age);
1813+
```
1814+
1815+
- A: `false`, `true`
1816+
- B: `"Lydia"`, `21`
1817+
- C: `true`, `true`
1818+
- D: `undefined`, `undefined`
1819+
1820+
<details><summary><b>Odpowiedź</b></summary>
1821+
<p>
1822+
1823+
#### Odpowiedź: A
1824+
1825+
Operator `delete` zwraca wartość logiczną: `true` po pomyślnym usunięciu, w przeciwnym razie zwróci `false`. Jednakże, zmienne zadeklarowane ze słowem kluczowym `var`, `const` lub `let` nie mogą być usunięte za pomocą operatora `delete`.
1826+
1827+
Zmienna `name` została zadeklarowana ze słowem kluczowym `const`, więc jej usunięcie nie powiedzie się: Zwracane jest `false`. Kiedy ustawiliśmy wartość `age` równą `21`, w rzeczywistości dodaliśmy właściwość o nazwie `age` do obiektu globalnego. W ten sposób można pomyślnie usunąć właściwości z obiektów, również z obiektu globalnego, więc `delete age` zwraca `true`.
1828+
1829+
</p>
1830+
</details>
1831+
1832+
---
1833+
1834+
###### 59. Jaki jest wynik?
1835+
1836+
```javascript
1837+
const numbers = [1, 2, 3, 4, 5];
1838+
const [y] = numbers;
1839+
1840+
console.log(y);
1841+
```
1842+
1843+
- A: `[[1, 2, 3, 4, 5]]`
1844+
- B: `[1, 2, 3, 4, 5]`
1845+
- C: `1`
1846+
- D: `[1]`
1847+
1848+
<details><summary><b>Odpowiedź</b></summary>
1849+
<p>
1850+
1851+
#### Odpowiedź: C
1852+
1853+
Możemy rozpakować wartości z tablic lub właściwości z obiektów poprzez destrukturyzację. Na przykład:
1854+
1855+
```javascript
1856+
[a, b] = [1, 2];
1857+
```
1858+
1859+
<img src="https://i.imgur.com/ADFpVop.png" width="200">
1860+
1861+
Wartość `a` wynosi teraz `1`, a wartość `b` wynosi teraz `2`.To, co faktycznie zrobiliśmy w pytaniu, to:
1862+
1863+
```javascript
1864+
[y] = [1, 2, 3, 4, 5];
1865+
```
1866+
1867+
<img src="https://i.imgur.com/NzGkMNk.png" width="200">
1868+
1869+
Oznacza to, że wartość `y` jest równa pierwszej wartości w tablicy, którą jest liczba `1`.Kiedy logujemy `y`, zwracana jest wartość `1`.
1870+
1871+
</p>
1872+
</details>
1873+
1874+
---
1875+
1876+
###### 60. Jaki jest wynik?
1877+
1878+
```javascript
1879+
const user = { name: 'Lydia', age: 21 };
1880+
const admin = { admin: true, ...user };
1881+
1882+
console.log(admin);
1883+
```
1884+
1885+
- A: `{ admin: true, user: { name: "Lydia", age: 21 } }`
1886+
- B: `{ admin: true, name: "Lydia", age: 21 }`
1887+
- C: `{ admin: true, user: ["Lydia", 21] }`
1888+
- D: `{ admin: true }`
1889+
1890+
<details><summary><b>Odpowiedź</b></summary>
1891+
<p>
1892+
1893+
#### Odpowiedź: B
1894+
1895+
Możliwe jest łączenie obiektów za pomocą operatora rozprzestrzeniania `...`.Umożliwia on tworzenie kopii par klucz/wartość jednego obiektu i dodawanie ich do innego obiektu. W tym przypadku tworzymy kopie obiektu `user` i dodajemy je do obiektu `admin`. Obiekt `admin` zawiera teraz skopiowane pary klucz/wartość, czego wynikiem jest `{ admin: true, name: "Lydia", age: 21 }`.
1896+
15531897
</p>
15541898
</details>

0 commit comments

Comments
 (0)