You signed in with another tab or window. Reload to refresh your session.You signed out in another tab or window. Reload to refresh your session.You switched accounts on another tab or window. Reload to refresh your session.Dismiss alert
Copy file name to clipboardExpand all lines: pl-PL/README.md
+344Lines changed: 344 additions & 0 deletions
Display the source diff
Display the rich diff
Original file line number
Diff line number
Diff line change
@@ -1550,5 +1550,349 @@ Podczas mapowania tablicy, wartość `num` jest równa elementowi, nad którym a
1550
1550
1551
1551
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`.
1552
1552
1553
+
</p>
1554
+
</details>
1555
+
1556
+
---
1557
+
1558
+
###### 51. Jaki jest wynik?
1559
+
1560
+
```javascript
1561
+
functiongetInfo(member, year) {
1562
+
member.name='Lydia';
1563
+
year ='1998';
1564
+
}
1565
+
1566
+
constperson= { name:'Sarah' };
1567
+
constbirthYear='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
+
functiongreeting() {
1599
+
throw'Hello world!';
1600
+
}
1601
+
1602
+
functionsayHi() {
1603
+
try {
1604
+
constdata=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
+
functionCar() {
1637
+
this.make='Lamborghini';
1638
+
return { make:'Maserati' };
1639
+
}
1640
+
1641
+
constmyCar=newCar();
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` są _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
+
classDog {
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
+
constpet=newDog('Mara');
1715
+
1716
+
pet.bark();
1717
+
1718
+
deleteDog.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
+
constset=newSet([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
+
exportdefaultcounter;
1775
+
```
1776
+
1777
+
```javascript
1778
+
// index.js
1779
+
importmyCounterfrom'./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
+
constname='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
+
constnumbers= [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:
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 }`.
0 commit comments