RegExp-urile și Symbol au multe lucruri în comun

Author: kosson

obiecte/obiecte-interne-standard/Array/prototype-array/Array.prototype.concat.md

@@ -1,6 +1,6 @@
-# Array.prototype.concat() - nu afectează array-ul
+# `Array.prototype.concat()` - nu afectează array-ul
 
-Realizează o „copie simplă” (shallow copy) formată din elementele array-ului asupra căruia se invocă metoda și elementele care se doresc a fi adăugate.
+Realizează o „copie simplă” (*shallow copy*) formată din elementele array-ului asupra căruia se invocă metoda și elementele care se doresc a fi adăugate.
 
 ```javascript
 var arr = [1, 2, 3];
@@ -12,23 +12,29 @@ arr.concat([4, [5, 6]]);// returnează Array [ 1, 2, 3, 4, Array[2] ]
 arr.concat([4, [5, 6], 7, 8, [9, 10]]); // returnează Array [ 1, 2, 3, 4, Array[2], 7, 8, Array[2] ]
 ```
 
-Ceea ce trebuie remarcat este faptul că operațiunea concat realizează o „desfacere” a unui array și alipirea valorilor sale, dacă acesta este poziționat primul. Un array poziționat dincolo de prima valoare, va fi introdus ca array și nu ca valorile sale.
+Ceea ce trebuie remarcat este faptul că operațiunea concat realizează o „desfacere” a unui array și alipirea valorilor sale, dacă acesta este poziționat primul. Un array poziționat dincolo de prima valoare, va fi introdus ca array și valorile sale în mod direct.
 
 Elementele array-urilor originale sunt copiate în noul array format respectându-se următoarele reguli:
 - în cazul obiectelor sunt copiate referințe către acestea, nu obiectele în sine. Dacă un obiect referențiat este modificat, se va reflecta în array-ul original și cel nou format.
-- în cazul șirurilor și numerelor, acestea vor fi copiate în noul array. Modificarea valorilor din array-urile originale nu se vor răsfrânge în cel nou constituit.
+- în cazul *șirurilor de caractere* și a *numerelor*, acestea vor fi copiate în noul array. Modificarea valorilor din array-urile originale nu se vor răsfrânge în cel nou constituit.
+
+La un array se pot adăuga elemente în mod direct folosindu-se `concat` prin pasarea unui al doilea argument.
+
+```javascript
+var arr = [1, 2, 3];
+arr.concat("ceva");
+console.log(arr);
+// [ 1, 2, 3, "ceva" ]
+```
 
 ![Array.prototype.concat()](ArrayConcat.svg)
 
-Se poate chiar construi o funcție concat folosind slice, dar care să facă concat pe argumentele pasate.
+Se poate chiar construi o funcție `concat` folosind `slice`, dar care să facă concat pe argumentele pasate.
 
 ```javascript
-
 function concat () {
   return Array.prototype.slice.call(arguments).join(' ');
 };
-
 var sirNou = concat('ceva', 'text', 'pentru', 'a', 'fi', 'unit');
-
 console.log(sirNou);
 ```

obiecte/obiecte-interne-standard/RegExp/RegExp.md

@@ -125,7 +125,7 @@ Să spunem că un fragment de text începe cu un caracter ales de tine sau un ș
 Fără acest fanion, va fi returnată doar prima potrivire care se face.
 Folosind fanionul, se va face potrivire pe tot ce seamănă cu secvența șablonul.
 
-### Proprietăți ale obiectului `RegExp`
+### Proprietăți ale obiectului prototip a lui `RegExp`
 
 Aceste proprietăți sunt foarte utile atunci când dorești să afli starea în care se află obiectul regex la un anumit moment dat.
 
@@ -263,7 +263,7 @@ console.dir(cautare);
 
 Fără niciun fanion specificat, se va face regărirea primului caracter din set, când acesta este întâlnit în șir. Căutarea se va opri aici. Folosirea fanionului `g`, va avea ca efect căutarea în întreg șirul după fiecare caracter din setul specificat.
 
-Regex-ul permite folosirea unui caracter special, linia, care va specifica limitele setului. Un bun exemplu este căutarea prin întreg setul de caractere de la a la z: `[a-z]` sau majusculele `[A-Z]` ori cifrele `[0-9]`. Caracterul liniuță spune Regex-ului să constituie un ***set***. O mică precizare pentru a elimina confuziile: pentru a face potrivire după însăși caracterul `-`, trebuie precedate de backslash. Atenție, potrivirea se va face după un singur caracter din acel set, nu după toate sau mai simplu, este răspunsul la întrebarea: caracterul la care mă uit se regăsește în acest set?
+Regex-ul permite folosirea unui caracter special, linia, care va specifica limitele setului. Un bun exemplu este căutarea prin întreg setul de caractere de la a la z: `[a-z]` sau majusculele `[A-Z]` ori cifrele `[0-9]`. Caracterul liniuță spune RegExp-ului să constituie un ***set***. O mică precizare pentru a elimina confuziile: pentru a face potrivire după însăși caracterul `-`, trebuie precedate de backslash. Atenție, potrivirea se va face după un singur caracter din acel set, nu după toate sau mai simplu, este răspunsul la întrebarea: caracterul la care mă uit se regăsește în acest set?
 
 ### Metacaracterele în seturi
 
@@ -355,7 +355,7 @@ console.log(sir.match(sablon));
 
 Acest lucru se petrece pentru că punctul consideră prima croșetă care în gândirea noastră ar trebui să închidă parcurgerea șirului drept un caracter oarecare și va vontinua cu toate celelalte până când va ajunge la poziția de după ultimul caracter. Abia atunci motorul RegExp va privi ultimul caracter și-l va compara cu cel din regex pentru a vedea dacă este ce caută pentru a satisface șablonul. Dacă mai sunt alte caractere diferite de `>`, pur și simplu se va întoarce înapoi pe cărare și la primul caracter `>` va returna ca potrivire. Operațiunea de a merge înapoi pe șir pentru a satisface căutarea se numește `backtracking` (back înseamnă „înapoi” și tracking „a urma”). După ce a făcut backtracking, va returna „nerăbdător” ceea ce a găsit.
 
-Cum transformi comportamentul expansiv (greedy) într-unul autosuficient? Adaugi imediat după plus cuantificatorul `?`
+Cum transformi comportamentul expansiv (**greedy**) într-unul autosuficient? Adaugi imediat după plus cuantificatorul `?`
 
 ```javascript
 var sir = '<p>Un <cite>citat.</cite></p>';
@@ -374,7 +374,7 @@ var cautare = sir.match(/pământ?/gi);
 console.dir(cautare); // apare de 2 ori
 ```
 
-De fapt, nu e chiar atât de inteligent regex-ul, ci doar spune că acea combinație de caractere trebuie să apară în șir cuantificându-se de câte ori apare indiferent ce precede sau cu ce continuă.
+De fapt, nu e chiar atât de inteligent RegExp-ul, ci doar spune că acea combinație de caractere trebuie să apară în șir numărându-se de câte ori apare indiferent ce precede sau cu ce continuă.
 
 Un strop de inteligență ar fi să introduci alternative într-un grup, care, la rândul său să existe sau nu.
 
@@ -394,7 +394,7 @@ console.log(sir.match(sablon));
 // ["octombrie","oct"]
 ```
 
-Ceea ce se mai observă este că metacaracterul `?` este unul care implică comportamentul expansiv (greedy). De ce? Pentru că spune motorului că musai trebuie să potrivească șablonul ca mai apoi să se dea bătut dacă acesta are corespondent în string. Pentru a face șablonul autosuficient (lazzy), ar trebui să mai pui un metacaracter `?` după primul.
+Ceea ce se mai observă este că metacaracterul `?` este unul care implică comportamentul expansiv (**greedy**). De ce? Pentru că spune motorului că musai trebuie să potrivească șablonul ca mai apoi să se dea bătut dacă acesta are corespondent în string. Pentru a face șablonul autosuficient (**lazzy**), ar trebui să mai pui un metacaracter `?` după primul.
 
 Cuantificatorul `*` este combinația celor dinainte. Este și el un cuantificator expansiv încercând să consume întreaga resursă de șir.
 
@@ -608,7 +608,7 @@ obi;
 
 Acesta este un caz foarte simplu în care dacă avem elemente de același fel acestea se vor suprascrie în obiect.
 
-### Backreferencing
+### Backreferencing - căutare înapoi cu un pas
 
 Gruparea activează un mecanism de memorizare care ține minte șirul de caractere pentru secvența șablonului dintre parantezele rotunde. Mecanismul de memorizare poate fi anulat la nevoie. Nu uita faptul că memorizarea (***backreference***) taxează ca și resurse. Dacă nu ai nevoie de ea, anuleaz-o. De exemplu, în `bună(stare)?`, fragmentul memorizat, la momentul extragerii din șir va fi `stare`. Pentru a renunța la memorizare pui imediat după deschiderea parantezei rotunde a grupului sintaxa specială semnul întrebării și două puncte: `?:`. Astfel, șablonul va deveni `bună(?:stare)?`. Sintaxa `?:` spune motorului să nu folosească capturarea, memorizarea.
 
@@ -644,7 +644,7 @@ console.log(sir.match(sablon));
 // [Array] ["scris scris","scris"]
 ```
 
-## Lookahead pozitiv și negativ
+## Lookahead pozitiv și negativ - căutarea cu anticipare
 
 Am menționat deja că un șablon `a(?=b)` indică motorului RegExp faptul că trebuie să avanseze pe șir pentru a satisface potrivirea lui a urmat imediat de `b` așa cum avem acum.
 
@@ -669,7 +669,7 @@ console.log(sir.match(sir));
 
 Șabloanele regex fac casă bună cu anumite metodele ale obiectului intern String.
 
-### Căutarea cu `search`
+### Căutarea folosind metoda `search(șablon)`
 
 Metoda specializată acceptă drept argument un șablon regex pentru a face căutări.
 
@@ -680,7 +680,7 @@ ceva.search(/orice/); // 14
 
 Este returnat indexul la care apare pentru prima dată combinația specificată de șablon. De ce nu a luat în considerare și primul cuvânt? Pentru că litera o este o majusculă care are nevoie de alt șablon. Prima secvență care se potrivește perfect este la indexul 4 al șirului.
 
-### Căutare cu `match`
+### Căutarea folosind metoda `match(șablon)`
 
 Rezultatul unei căutări pe șir cu metoda `match` a obiectului intern `String`.
 
@@ -693,9 +693,9 @@ console.dir(potriviri);
 Rezultatul este un array, care are valoarea 14 pentru `index` și la `input` întreg șirul.
 Dacă este activat fanionul `g`, regăsirea se va face pe tot șirul în toate combinațiile posibile și se va completa array-ul cu toate aceste variante.
 
-### Înlocuiri simple de șiruri - `replace`
+### Înlocuirea unui șir folosind metoda `replace(șablon, înlocuitor)`
 
-Adeseori regex-urile sunt cuplate cu metoda replace a obiectului intern `String`.
+Adeseori regex-urile sunt cuplate cu metoda `replace` a obiectului intern `String`.
 
 ```javascript
 var ceva = 'caut ceva';

obiecte/obiecte-interne-standard/String/prototype-string-methods/String.prototype.concat.md

@@ -7,7 +7,7 @@ var nucleu = "Salutare, ";
 console.log(nucleu.concat('prietene,', ' ce mai faci?')); // Salutare, prietene, ce mai faci?
 ```
 
-Același efect poate fi obținut cu următoarea secvență de cod, care de această dată construiește o funcție concat și care operează asupra array-like-ului `arguments`:
+Același efect poate fi obținut cu următoarea secvență de cod, care de această dată construiește o funcție `concat` și care operează asupra array-like-ului `arguments`:
 
 ```javascript
 function concat () {
@@ -17,7 +17,7 @@ var sirNou = concat('ceva', 'text', 'pentru', 'a', 'fi', 'unit')
 console.log(sirNou); // ceva text pentru a fi unit
 ```
 
-Folosirea `rest parameters`, adică o sintaxă ce permite extragerea unui Array din argumentele pasate unei funcții. Această sintaxă constă din adăugarea unui nume de parametru prefixat de trei puncte de suspensie. Această sintaxă generează un Array adevărat, nu un array-like așa cum este `arguments`.
+Folosirea `rest parameters`, adică o sintaxă ce permite extragerea unui Array din argumentele pasate unei funcții. Această sintaxă constă din adăugarea unui nume de parametru prefixat de trei puncte de suspensie. Această sintaxă generează un array adevărat, nu un *array-like* așa cum este `arguments`.
 
 ```javascript
 function concat (...argumentePasate){

obiecte/obiecte-interne-standard/Symbol/Symbol.md

@@ -159,14 +159,44 @@ Prin ce se disting *simbolurile binecunoscute* de celelalte? Prin faptul că sun
 
 Acesta este cazul operatorului `instanceof` prin care putem afla dacă un anumit obiect este o instanță a celui pentru care se face investigația.
 
+```javascript
+var obi = {x: true};
+obi instanceof Object; // true
+// echivalent cu
+Object[Symbol.hasInstance](obi);
+```
+
+Concluzia este că operatorul `instanceof` începând cu ECMAScript 6 a devenit o prescurtare către metoda `hasInstance` a lui `Symbol`. În acest caz, toate funcțiile în JavaScript vor avea o metodă `Symbol.hasInstance` prin care se poate testa dacă un obiecte este sau nu o instanță a acesteia. Această metodă este chiar în obiectul prototip al lui `Function` (`Function.prototype`), ceea ce face ca toate funcțiile să o moștenească. Proprietatea `Symbol.hasInstance` este non-writable, nonconfigurable și nonenumerable pentru a se asigura faptul că nu va fi suprascrisă dintr-o eroare. Totuși, fii foarte atent că prin utilizarea metodei `Object.defineProperty()`, poți modifica fără probleme `Symbol.hasInstance`.
+
 ### `Symbol.isConcatSpreadable`
 
-Aceasta este o valoare boolean. Ceea ce indică ea este dacă un obiect poate fi transformat într-un array ce conține proprietățile sale atunci când se invocă `concat` pe un array existent. Adu-ți aminte că un array este la rândul său un obiect, de fapt. Acest simbol dă girul că obiectul poate fi tratat ca un array căruia urmează să i se adauge noi elemente.
+Aceasta este o valoare boolean. Ceea ce indică ea este dacă un obiect poate fi transformat într-un array ce conține proprietățile sale atunci când se invocă `concat` pe un array existent. Adu-ți aminte că un array este la rândul său un obiect, de fapt. Acest simbol dă girul că obiectul poate fi tratat ca un array căruia urmează să se adauge ca elemente noi la un array pe care se face `concat`-ul.
+
+```javascript
+var obiSimulandUnArray = {
+  0: "unu",
+  1: "doi",
+  length: 2,
+  [Symbol.isConcatSpreadable]: true
+};
+// obiSimulandUnArray are acum comportament de array
+var numaram = ["zero"].concat(obiSimulandUnArray);
+console.log(numaram); // [ "zero", "unu", "doi" ]
+```
 
 ### `Symbol.iterator`
 
 Acest simbol este mijlocul prin care se aplează iteratorul pentru un anumit obiect. Este binecunoscută apelarea iteratorului atunci când se folosește `for...of`.
 
+### Expunerea metodelor prin care se realizează interacțiuni cu textul
+
+Există patru metode a constructorului `Symbol`, care permit o posibilă interacțiune și mai intimă cu modul în care sunt exploatate textele folosind regex-urile. Pentru a înțelege ce oferă metodele lui Symbol, să trecem în revistă metodele utilizate de obiectul intern `RegExp`.
+
+- `match(șablonRegExp)` prin care se verifică dacă un șir de caractere este identic cu cel menționat prin șablonul regex-ului.
+- `replace(șablonRegExp, șirDeÎnlocuire)` prin care se caută un fragment identic cu cel menționat de regex, iar atunci când este găsit, se face înlocuirea sa cu șirul de caractere introdus ca al doilea argument.
+- `search(șablonRegExp)` localizează un fragment menționat prin șablonul regex-ului în interiorul unui text.
+- `split(șablonRegExp)` „sparge” un șir de caractere într-un array pe baza potrivirii după un șablon menționat prin regex.
+
 ### `Symbol.match`
 
 Este simbolul care pune în funcțiune algoritmii responsabili cu realizarea unei căutări într-un șir de caractere după un șablon. Este apelabil prin invocarea metodei `match()` pusă la dispoziție de obiectul intern RegExp.
@@ -179,14 +209,14 @@ Este simbolul care pune în funcțiune algoritmii responsabili cu realizarea une
 
 Este mecanismul declanțat la căutarea într-un șir după un șablon atunci când este apelată metoda `search()` a lui RegExp.
 
-### `Symbol.species`
-
-Este o valoare implicată în crearea de obiecte derivate.
-
 ### `Symbol.split`
 
 Este algoritmul care se pune în mișcare la apelarea metodei `split()` pe care obiectul intern String o pune la dispoziție.
 
+### `Symbol.species`
+
+Este o valoare implicată în crearea de obiecte derivate.
+
 ### `Symbol.toPrimitive`
 
 Un simbol utilizat pentru a converti un obiect la o primitivă. Standardul îl menționează, dar încă nu există aplicații practice.

operatori/operatori-de-relatie.md

@@ -25,10 +25,10 @@ var obi = {a: 1, b: 2};
 
 ## Operatorul `instanceof`
 
-Acest operator testează dacă în lanțul prototipal al unui obiect se află proprietatea `prototype` a unui constructor.
+Acest operator testează dacă în lanțul prototipal al unui obiect se află proprietatea `prototype` a unui constructor. Începând cu ECMAScript 6, operatorul `instanceof` este o prescurtare care apelează metoda `hasInstance` a constructorului `Symbol`. Toate funcțiile au o metodă `Symbol.hasInstance` cu ajutorul căreia se poate verifica dacă un anume obiect este sau nu o instanță a acelei funcții.
 
 ```javascript
-function EX(){};
+function EX () {};
 var obiX = new EX();
 
 Object.getPrototypeOf(obiX); // prototype este Object
@@ -50,8 +50,9 @@ Dacă este nevoie poți seta proprietatea `prototype` la un obiect diferit de ce
 EX.prototype = {};
 ```
 
-Nu uita că portotipul unui obiect se mai poate seta și cu `Object.setPrototypeOf(obiectul)`.
+Adu-ți mereu aminte că prototipul unui obiect se mai poate seta și cu `Object.setPrototypeOf(obiectul)`.
 
 ## Mantre
 
 - Un obiect literal are prototype `undefined`. Cu toate acestea la interogare cu instanceof trimite la Object.
+- `instanceof` este o prescurtare care apelează metoda `hasInstance` a constructorului `Symbol`.