Salutări tuturor cititorilor site-ului blog În acest articol ne vom uita la obiectul jscript încorporat – String, care este responsabil de procesarea textului.

Clasa internă js String a limbajului de programare al serverului de scripturi oferă metode de lucru cu șiruri, cum ar fi căutarea subșirurilor, analizarea sau înlocuirea. Are o singură proprietate lungime care returnează lungimea șirului. Trebuie amintit că . Nu este nevoie să folosiți cuvântul cheie nou și String pentru a declara o clasă.

Să ne uităm la un exemplu simplu:

WScript.Echo(s1.length + " \n"+ s2.lungime) ;

Vedem că aici am declarat două variabile s1 și s2, ambele stochează o valoare text "

text simplu

", folosind proprietatea length le-am determinat lungimea. După cum puteți vedea, puteți utiliza atât un format simplificat, cât și unul mai greoi (cuvinte cheie noi). Să ne uităm la principalele metode ale clasei String.

Metode ale clasei String JS s.charAt(index) – Obțineți caracterul la indexul dat din s. s.charCodeAt(index)

– Extrageți codul de caractere specificat în codificare Unicode

prin indicele său din s. s1.concat(s2) – Obțineți caracterul la indexul dat din s..

// Formarea unui șir// din CharCode_string.js var MyResult;.

MyResult= MyStr.indexOf("două", 2); WScript.Echo(MyResult);

s.lastIndexOf(substr, startindex)– Similar cu indexOf, dar vom căuta în ordine inversă.

„Pagină de internet http://www.site/~vladimir”; var rezultat = text.match (url) , index, list= "" if (rezultat != null ) ( for (var index în rezultat) ( list+= result[ index] + "; ) ) WScript.Echo (lista) ; s.slice(start, )

– Obțineți o parte din text, parametriînceput

// split_string.js var MyStr2, MyResult1, index, list= "" ;

MyStr2 ="primul, al doilea, al treilea, al patrulea" ; MyResult1 = MyStr2.split (", " );

pentru (var index în MyResult1) ( list+= MyResult1[ index] + "

;

) WScript.Echo (lista) ;

s.substr(început[, lungime])

– Similar cu felia, dar aici indicăm nu indexul final, ci lungimea.

s.substring(index1, index2)

– Vă permite să obțineți un subșir dintr-un șir dat.

subșir

Var hello = „bună ziua lume”; console.log("În linie "" + salut + "" " + hello.length + " caractere");

Metoda repeat() vă permite să creați un șir repetând un alt șir din nou și din nou. Numărul de repetări este transmis ca argument:

Let hello = „bună ziua”; console.log(hello.repeat(3)); // buna ziua buna ziua

Modele de rânduri

Șabloanele de șir vă permit să inserați diferite valori într-un șir. Pentru a face acest lucru, liniile sunt cuprinse între ghilimele înainte:

Let name = "Tom"; let hello = `Bună ziua $(nume)`; console.log(bună ziua); // Bună, Tom lasă vârsta = 23; let info = `$(numele) are $(vârsta) ani`; console.log(info); //Tom are 23 de ani

Pentru a introduce o valoare într-un șir, aceasta este închisă între acolade, precedată de un semn dolar.

De asemenea, în loc de valori scalare, pot fi adăugate proprietăți ale obiectelor complexe sau rezultate ale expresiilor:

Let tom =( nume: "Tom", vârsta: 25 ) let info = `$(tom.name) are $(tom.age) ani`; console.log(info); // Tom are 23 de ani funcția sum(x, y)( return x + y; ) fie a = 5, b = 4; fie rezultatul = `$(a) + $(b) = $(sum(a, b))`; console.log(rezultat); // 5 + 4 = 9

Căutați într-un șir

Pentru a căuta șiruri pentru un anumit subșir, se folosesc metodele indexOf() (indexul primei apariții a subșirului) și lastIndexOf() (indexul ultimei apariții a subșirului). Aceste metode iau doi parametri:

Subșir de găsit

Un parametru opțional care specifică din ce caracter să caute un subșir într-un șir

Ambele metode returnează indexul caracterului la care începe subșirul în șir. Dacă subșirul nu este găsit, atunci este returnat numărul -1.

Let hello = "bună lume. Pa pace"; let key = "lume"; let firstPos = hello.indexOf(key); let lastPos = hello.lastIndexOf(key); console.log("Prima apariție: ", firstPos); // 7 console.log("Ultima apariție: ", lastPos); // 17

O altă metodă - includes() returnează true dacă șirul conține un anumit subșir.

Let hello = "bună lume. Pa pace"; console.log(hello.includes(„lumea”)); // true console.log(hello.includes("moment"); // fals

Folosind al doilea parametru suplimentar, puteți determina indexul de la care va începe căutarea subșirului:

Let hello = "bună lume. Pa pace"; console.log(hello.includes(„lume”, 5)); // adevărat console.log(hello.includes(„bună ziua”, 6)); // fals

Selectarea subșirurilor

Pentru a tăia un subșir dintr-un șir, utilizați metodele substr() și substring().

Metoda substring() ia doi parametri:

index al caracterului din șir, începând de la care șirul trebuie tăiat

index la care ar trebui trunchiat șirul

Metoda substr() ia, de asemenea, indexul de pornire al subșirului ca prim parametru și lungimea subșirului de tăiat ca al doilea parametru:

Let hello = "bună lume. Pa pace"; lasă pa = hello.substr(12, 4); console.log(pa); // La revedere

Dacă al doilea parametru nu este specificat, restul liniei este trunchiat:

Let hello = "bună lume. Pa pace"; let bye = salut.substr(12); console.log(pa); // pa pace

Gestionarea registrului

Pentru a schimba majusculele, există metode toLowerCase() (pentru conversia în minuscule) și toUpperCase() (pentru conversia în majuscule).

Let hello = "Bună ziua Tom"; console.log(hello.toLowerCase()); // salut Tom console.log(hello.toUpperCase()); // SALUT TOM

Obținerea unui simbol prin index

Pentru a obține un anumit caracter într-un șir prin index, puteți utiliza metodele charAt() și charCodeAt(). Ambele metode iau indexul caracterelor ca parametru:

Let hello = "Bună ziua Tom"; console.log(hello.charAt(2)); // și console.log(hello.charCodeAt(2)); // 1080

Dar dacă metoda charAt() returnează caracterul în sine ca rezultat, atunci metoda charCodeAt() returnează codul numeric al acestui caracter.

Eliminarea spatiilor

Pentru a elimina spațiile de început și de final dintr-un șir, utilizați metoda trim():

Let hello = "Bună ziua Tom"; let beforeLength = salut.lungime; salut = hello.trim(); let afterLength = hello.length; console.log("Lungimea liniei până la: ", beforeLength); // 15 console.log("Lungimea liniei după: ", dupăLungime); // 10

Concatenarea șirurilor

Metoda concat() concatenează două șiruri de caractere:

Let hello = „Bună ziua”; let world = „lume”; hello = hello.concat(world); console.log(bună ziua); // Salut Lume

Înlocuirea subșirurilor

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

Bună ziua = „Bună ziua”; hello = hello.replace("zi", "seara"); console.log(bună ziua); // Bună seara

Primul parametru al metodei specifică ce subșir trebuie înlocuit, iar al doilea parametru specifică cu ce subșir trebuie înlocuit.

Împărțirea șirurilor

Metoda split() împarte un șir într-o matrice de subșiruri folosind un delimitator specificat. Separatorul este un șir care este transmis metodei:

Var mesaj = „Vremea a fost frumoasă astăzi”; var stringArray = message.split(" "); for(var str în stringArray) console.log(stringArray);

Ieșire din browser

Vremea a fost frumoasă astăzi

Verificarea începutului și a sfârșitului unei linii

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

Let hello = „lasă-mă să vorbesc din inima mea”; console.log(hello.startsWith("lasa")); // true console.log(hello.startsWith("Let")); // false console.log(hello.startsWith("permite")); // false console.log(hello.endsWith("inima"); // true console.log(hello.startsWith("bart")); // fals

Cazul joacă un rol aici, iar din exemplul de mai sus putem observa că „las” nu este echivalent cu „Let”.

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

Let hello = „lasă-mă să vorbesc din inima mea”; console.log(hello.startsWith(„eu”, 4)); // adevărat, "eu" - al patrulea index de la începutul liniei console.log(hello.startsWith("my", hello.length-8)); // adevărat, „meu” - al 8-lea indice de la sfârșit

Buna ziua! În această lecție ne vom uita la modul în care puteți crea un șir și funcții pentru a lucra cu șiruri în JavaScript. În principiu, în JavaScript, orice variabilă de text este un șir, deoarece JavaScript nu este un limbaj de programare puternic tipizat (citiți despre tipurile de date). Și, de asemenea, pentru a lucra cu șiruri de caractere se folosește clasa String:

Var name1 = "Tommy";

Deci, utilizați constructorul String:

Var name1 = new String ("Tommy");

Prima metodă este folosită în principal, probabil pentru că este mai scurtă.

Clasa String pentru lucrul cu șiruri are un set destul de mare de proprietăți și funcții cu care puteți efectua diverse manipulări cu șiruri.

Lungimea șirului

Proprietatea length vă permite să setați lungimea șirului. Această proprietate returnează un număr:

Var hello1 = „bună ziua lume”; document.write("În linie "" + salut + "" " + hello1.length + " caractere");

Căutați într-un șir

Pentru a găsi un anumit subșir într-un șir, se folosesc funcțiile indexOf() (returnează indexul primei apariții a subșirului) și lastIndexOf() (returnează indexul ultimei apariții a subșirului). Aceste funcții au două argumente:

• Subșirul care de fapt trebuie găsit
• Un argument opțional care specifică din ce caracter să caute un subșir într-un șir

Ambele funcții returnează un număr, care este indexul caracterului la care începe subșirul în șir. Dacă subșirul nu este găsit, va fi returnat numărul -1. Prin urmare, aceste funcții sunt utilizate în operatorii logici, deoarece, de regulă, trebuie doar să verificați dacă un șir conține sau nu un subșir, apoi în acest caz rezultatul acestor funcții este comparat cu -1.

Var str1 = „Bună Vasya!”; var podstr = "Petya"; if(str.indexOf(podstr) == -1)( document.write("Subșirul nu a fost găsit."); ) else (document.write("Subșirul găsit."); )

În exemplu, va fi afișat mesajul „Substring not found”, deoarece șirul „Peter” nu este conținut în șirul „Hello Vasya!”.

Funcțiile includ, startsWith, endsWith

Metoda mai modernă str.includes(substr, pos) returnează true dacă șirul str conține subșirul subșirului, sau false dacă nu.

Aceasta este alegerea potrivită dacă trebuie să verificăm dacă există o potrivire, dar poziția nu este necesară:

Alert("Widget cu id". include ("Widget"); // alertă adevărată ("Bună ziua". include ("La revedere")); // fals

Al doilea argument opțional pentru str.includes vă permite să începeți căutarea la o anumită poziție:

Alerta ("Midget". include ("id")); // alertă adevărată ("Midget". include ("id", 3)); // fals, căutarea a început din poziția 3

Metodele str.startsWith și, respectiv, str.endsWith verifică dacă un șir începe și se termină cu un anumit șir:

Alert("Widget". startsWith("Wid")); // true, "Wid" - începutul alertei "Widget" ("Widget".endsWith("get")); // adevărat, "obține" - se termină cu "Widget"

Selectarea subșirurilor

Pentru a tăia un subșir dintr-un șir, sunt folosite funcții precum substr() și substring().

Funcția substring() are 2 argumente:

• poziția de pornire a caracterului în linie, începând de la care linia va fi tăiată
• poziţia finală la care trebuie tăiată sfoara

Funcția substr() ia, de asemenea, indexul de pornire al subșirului ca prim parametru și lungimea subșirului ca al doilea parametru:

Var hello1 = "bună lume. Adio lume"; var bye1 = hello1.substr(12, 2); document.write(bye1);//Înainte

Și dacă al 2-lea parametru nu este specificat, atunci linia va fi trunchiată până la sfârșit:

Var hello1 = "bună lume. Adio lume"; var bye1 = hello1.substr(12); document.write(bye1); //pa pace

Controlul majusculelor cu litere

Pentru a schimba majusculele literelor, adică pentru a face toate literele mici sau majuscule, utilizați funcțiile toLowerCase() (pentru a converti caracterele în minuscule, adică toate literele vor fi mici) și toUpperCase() (pentru a converti caracterele în minuscule). majuscule, adică toate literele vor fi mari).

Var hello1 = "Bună ziua, Jim"; document.write(hello1.toLowerCase() + "
"); //salut Jim document.write(hello1.toUpperCase() + "
"); //BUNA JIM

Obținerea unui simbol după indexul său

Pentru a găsi un anumit caracter dintr-un șir prin indexul său, sunt utilizate funcțiile charAt() și charCodeAt(). Ambele funcții au ca argument un index de caractere:

Var hello1 = "Bună ziua, Jim"; document.write(hello1.charAt(3) + "
"); //în document.write(hello1.charCodeAt(3) + "
"); //1080

Dar numai dacă funcția charAt() returnează caracterul în sine ca rezultat al activității sale, atunci funcția charCodeAt() va returna codul numeric Unicode al acestui caracter.

Eliminarea spatiilor

Pentru a elimina spațiile dintr-un șir, utilizați funcția trim():

Var hello1 = "Bună ziua, Jim"; var beforeLen = hello1.lungime; hello1 = hello1.trim(); var afterLen = hello1.length; document.write("Lungimea liniei până la: " + beforeLen + "
"); //15 document.write("Lungimea liniei după: " + afterLen + "
"); //10

Concatenarea șirurilor

Funcția concat() vă permite să concatenați 2 șiruri de caractere:

Var hello1 = "Bună ziua"; var world1 = „Vasya”; hello1 = hello1.concat(world1); document.write(bună ziua); //Bună Vasya

Înlocuirea subșirurilor

Funcția înlocuire() vă permite să înlocuiți un subșir cu altul:

Var hello1 = „Bună ziua”; hello1 = hello1.replace("zi", "seara"); document.write(hello1); //Bună seara

Primul argument al funcției indică ce subșir trebuie înlocuit, iar al 2-lea argument indică cu ce subșir trebuie înlocuit.

Împărțirea unui șir într-o matrice

Funcția split() vă permite să împărțiți un șir într-o matrice de subșiruri folosind un delimitator specific. Puteți folosi un șir care este transmis metodei:

Var mes = „Vremea a fost frumoasă astăzi”; var stringArr = mes.split(" "); for(var str1 în stringArr) document.write(stringArr + "
");

Comparație de șiruri

De asemenea, atunci când comparați șiruri, ar trebui să țineți cont de cazul literelor. Litera mare este mai mică decât litera mică, iar litera e se află în afara alfabetului în general.

SARCINI

Schimbarea majusculei ultimei litere dintr-un șir

Scrieți o funcție lastLetterStr(str) care va schimba majusculele ultimei litere, făcând-o majusculă.

Verificare spam

Scrieți o funcție provSpam(str) care va verifica un șir pentru prezența subșirurilor: „spam”, „sex”, „xxx”. Și returnează true dacă există date subșir și false în caz contrar.

Găsiți numărul

Scrieți o funcție extrNum(str) care obține un număr dintr-un șir dacă șirul conține un număr și funcția număr ar trebui să revină. De exemplu, există o linie „120 UAH” care trebuie returnată de la linia 120.

Și pentru a consolida acest lucru, vizionați videoclipul despre lucrul cu șiruri în JavaScript.

Un șir este o secvență de unul sau mai multe caractere care poate conține litere, cifre și alte simboluri. În JavaScript, este cel mai simplu tip de date imuabil.

Șirurile vă permit să afișați și să manipulați text, iar textul este modalitatea principală de a comunica și transmite informații pe web. Prin urmare, șirurile sunt unul dintre conceptele principale ale programării.

Acest tutorial vă va învăța cum să creați și să vizualizați ieșirea șirurilor, să concatenați șirurile și să le stocați în variabile. Veți afla, de asemenea, despre regulile de utilizare a ghilimelelor, apostrofelor și liniilor noi în JavaScript.

Crearea și vizualizarea unui șir

Există trei moduri de a crea un șir în JavaScript: acestea pot fi scrise între ghilimele simple (‘), ghilimele duble (‘) sau backtick-uri (`). Deși scripturile conțin uneori toate cele trei tipuri de șiruri, doar un singur tip de ghilimele ar trebui să fie folosit într-o singură linie.

Șirurile cu ghilimele simple și duble sunt în esență același lucru. Nu există convenții cu privire la utilizarea unui tip de ghilimele sau altul, dar în general se recomandă utilizarea unui tip în mod consecvent în scripturile programelor.

„Acest șir folosește ghilimele simple.”;
„Acest șir folosește ghilimele duble.”;

Al treilea și cel mai nou mod de a crea un șir se numește literal șablon. Literele șablonului sunt scrise în interiorul ghilimelelor (cunoscute și sub numele de backticks) și funcționează la fel ca șirurile obișnuite, cu câteva caracteristici suplimentare pe care le vom acoperi în acest articol.

`Acest șir folosește backticks.`;

Cel mai simplu mod de a vizualiza rezultatul unui șir este să îl introduceți în consolă folosind console.log().

console.log("Acesta este un șir în consolă.");
Acesta este un șir în consolă.

O altă modalitate simplă de a interoga valoarea unui șir este printr-o fereastră pop-up a browserului, care poate fi invocată folosind alert():

alert("Acesta este un șir într-o alertă.");

Această linie va deschide o fereastră de notificare în browser cu următorul text:

Acesta este un șir dintr-o alertă.

Metoda alert() este folosită mai rar deoarece alertele trebuie să fie închise în mod constant.

Stocarea șirurilor de caractere în variabile

Variabilele din JavaScript sunt denumite containere care stochează valori folosind cuvintele cheie var, const sau let. Șirurile pot fi alocate variabilelor.

const newString = "Acesta este un șir alocat unei variabile.";

Variabila newString conține acum un șir care poate fi referit și afișat folosind consola.

console.log(newString);
Acesta este un șir atribuit unei variabile.

Atribuind șiruri de caractere variabilelor, nu trebuie să tastați din nou șirul de fiecare dată când doriți să-l scoateți, ceea ce face mai ușor să lucrați cu șiruri în cadrul programelor.

Concatenarea șirurilor

Concatenarea șirurilor este procesul de combinare a două sau mai multe șiruri într-un șir nou. Concatenarea se face folosind operatorul +. Simbolul + este și operatorul de adunare în operațiile matematice.

De exemplu, încercați să concatenați două șiruri scurte:

„Marea” + „cal”;
cal de mare

Concatenarea unește sfârșitul unui șir de începutul altui șir fără a introduce spații. Pentru a avea un spațiu între linii, acesta trebuie adăugat la sfârșitul primei linii.

„Marea” + „cal”;
Cal de mare

Concatenarea vă permite să combinați șiruri și variabile cu valori ale șirurilor.

const favePoem = "Poezia mea preferată este " + poem + " de " + autor ".";

Noile șiruri rezultate din concatenare pot fi folosite în program.

Variabile cu literale șablon

Una dintre caracteristicile literalelor șablon este capacitatea de a include expresii și variabile în șir. În loc de concatenare, puteți folosi sintaxa $() pentru a insera o variabilă.

const poem = „Oceanul larg”;
const autor = "Pablo Neruda";
const favePoem = `Poezia mea preferată este $(poemul) de $(autor).`;
Poezia mea preferată este Oceanul larg de Pablo Neruda.

Această sintaxă vă permite să obțineți același rezultat. Literalele de șablon facilitează concatenarea șirurilor.

Literale de șir și valori de șir

După cum probabil ați observat, toate șirurile sunt scrise între ghilimele sau ghilimele, dar atunci când sunt afișate, șirul nu conține ghilimele.

„Dincolo de mare”;
Dincolo de mare

Un șir literal este șirul așa cum apare în codul sursă, inclusiv ghilimele. Valoarea șirului este șirul care apare în rezultat (fără ghilimele).

În acest exemplu, „Beyond the Sea” este un șir literal, iar Beyond the Sea este o valoare șir.

Traversând citate și apostrofe în șiruri

Deoarece ghilimelele sunt folosite pentru a desemna șiruri, există reguli speciale pentru utilizarea apostrofurilor și a ghilimelelor în șiruri. De exemplu, JavaScript va interpreta un apostrof în mijlocul unui șir cu ghilimele simple ca un ghilimele de închidere și va încerca să citească restul șirului dorit ca cod.

Luați în considerare acest exemplu:

const brokenString = „Sunt un șir rupt”;
console.log(brokenString);
necunoscut: simbol neașteptat (1:24)

Același lucru se întâmplă dacă încercați să utilizați ghilimele duble în interiorul unui șir ghilimele duble. Interpretul nu va observa diferența.

Pentru a evita astfel de erori, puteți utiliza:

• Sintaxă de șiruri diferite.
• Simboluri de evacuare.
• Literal șablon.

Sintaxă alternativă a șirurilor

Cel mai simplu mod de a ocoli această problemă este să utilizați sintaxa opusă celei pe care o utilizați în script. De exemplu, puneți șiruri cu apostrofe între ghilimele duble:

„Folosim în siguranță un apostrof între ghilimele duble”.

Șirurile cu ghilimele pot fi incluse între ghilimele simple:

„Apoi a spus: „Bună, lume!”;

Combinând ghilimele simple și duble, puteți controla afișarea ghilimelelor și apostrofelor în șiruri. Totuși, acest lucru va afecta consistența sintaxei din fișierele de proiect, făcându-le dificil de întreținut.

Caracter de evadare \

Folosind o bară oblică inversă, JavaScript nu va interpreta ghilimele ca ghilimele de închidere.

Combinația \' va fi întotdeauna tratată ca un apostrof și \" ca ghilimele duble, fără excepții.

Acest lucru permite utilizarea apostrofurilor în șiruri cu ghilimele simple și a ghilimelelor în șiruri cu ghilimele duble.

„Folosim în siguranță un apostrof între ghilimele simple.”
„Atunci a spus: „Bună ziua, lume!””;

Această metodă pare puțin dezordonată. Dar este necesar dacă aceeași linie conține atât un apostrof, cât și ghilimele duble.

Literale șablon

Literalele șablonului sunt definite prin ghilimele înapoi, astfel încât atât ghilimelele duble, cât și apostrofele pot fi utilizate în siguranță, fără nicio manipulare suplimentară.

„Folosim în siguranță apostrofe și „ghilimele” într-un literal șablon.”;

Literalele șablonului nu numai că evită erorile atunci când se afișează ghilimele și apostrofele, dar oferă și suport pentru expresii inline și blocuri cu mai multe linii, așa cum se discută în secțiunea următoare.

Linii cu mai multe linii și linie nouă

În unele situații este necesar să se insereze un caracter de nouă linie sau o întrerupere de linie. Caracterele de escape \n sau \r vor ajuta la inserarea unei noi linii în rezultatul codului.

const threeLines = "Acesta este un șir\ncare se întinde pe\ntrei linii.";
Acesta este un șir
care se întinde peste tot
trei rânduri.

Aceasta va împărți ieșirea în mai multe linii. Cu toate acestea, dacă există rânduri lungi în cod, vor fi dificil de lucrat și de citit. Pentru a afișa un șir pe mai multe linii, utilizați operatorul de concatenare.

const threeLines = „Acesta este un șir\n” +
„care se întinde peste\n” +
„trei rânduri.”;

De asemenea, puteți evada dintr-o linie nouă folosind caracterul de escape \.

const threeLines = „Acesta este un șir\n\
care se întinde peste\n\
trei rânduri.”;

Nota: Această metodă nu este recomandată deoarece poate cauza probleme în unele browsere.

Pentru a face codul ușor de citit, utilizați literale șablon. Acest lucru elimină concatenarea și caracterele de evacuare.

const threeLines = `Acesta este un șir
care se întinde peste tot
trei rânduri.`;
Acesta este un șir
care se întinde peste tot
trei rânduri.

Deoarece bazele de cod diferite pot utiliza standarde diferite, este important să cunoașteți toate modalitățile de a întrerupe o linie nouă și de a crea șiruri de mai multe linii.

Concluzie

Acum cunoașteți principiile de bază ale lucrului cu șiruri în JavaScript, puteți crea șiruri și literale șablon, puteți efectua concatenare și traversare și puteți atribui șiruri variabilelor.

Când scriu în javascript, de multe ori trebuie să apelez la motoarele de căutare pentru a clarifica sintaxa metodelor (și ordinea, definirea argumentelor) care funcționează cu șiruri.

În acest articol voi încerca să dau exemple și descrieri ale celor mai comune metode javascript legate de șiruri. Cele mai populare metode sunt situate în partea de sus a articolului pentru comoditate.

Convertiți în șir

Puteți converti un număr, un boolean sau un obiect într-un șir.

Var myNumber = 24; // 24 var myString = myNumber.toString(); // "24"

De asemenea, puteți efectua o manipulare similară folosind funcția string().

Var myNumber = 24; // 24 var myString = String(myNumber); // "24"

Nicholas Zakas spune: „Dacă nu ești sigur de valoare (nulă sau nedefinită), atunci folosește funcția String(), deoarece returnează un șir indiferent de tipul variabilei.”

nedefinitînseamnă că variabilei nu i se atribuie nicio valoare, a nul, - că i se atribuie o valoare goală (putem spune că null este definit ca un obiect gol).

Împărțiți un șir în subșiruri

Pentru a împărți un șir într-o matrice de subșiruri puteți folosi metoda split():

Var myString = "se desparte,la,virgulele";

După cum sugerează ultima linie, valoarea celui de-al doilea argument opțional determină numărul de elemente din tabloul returnat.

Obțineți lungimea șirului

Folosind proprietatea length, puteți găsi numărul de caractere Unicode dintr-un șir:

Var myString = „Ești un personaj”; var stringLength = myString.length; // 25

Definiți un subșir într-un șir

Există două moduri de a-ți realiza planul:

Utilizați indexOf() :

Var stringOne = "Johnny Waldo Harrison Waldo";

var wheresWaldo = stringOne.indexOf("Waldo"); // 7

Metoda indexOf() caută un subșir (primul argument transmis) într-un șir (de la începutul șirului) și returnează poziția primului caracter de la care subșirul a început să apară în șir.

Utilizați lastIndexOf() :

Var stringOne = "Johnny Waldo Harrison Waldo";

var wheresWaldo = stringOne.lastIndexOf("Waldo"); // 22

Metoda lastIndexOf() face totul la fel, cu excepția faptului că caută ultimul subșir care apare în șir.

Dacă subșirul nu este găsit, ambele metode returnează -1. Al doilea argument opțional specifică poziția din șir în care doriți să începeți căutarea. Deci, dacă al doilea argument al metodei indexOf() este 5, atunci căutarea va începe de la al 5-lea caracter, iar caracterele 0-4 vor fi ignorate. Pentru lastIndexOf() , de asemenea, dacă al doilea argument este 5, căutarea va începe în direcția opusă, cu caracterele 6 și mai sus fiind ignorate.

Cum să înlocuiți o parte dintr-un șir

Pentru a înlocui o parte (sau chiar tot) dintr-un șir, utilizați metoda înlocuire().

Var slugger = "Josh Hamilton";

var betterSlugger = slugger.replace("h Hamilton", "e Bautista");

console.log(betterSlugger); // „Jose Bautista”

Primul argument conține partea din subșir care urmează să fie înlocuită; al doilea argument este șirul care va lua locul subșirului care este înlocuit. Doar prima instanță a subșirului va fi înlocuită.

Pentru a înlocui toate aparițiile unui subșir, utilizați o expresie regulată cu indicatorul „g”.

Var myString = „Ea vinde carcase pentru automobile pe malul auto”;

var newString = myString.replace(/automotive/g, "sea");

Alternativ, puteți utiliza metoda charCodeAt(), dar în loc de caracterul în sine, veți primi codul acestuia.

Var myString = "Păsări de pene";

var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"

Rețineți că codul pentru o literă mare (poziția 11) este diferit de codul pentru aceeași literă în minuscule (poziția 7).

Concatenarea șirurilor în javascript

În cea mai mare parte, veți folosi operatorul (+) pentru a concatena șiruri. Dar puteți, de asemenea, să concatenați șiruri folosind metoda concat().

Var stringOne = "fotbal Knibb High";

var stringTwo = stringOne.concat("reguli."); // „Reguli de fotbal Knibb High”

Mai multe șiruri pot fi trecute la concat(), iar șirul rezultat va apărea în ordinea în care au fost adăugate la metoda concat().

Var stringOne = "Knibb";

var stringTwo = "Ridicat";

var stringThree = "fotbal";

var stringFour = "reguli.";

var finalString = stringOne.concat(stringTwo, stringThree, stringFour);

console.log(finalString); // „Reguli înalte de fotbal Knibb”.

Parte dintr-un șir (extrage subșirul în javascript)

Există trei moduri diferite de a crea un șir nou „trăgând” o parte dintr-un subșir dintr-un șir existent.

Folosind slice() :

Var stringOne = "abcdefghijklmnopqrstuvwxyz";

var stringTwo = stringOne.slice(5, 10); // "fghij"

Var stringOne = „Vorbește, nu te aud.”; var stringTwo = stringOne.toLocaleUpperCase(); // „VORBEȘTE, NU TE AUD” var stringThree = stringOne.toUpperCase(); // „VORBIȚI, NU TE AUD”

Și două pentru a converti șirul în minuscule:

Var stringOne = „NU TREBUIE să țipi”; var stringTwo = stringOne.toLocaleLowerCase(); // „nu trebuie să țipi” var stringThree = stringOne.toLowerCase(); // „nu trebuie să țipi”

În general, nu există nicio diferență între o metodă locală și o metodă non-locale, dar „pentru unele limbi, cum ar fi turca, a căror majusculă nu urmează cazul Unicode stabilit, consecințele utilizării unei metode non-locale pot fi diferit." Prin urmare, urmați următoarea regulă: „dacă nu cunoașteți limba în care va rula codul, este mai sigur să utilizați metode locale”.

Potrivirea modelului în javascript

Puteți verifica prezența unui model într-un șir folosind 2 metode.

Metoda match() este apelată pe un obiect șir, trecând o expresie regulată ca argument la metoda match().

Var myString = "Cât lemn ar putea mandrina de lemne";

var myPattern = /.ood/;

var myResult = myString.match(myPattern); // ["wood"] var patternLocation = myResult.index; // 9 var originalString = myResult.input // „Cât lemn ar putea să mandră o mandrina de lemn”

Și metoda exec() este apelată pe obiectul RegExp, trecând șirul ca argument:

Var myString = "Cât lemn ar putea mandrina de lemne";

var myPattern = /.huck/;

var myResult = myPattern.exec(myString); // ["chuck"] var modelLocation = myResult.index; // 27 var originalString = myResult.input // „Cât lemn ar putea să mandră o mandrina de lemn”

Ambele metode returnează prima apariție potrivită. Dacă nu se găsesc potriviri, va fi returnat NULL. Dacă expresia regulată are indicatorul „g”, rezultatul va fi o matrice care conține toate potrivirile.

De asemenea, puteți utiliza metoda search(), care ia o expresie regulată ca argument și returnează poziția de pornire a primului model potrivit.

MyString = „pui”; var myStringTwo = "ou"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (cu excepția Chrome, care returnează -2) whichCameFirst = myString.localeCompare("pui"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome returnează 2)

După cum se arată mai sus, o valoare negativă va fi returnată dacă șirul original este sortat înainte de argumentul șir dacă argumentul șir este sortat după șirul original, este returnat +1. Dacă se returnează null, cele două șiruri de caractere sunt echivalente.