Șiruri de caractere

Șiruri de caractere, obiectul String și metodele sale

Pentru a crea șiruri de caractere, putem să le atribuim direct unei variabile sau constante:

const message = "Hello";

Pentru lucrul cu șiruri de caractere, există obiectul String, așa că putem folosi și constructorul String:

const message = new String("Hello");

Dar de obicei, prima variantă mai scurtă este preferată. În primul caz, JavaScript va converti automat variabila de tip primitiv într-un obiect String, dacă este necesar.

Prin intermediul indecșilor, putem accesa caractere individuale dintr-un șir, asemenea elementelor unui array (în JavaScript, indexarea începe de la zero):

const message = "Hello";
console.log(message[0]);    // H
console.log(message[4]);    // o

Obiectul String are un set extins de proprietăți și metode, cu ajutorul cărora putem manipula șirurile.

Lungimea șirului

Proprietatea length indică lungimea șirului:

const message = "Hello";
console.log(message.length);            //  5 simboluri

Repetarea șirului

Metoda repeat() permite crearea unui șir prin repetarea multiplă a altui șir. Numărul de repetări este transmis ca argument:

const message = "hello ";
console.log(message.repeat(3)); // hello hello hello

Căutarea în șir

Pentru a căuta un subșir într-un șir se folosesc metodele indexOf() (indicele primei apariții a subșirului) și lastIndexOf() (indicele ultimei apariții a subșirului). Aceste metode primesc doi parametri:

indexOf(str, index)
lastIndexOf(str, index)

• str: Subșirul de căutat
• index: Indexul de la care începe căutarea (parametru opțional)

Ambele metode returnează indicele caracterului de la care începe subșirul în șir. Dacă subșirul nu este găsit, se returnează -1.

const hello = "salut lume. la revedere lume";
const key = "lume";
const firstPos = hello.indexOf(key);
const lastPos = hello.lastIndexOf(key);
console.log("Prima apariție: ", firstPos);    // 7
console.log("Ultima apariție: ", lastPos);  // 17

Aplicăm căutarea relativ la un index, de exemplu, începând de la indexul 10:

const hello = "salut lume. la revedere lume";
const key = "lume";
const firstPos = hello.indexOf(key, 10);    // căutare de la indexul 10
console.log("Prima apariție: ", firstPos);    // 17

Trebuie să ținem cont că căutarea este sensibilă la majuscule și minuscule:

const hello = "salut lume. la revedere lume";
const key = "Lume";
const firstPos = hello.indexOf(key);
console.log(firstPos);  // -1

Metoda includes

Încă o metodă - includes() returnează true dacă șirul conține un anumit subșir.

const hello = "salut lume. la revedere lume";

console.log(hello.includes("lume")); // true
console.log(hello.includes("lumina")); // false

Cu ajutorul celui de-al doilea parametru opțional, putem specifica indexul de la care începe căutarea subșirului:

const hello = "salut lume. la revedere lume";

console.log(hello.includes("lume", 5));  // true
console.log(hello.includes("salut", 6));   // false

Alegerea unui subșir

Pentru a tăia un subșir dintr-un șir, se folosesc metodele substring() și slice().

Metoda Substring

Metoda substring() primește doi parametri:

substring(startIndex, endIndex)

• startIndex: Indexul caracterului din șir de la care să înceapă tăierea. Parametru obligatoriu.
• endIndex: Indexul până la care să se taie șirul. Parametru opțional - dacă nu este specificat, se taie restul șirului.

const hello = "salut lume. la revedere lume";
const world = hello.substring(7, 10); // de la indexul 7 la 10
console.log(world); // lume
const bye = hello.substring(12);    // de la indexul 12 până la sfârșitul șirului
console.log(bye); // la revedere lume

Metoda slice

Metoda slice permite, de asemenea, obținerea unei părți dintr-un șir. Aceasta primește doi parametri:

slice(startIndex, endIndex)

• Indexul de început al subșirului în șir. Parametru obligatoriu.
• Indexul de sfârșit al subșirului în șir. Parametru opțional - dacă nu este specificat, se taie restul șirului.

const hello = "salut lume. la revedere lume";
const world = hello.slice(6, 10); // de la indexul 6 la 10
console.log(world); // lume
const bye = hello.slice(12);    // de la indexul 12 până la sfârșitul șirului
console.log(bye); // la revedere lume

Se poate observa că această metodă este similară cu metoda substring(). Cu toate acestea, există mici diferențe între ele. În primul rând, în slice(), indexul de început trebuie să fie mai mic decât indexul de sfârșit. În substring(), dacă indexul de început este mai mare decât indexul de sfârșit, acestea sunt schimbate (adică substring(5, 1) va fi echivalent cu substring(1, 5)):

const hello = "salut lume. la revedere lume";
const world1 = hello.slice(6, 0); // nu funcționează
console.log(world1); // șir gol
const world2 = hello.substring(6, 0); // echivalent cu hello.substring(0, 6)
console.log(world2); // salut

O altă diferență este că slice() permite utilizarea de indecși negativi. Un index negativ indică indexul caracterului față de sfârșitul șirului. substring() nu suportă însă indecșii negativi:

const hello = "salut lume. la revedere lume";
const bye1 = hello.slice(-8, -4); // de la indexul 8 de la sfârșit până la 4 de la sfârșit
console.log(bye1); // la
const bye2 = hello.substring(-8, -4); // nu funcționează
console.log(bye2); //

Metoda substr

Trebuie de menționat că există și metoda substr(). Această metodă nu face parte din standard și, în general, nu este recomandată pentru utilizare. Cu toate acestea, încă poate fi acceptată de browsere și o puteți întâlni în diferite programe. Aceasta primește doi parametri:

substr(startIndex, count)

• startIndex: Indexul caracterului din șir de la care să înceapă selectarea. Parametru obligatoriu.
• count: Numărul de caractere de selectat. Parametru opțional - dacă nu este specificat, se selectează restul șirului.

Exemplu:

const hello = "salut lume. la revedere lume";
const world = hello.substr(6, 3); // de la indexul 6, 3 caractere
console.log(world); // lume
const bye = hello.substr(12); // de la indexul 12 până la sfârșitul șirului
console.log(bye); // la revedere lume

Controlul majusculelor și minusculelor

Pentru a schimba registrul caracterelor, există metodele toLowerCase() (pentru a converti la litere mici) și toUpperCase() (pentru a converti la litere mari).

const hello = "Salut Tom";
console.log(hello.toLowerCase()); // salut tom
console.log(hello.toUpperCase()); // SALUT TOM

Obținerea unui caracter după index

Pentru a obține un anumit caracter în șir la un anumit index, se poate utiliza sintaxa de array. Totuși, JavaScript oferă și metodele charAt() și charCodeAt(). Ambele metode primesc indexul caracterului ca parametru:

const hello = "Salut Tom";
console.log(hello.charAt(2));       // i
console.log(hello.charCodeAt(2));   // 108

Dar în timp ce metoda charAt() returnează caracterul însuși ca rezultat, metoda charCodeAt() returnează codul numeric al acelui caracter.

Eliminarea spațiilor goale

Pentru a elimina spațiile goale inițiale și finale dintr-un șir, se utilizează metoda trim():

let hello = "   Salut Tom  ";
const beforeLength = hello.length;
hello = hello.trim();
const afterLength = hello.length;
console.log("Lungimea șirului înainte: ", beforeLength);     // 17
console.log("Lungimea șirului după: ", afterLength);   // 10

Eliminarea spațiilor goale de la începutul și sfârșitul șirului:

• trimStart(): elimină spațiul gol de la începutul șirului (în funcție de direcția de scriere, acesta poate fi marginea dreaptă sau stângă a șirului)
• trimEnd(): elimină spațiul gol de la sfârșitul șirului (în funcție de direcția de scriere, acesta poate fi marginea dreaptă sau stângă a șirului)
• trimLeft(): elimină spațiul gol de la stânga șirului
• trimRight(): elimină spațiul gol de la dreapta șirului

Concatenarea șirurilor

Metoda concat() unește două șiruri:

let hello = "Salut ";
const world = "Tom";
hello = hello.concat(world);
console.log(hello); // Salut Tom

Înlocuirea unui subșir

Metoda replace() înlocuiește prima apariție a unui subșir cu altul:

let hello = "Bună ziua";
hello = hello.replace("ziua", "seară");
console.log(hello); // Bună seară

Primul parametru al metodei indică subșirul care trebuie înlocuit, iar al doilea parametru indică subșirul cu care trebuie înlocuit.

Cu toate acestea, această metodă are o caracteristică - înlocuiește doar prima apariție a subșirului:

let menu = "Mic dejun: fulgi de ovăz, ceai. Prânz: supă, ceai. Cină: salată, ceai.";
menu = menu.replace("ceai", "cafea");
console.log(menu);  // Mic dejun: fulgi de ovăz, cafea. Prânz: supă, ceai. Cină: salată, ceai.

Cu toate acestea, o altă metodă - replaceAll() - permite înlocuirea tuturor aparițiilor ale subșirului:

let menu = "Mic dejun: fulgi de ovăz, ceai. Prânz: supă, ceai. Cină: salată, ceai.";
menu = menu.replaceAll("ceai", "cafea");
console.log(menu);  // Mic dejun: fulgi de ovăz, cafea. Prânz: supă, cafea. Cină: salată, cafea.

Despărțirea șirului

Metoda split() împarte un șir într-un array de subșiruri, folosind un anumit separator. Separatorul este transmis ca argument:

const message = "Astăzi a fost vreme frumoasă";
const messageParts = message.split(" ");
console.log(messageParts);  // ["Astăzi", "a", "fost", "vreme", "frumoasă"]

În acest caz, șirul este despărțit în funcție de spațiu, astfel încât array-ul messageParts conține patru elemente.

Verificarea începutului și sfârșitului șirului

Metoda startsWith() returnează true dacă șirul începe cu un anumit subșir. Metoda endsWith() returnează true dacă șirul se termină cu un anumit subșir.

const hello = "let me speak from my heart";
console.log(hello.startsWith("let"));       // true
console.log(hello.startsWith("Let"));       // false
console.log(hello.startsWith("lets"));      // false

console.log(hello.endsWith("heart"));       // true
console.log(hello.startsWith("bart"));      // false

Joacă un rol și sensibilitatea la majuscule și minuscule, și din exemplul de mai sus vedem că "let" nu este echivalent cu "Let".

Un al doilea parametru suplimentar permite specificarea unui index (pentru startsWith - index de la început și pentru endsWith - index de la sfârșitul șirului) în raport cu care se va face comparația:

const hello = "let me speak from my heart";
console.log(hello.startsWith("me", 4));     // true, "me" - index 4 de la începutul șirului

console.log(hello.startsWith("my", hello.length-8));    // true, "my" - index 8 de la sfârșit

Umplerea șirului

Metodele padStart() și padEnd() extind un șir la un număr specific de caractere și umplu șirul la stânga și, respectiv, la dreapta.

let hello = "hello".padStart(8);  // "   hello"
console.log(hello);
hello = "hello".padEnd(8);      // "hello   "
console.log(hello);

Apelul "hello".padStart(8) va extinde șirul "hello" la 8 caractere. Adică inițial în șirul "hello" sunt 5 caractere, astfel că vor fi adăugate 3 caractere. Acestea vor fi adăugate la începutul șirului. În mod implicit, caracterele adăugate spații goale. Similar, apelul "hello".padEnd(8) va extinde șirul la 8 caractere, dar caracterele rămase sub formă de spații goale vor fi adăugate la sfârșitul șirului.

În mod implicit, aceste metode utilizează spații goale pentru umplere, dar ca al doilea parametru putem furniza metodelor valoarea cu care să umplem șirul:

let hello = "hello".padStart(17, "JavaScript, ");  // "JavaScript, hello"
hello = "hello".padEnd(12, " Eugene");      // "hello Eugene"

Dacă numărul de caractere adăugate este mai mare decât lungimea șirului adăugat, atunci șirul adăugat se repetă:

let hello = "123".padStart(6, "0");  // "000123"
hello = "123".padEnd(6, "0");       // "123000"