Skip to content

Commit f71c416

Browse files
alexb017alexb017
committed
Added the questions from 31-40
1 parent fb56bd0 commit f71c416

File tree

1 file changed

+299
-0
lines changed

1 file changed

+299
-0
lines changed

‎ro-RO/README.ro.md

Lines changed: 299 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -960,4 +960,303 @@ Aici începe să lucreze un event loop. Un **event loop** se uită la stivă și
960960
</p>
961961
</details>
962962

963+
---
964+
965+
###### 31. Ce reprezintă "event.target" atunci când se face clic pe buton?
966+
967+
```html
968+
<div onclick="console.log('first div')">
969+
<div onclick="console.log('second div')">
970+
<button onclick="console.log('button')">
971+
Click!
972+
</button>
973+
</div>
974+
</div>
975+
```
976+
977+
- A: În afara `div`
978+
- B: În interior `div`
979+
- C: `button`
980+
- D: Un șir de toate elementele înglobate.
981+
982+
<details><summary><b>Răspuns</b></summary>
983+
<p>
984+
985+
#### Răspuns: C
986+
987+
Cel mai profund element înglobat care a cauzat evenimentul este ținta evenimentului. Puteți opri propagarea acestuia prin `event.stopPropagation`
988+
989+
</p>
990+
</details>
991+
992+
---
993+
994+
###### 32. Când faceți clic pe paragraf, care este ieșirea înregistrată?
995+
996+
```html
997+
<div onclick="console.log('div')">
998+
<p onclick="console.log('p')">
999+
Click here!
1000+
</p>
1001+
</div>
1002+
```
1003+
1004+
- A: `p` `div`
1005+
- B: `div` `p`
1006+
- C: `p`
1007+
- D: `div`
1008+
1009+
<details><summary><b>Răspuns</b></summary>
1010+
<p>
1011+
1012+
#### Răspuns: A
1013+
1014+
Dacă facem clic pe `p`, vom vedea două înregistrări: `p` și `div`. În timpul propagării evenimentului, există 3 faze: capturare, țintă și propagare. În mod implicit, gestionarii de evenimente sunt executați în faza de propagare (cu excepția cazului în care setați `useCapture` la `true`). Aceștia se execută de la cel mai profund element înglobat către exterior.
1015+
1016+
</p>
1017+
</details>
1018+
1019+
---
1020+
1021+
###### 33. Care este rezultatul?
1022+
1023+
```javascript
1024+
const person = { name: 'Lydia' };
1025+
1026+
function sayHi(age) {
1027+
return `${this.name} is ${age}`;
1028+
}
1029+
1030+
console.log(sayHi.call(person, 21));
1031+
console.log(sayHi.bind(person, 21));
1032+
```
1033+
1034+
- A: `undefined is 21` `Lydia is 21`
1035+
- B: `function` `function`
1036+
- C: `Lydia is 21` `Lydia is 21`
1037+
- D: `Lydia is 21` `function`
1038+
1039+
<details><summary><b>Răspuns</b></summary>
1040+
<p>
1041+
1042+
#### Răspuns: D
1043+
1044+
Cu ambele metode, putem transmite obiectul la care dorim să se refere cuvântul cheie `this`. Cu toate acestea, `.call` este de asemenea _executat imediat_!
1045+
1046+
`.bind.` returnează o _copie_ a funcției, dar cu un context legat! Nu este executat imediat.
1047+
1048+
</p>
1049+
</details>
1050+
1051+
---
1052+
1053+
###### 34. Care este rezultatul?
1054+
1055+
```javascript
1056+
function sayHi() {
1057+
return (() => 0)();
1058+
}
1059+
1060+
console.log(typeof sayHi());
1061+
```
1062+
1063+
- A: `"object"`
1064+
- B: `"number"`
1065+
- C: `"function"`
1066+
- D: `"undefined"`
1067+
1068+
<details><summary><b>Răspuns</b></summary>
1069+
<p>
1070+
1071+
#### Răspuns: B
1072+
1073+
Funcția `sayHi` returnează valoarea returnată de expresia funcției invocate imediat (IIFE). This function returned `0`, care este de tip `"number"`.
1074+
1075+
Informație utilă: `typeof` poate returna următoarele valori: `undefined`, `boolean`, `number`, `bigint`, `string`, `symbol`, `function` și `object`. Notați că `typeof null` returnează `"object"`.
1076+
1077+
</p>
1078+
</details>
1079+
1080+
---
1081+
1082+
###### 35. Care dintre aceste valori sunt considerate falsy?
1083+
1084+
```javascript
1085+
0;
1086+
new Number(0);
1087+
('');
1088+
(' ');
1089+
new Boolean(false);
1090+
undefined;
1091+
```
1092+
1093+
- A: `0`, `''`, `undefined`
1094+
- B: `0`, `new Number(0)`, `''`, `new Boolean(false)`, `undefined`
1095+
- C: `0`, `''`, `new Boolean(false)`, `undefined`
1096+
- D: Toate dintre ele sunt considerate falsy
1097+
1098+
<details><summary><b>Răspuns</b></summary>
1099+
<p>
1100+
1101+
#### Răspuns: A
1102+
1103+
Există 8 valori considerate falsy:
1104+
1105+
- `undefined`
1106+
- `null`
1107+
- `NaN`
1108+
- `false`
1109+
- `''` (șir de caractere gol)
1110+
- `0`
1111+
- `-0`
1112+
- `0n` (BigInt(0))
1113+
1114+
Constructorii de funcții, cum ar fi `new Number` și `new Boolean` sunt considerați truthy.
1115+
1116+
</p>
1117+
</details>
1118+
1119+
---
1120+
1121+
###### 36. Care este rezultatul?
1122+
1123+
```javascript
1124+
console.log(typeof typeof 1);
1125+
```
1126+
1127+
- A: `"number"`
1128+
- B: `"string"`
1129+
- C: `"object"`
1130+
- D: `"undefined"`
1131+
1132+
<details><summary><b>Răspuns</b></summary>
1133+
<p>
1134+
1135+
#### Răspuns: B
1136+
1137+
`typeof 1` returnează `"number"`.
1138+
`typeof "number"` returnează `"string"`
1139+
1140+
</p>
1141+
</details>
1142+
1143+
---
1144+
1145+
###### 37. Care este rezultatul?
1146+
1147+
```javascript
1148+
const numbers = [1, 2, 3];
1149+
numbers[10] = 11;
1150+
console.log(numbers);
1151+
```
1152+
1153+
- A: `[1, 2, 3, null x 7, 11]`
1154+
- B: `[1, 2, 3, 11]`
1155+
- C: `[1, 2, 3, empty x 7, 11]`
1156+
- D: `SyntaxError`
1157+
1158+
<details><summary><b>Răspuns</b></summary>
1159+
<p>
1160+
1161+
#### Răspuns: C
1162+
1163+
Când setați o valoare pentru un element într-un array care depășește lungimea array-ului, JavaScript creează ceea ce se numește "slot-uri goale" (empty slots). Acestea au de fapt valoarea `undefined`, dar veți vedea ceva de genul:
1164+
1165+
`[1, 2, 3, empty x 7, 11]`
1166+
1167+
în funcție de locul în care îl rulați (este diferit pentru fiecare browser, Node.js, etc.)
1168+
1169+
</p>
1170+
</details>
1171+
1172+
---
1173+
1174+
###### 38. Care este rezultatul?
1175+
1176+
```javascript
1177+
(() => {
1178+
let x, y;
1179+
try {
1180+
throw new Error();
1181+
} catch (x) {
1182+
(x = 1), (y = 2);
1183+
console.log(x);
1184+
}
1185+
console.log(x);
1186+
console.log(y);
1187+
})();
1188+
```
1189+
1190+
- A: `1` `undefined` `2`
1191+
- B: `undefined` `undefined` `undefined`
1192+
- C: `1` `1` `2`
1193+
- D: `1` `undefined` `undefined`
1194+
1195+
<details><summary><b>Răspuns</b></summary>
1196+
<p>
1197+
1198+
#### Răspuns: A
1199+
1200+
Blocul `catch` primește argumentul `x`. Acesta nu este același `x` ca variabila când transmitem argumente. Această variabilă `x` este având domeniu de bloc (block-scoped).
1201+
1202+
Mai târziu, setăm această variabilă cu domeniu de bloc la valoarea `1`, și stabilim valoarea variabilei `y`. Acum, înregistrăm în consolă variabila cu domeniu de bloc `x`, care este egală cu `1`.
1203+
1204+
În afara blocului `catch`, `x` rămâne `undefined`, și `y` este `2`. Atunci când dorim să afișăm în consolă `console.log(x)` în afara blocului `catch`, acesta returnează `undefined`, și `y` returnează `2`.
1205+
1206+
</p>
1207+
</details>
1208+
1209+
---
1210+
1211+
###### 39. Totul în JavaScript este fie un...
1212+
1213+
- A: primitiv sau obiect
1214+
- B: funcție sau obiect
1215+
- C: întrebare trucată! doar obiecte
1216+
- D: număr sau obiect
1217+
1218+
<details><summary><b>Răspuns</b></summary>
1219+
<p>
1220+
1221+
#### Răspuns: A
1222+
1223+
JavaScript are doar tipuri primitive și obiecte.
1224+
1225+
Tipurile primitive sunt `boolean`, `null`, `undefined`, `bigint`, `number`, `string`, și `symbol`.
1226+
1227+
Ceea ce diferențiază un tip primitiv de un obiect este faptul că tipurile primitive nu au proprietăți sau metode. Cu toate acestea, veți observa că `'foo'.toUpperCase()` se evaluează la `'FOO'` și nu duce la o eroare `TypeError`. Acest lucru se întâmplă pentru că atunci când încercați să accesați o proprietate sau o metodă pe un tip primitiv, cum ar fi un șir de caractere (string), JavaScript va înconjura implicit tipul primitiv folosind una dintre clasele de înveliș, adică `String`, și apoi va renunța imediat la înveliș după ce expresia se evaluează. Toate tipurile primitive, cu excepția `null` și `undefined` prezintă acest comportament.
1228+
1229+
</p>
1230+
</details>
1231+
1232+
---
1233+
1234+
###### 40. Care este rezultatul?
1235+
1236+
```javascript
1237+
[[0, 1], [2, 3]].reduce(
1238+
(acc, cur) => {
1239+
return acc.concat(cur);
1240+
},
1241+
[1, 2],
1242+
);
1243+
```
1244+
1245+
- A: `[0, 1, 2, 3, 1, 2]`
1246+
- B: `[6, 1, 2]`
1247+
- C: `[1, 2, 0, 1, 2, 3]`
1248+
- D: `[1, 2, 6]`
1249+
1250+
<details><summary><b>Răspuns</b></summary>
1251+
<p>
1252+
1253+
#### Răspuns: C
1254+
1255+
`[1, 2]` este valoarea noastră inițială. Aceasta este valoarea cu care începem și valoarea primului `acc`. În prima rundă, `acc` este `[1,2]`, și `cur` este `[0, 1]`. Le concatenăm, ceea ce duce la rezultatul `[1, 2, 0, 1]`.
1256+
1257+
Atunci, `[1, 2, 0, 1]` este `acc` și `[2, 3]` este `cur`. Le concatenăm și obținem `[1, 2, 0, 1, 2, 3]`
1258+
1259+
</p>
1260+
</details>
1261+
9631262
---

0 commit comments

Comments
 (0)