Când scrii JavaScript, de foarte multe ori trebuie să navigați pe Internet în căutarea informațiilor despre sintaxa și parametrii pentru metodele care funcționează cu șiruri.
Am citit o mulțime de articole despre lucrul cu șiruri. Această postare va prezenta exemple și scurte descrieri ale celor mai comune metode de lucru cu șiruri. Am încercat să pun cele mai comune metode în partea de sus pentru o referință rapidă.
Desigur, cei mai mulți dezvoltatori experimentați vor fi deja destul de familiarizați cu multe dintre tehnici, dar cred că aceasta este o listă bună pentru începători pentru a înțelege gama de tehnici care pot ajuta la realizarea operațiunilor complexe cu mijloace simple.
Convertirea în șir
Puteți converti un număr, o expresie booleană sau un obiect într-un șir:
Var myNumber = 24; // 24 var myString = myNumber.toString(); // "24"
Puteți face în același mod cu Şir():
Var myNumber = 24; // 24 var myString = String(myNumber); // "24"
Dacă nu sunteți sigur care nu este valoarea nul sau nedefinit, poți să folosești Şir(), care returnează întotdeauna un șir, indiferent de tipul valorii.
Împărțirea unui șir în subșiruri
Pentru a împărți șirurile într-o matrice de subșiruri puteți folosi metoda Despică():
Var myString = "se desparte,la,virgulele"; var substringArray = myString.split(","); // ["coming", "apart", "la", "the", "commas"] var arrayLimited = myString.split(",", 3); // ["vine", "desparte", "la"]
După cum puteți vedea în ultima linie, al doilea parametru al funcției este limita numărului de elemente care vor fi în tabloul final.
Obținerea lungimii unui șir
Pentru a afla câte caractere există într-un șir, folosim proprietatea lungime:
Var myString = „Ești un personaj”; var stringLength = myString.length; // 25
Găsirea unui subșir într-un șir
Există două metode de a căuta un subșir:
Utilizare Index de():
Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.indexOf("Waldo"); // 7
Index de() Metoda începe căutarea unui subșir de la începutul șirului și returnează poziția începutului primei apariții a subșirului. În acest caz - poziția a 7-a.
Utilizare lastIndexOf():
Var stringOne = "Johnny Waldo Harrison Waldo"; var wheresWaldo = stringOne.lastIndexOf("Waldo"); // 22
Metoda returnează poziția de pornire a ultimei apariții a unui subșir dintr-un șir.
Ambele metode returnează -1 dacă subșirul nu este găsit și ambele iau un al doilea argument opțional care indică poziția în șir în care doriți să înceapă căutarea. Deci, dacă al doilea argument este „5”, Index de()începe căutarea de la caracterul 5, ignorând caracterele 0-4, în timp ce lastIndexOf()începe căutarea de la caracterul 5 și lucrează înapoi, ignorând caracterele 6 și mai departe.
Înlocuirea subșirurilor
Pentru a înlocui o apariție a unui subșir într-un șir cu un alt subșir, puteți utiliza a inlocui():
Var slugger = "Josh Hamilton"; var betterSlugger = slugger.replace("h Hamilton", "e Bautista"); console.log(betterSlugger); // „Jose Bautista”
Primul argument este ceea ce doriți să înlocuiți, iar al doilea argument este linia nouă. Funcția înlocuiește doar prima apariție a unui subșir dintr-un șir.
Pentru a înlocui toate aparițiile, trebuie să utilizați o expresie regulată cu un steag global:
Var myString = „Ea vinde carcase pentru automobile pe malul auto”; var newString = myString.replace(/automotive/g, "sea"); console.log(newString); // „Ea vinde scoici pe malul mării”
Al doilea argument poate include un șablon sau o funcție specială. Puteți citi mai multe.
Obțineți un caracter într-o poziție dată într-un șir
Putem obține simbolul folosind funcția charAt():
Var myString = "Păsări de pene"; var whatsAtSeven = myString.charAt(7); // "f"
Așa cum este adesea cazul în JavaScript, prima poziție din șir începe la 0, nu la 1.
Ca o funcție alternativă, puteți utiliza charCodeAt() funcția, care este codul caracterului.
Var myString = "Păsări de pene"; var whatsAtSeven = myString.charCodeAt(7); // "102" var whatsAtEleven = myString.charCodeAt(11); // "70"
Rețineți că codul caracterului „F” (poziția 11) este diferit de caracterul „f” (poziția 7).
Concatenarea șirurilor
În cele mai multe cazuri, puteți utiliza operatorul „+” pentru a concatena șiruri. Dar puteți folosi și metoda concat():
Var stringOne = "fotbal Knibb High"; var stringTwo = stringOne.concat("reguli."); // „Reguli de fotbal Knibb High”
În acest fel putem combina mai multe rânduri într-una singură, în ordinea în care sunt scrise:
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”.
Extragerea subșirurilor
Există 3 moduri de a obține un șir dintr-o parte a altui șir:
Folosind felie():
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.slice(5, 10); // "fghij"
Folosind subșir ():
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substring(5, 10); // "fghij"
În ambele funcții, primul parametru este caracterul la care începe subșirul (începând de la poziția 0), iar al doilea argument (opțional) este poziția caracterului până la care este returnat subșirul. Exemplul (5, 10) returnează șirul între pozițiile 5 și 9.
Folosind substr():
Var stringOne = "abcdefghijklmnopqrstuvwxyz"; var stringTwo = stringOne.substr(5, 10); // "fghijklmno"
Primul argument este poziția caracterului la care începe noua linie, iar al doilea argument este numărul de caractere din poziția de pornire a noii linii. Acestea. (5, 10) returnează 10 caractere, începând cu poziția 5.
Convertiți un șir în litere mari sau mici.
Există 4 metode de traducere. Primele 2 convertesc șirul în majuscule:
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”
Celelalte 2 convertesc ș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”
Este mai bine să folosiți metode „locale”, pentru că... în diferite locuri, de exemplu, în Turcia, afișarea registrelor nu funcționează chiar așa cum suntem obișnuiți și, prin urmare, rezultatul poate fi cel pe care ne-am dorit. Dacă utilizați metode „locale”, atunci nu vor exista astfel de probleme.
Potrivire de model
Potrivirea modelului pe un șir se poate face folosind 2 metode, care funcționează diferit.
Metodă Meci() este aplicat unui șir și ia o expresie regulată ca parametru:
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”
Metodă exec() aplicat unui obiect cu expresie regulată și ia șirul ca parametru:
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”
În ambele metode, este returnată doar prima potrivire. Dacă nu există potriviri, se întoarce nul.
Puteți folosi și metoda căutare() care ia o expresie regulată și returnează poziția primei potriviri din model:
Var myString = „Presumăm”; var modelLocation = myString.search(/ume/); // 3
Dacă nu ar exista meciuri, " -1 «.
Compararea a două șiruri de caractere pentru sortare
Puteți compara 2 șiruri pentru a determina care este primul în alfabet. Pentru a face acest lucru, vom folosi metoda localeCompare() care returnează 3 valori posibile:
Var myString = "pui"; var myStringTwo = "ou"; var whichCameFirst = myString.localeCompare(myStringTwo); // -1 (Chrome returnează -2) whichCameFirst = myString.localeCompare("pui"); // 0 whichCameFirst = myString.localeCompare("apple"); // 1 (Chrome returnează 2)
După cum se arată mai sus, este returnat un număr negativ dacă argumentul șir vine după șirul original. Un număr pozitiv dacă argumentul șir vine înaintea șirului original. Dacă este returnat 0 - înseamnă că liniile sunt egale.
Pentru a verifica valoarea returnată, este mai bine să utilizați if (rezultat< 0), чем if (result === -1). Последнее не будет работать в Chrome.
Vă mulțumesc pentru atenție, sper că ați învățat o mulțime de lucruri noi și interesante!
Autorul articolului: Alex. Categorie:Data publicării: 19.03.2013
Salutări tuturor celor care au decis să învețe un limbaj orientat spre prototip. Ultima dată ți-am vorbit despre , iar astăzi vom analiza șirurile JavaScript. Deoarece în această limbă toate elementele de text sunt șiruri de caractere (nu există un format separat pentru caractere), puteți ghici că această secțiune ocupă o parte semnificativă în învățarea sintaxei js.
De aceea, în această publicație, vă voi spune cum sunt create elementele șir, ce metode și proprietăți sunt furnizate pentru acestea, cum să convertiți corect șirurile, de exemplu, convertiți într-un număr, cum puteți extrage subșirul dorit și multe altele. În plus, voi atașa exemple de cod de program. Acum să trecem la treabă!
Sintaxă variabilă șir
În limbajul js, toate variabilele sunt declarate folosind cuvântul cheie var, iar apoi, în funcție de formatul parametrilor, se determină tipul variabilei declarate. După cum vă amintiți din JavaScript, nu există o tastare puternică. De aceea există această situație în cod.
La inițializarea variabilelor, valorile pot fi încadrate în ghilimele duble, simple și, începând din 2015, între ghilimele simple. Mai jos am atașat exemple ale fiecărei metode de declarare a șirurilor.
Vreau să acord o atenție deosebită celei de-a treia metode. Are o serie de avantaje.
Cu ajutorul acestuia, puteți efectua cu ușurință o întrerupere de linie și va arăta astfel:
alert(`mai multe
mă transfer
Și a treia metodă vă permite să utilizați construcția $(…). Acest instrument este necesar pentru a introduce interpolare. Nu vă alarmați, acum vă spun despre ce este vorba.
Datorită lui $(…) puteți introduce nu numai valori variabile în șiruri de caractere, ci și efectuați operații aritmetice și logice cu acestea, metode de apelare, funcții etc. Toate acestea se numesc un singur termen - interpolare. Consultați un exemplu de implementare a acestei abordări.
| 1 2 3 | var pen = 3; var creion = 1; alert(`$(pix) + $(creion*5) = $(pix + creion)`); |
var pen = 3; var creion = 1; alert(`$(pix) + $(creion*5) = $(pix + creion)`);
Ca rezultat, expresia „3 + 1*5 = 8” va fi afișată pe ecran.
În ceea ce privește primele două moduri de declarare a șirurilor de caractere, nu există nicio diferență între ele.
Să vorbim puțin despre personaje speciale
Multe limbaje de programare au caractere speciale care ajută la manipularea textului în șiruri. Cel mai faimos dintre ele este ruptura de linie (\n).
Toate instrumentele similare încep inițial cu o bară oblică inversă (\) și sunt urmate de litere ale alfabetului englez.
Mai jos am atașat un mic tabel care listează câteva caractere speciale.
Ne aprovizionăm cu un arsenal greu de metode și proprietăți
Dezvoltatorii limbajului au oferit multe metode și proprietăți pentru a simplifica și optimiza lucrul cu șiruri. Și odată cu lansarea unui nou standard numit ES-2015 anul trecut, această listă a fost completată cu noi instrumente.
Lungime
Voi începe cu cea mai populară proprietate, care vă ajută să aflați lungimea valorilor variabilelor șir. Acest lungime. Se foloseste astfel:
var șir = „Unicorni”;
alert(string.lungime);
Răspunsul va afișa numărul 9. Această proprietate poate fi aplicată și valorilor în sine:
„Unicorni”.lungime;
Rezultatul nu se va schimba.
charAt()
Această metodă vă permite să extrageți un anumit caracter din text. Permiteți-mi să vă reamintesc că numerotarea începe de la zero, așa că pentru a extrage primul caracter dintr-un șir, trebuie să scrieți următoarele comenzi:
var șir = „Unicorni”;
alert(string.charAt(0));.
Totuși, rezultatul rezultat nu va fi un tip de caracter, ci va fi considerat un șir cu o singură literă.
De la toLowerCase() la UpperCase()
Aceste metode controlează cazul caracterelor. Când scrieți codul „Conținut”.
laMajuscule()întregul cuvânt va fi afișat cu majuscule.
Pentru efectul opus, ar trebui să utilizați „Conținut”. toLowerCase().
Index de()
Un instrument popular și necesar pentru căutarea subșirurilor. Ca argument, trebuie să introduceți cuvântul sau expresia pe care doriți să o găsiți, iar metoda returnează poziția elementului găsit. Dacă textul căutat nu a fost găsit, „-1” va fi returnat utilizatorului.
| 1 2 3 4 | var text = "Organizați o căutare de flori!"; alert(text.indexOf("culoare")); //19 alert(text.indexOf(" ")); //12 alert(text.lastIndexOf(" ")); //18 |
var text = "Organizați o căutare de flori!"; alert(text.indexOf("culoare")); //19 alert(text.indexOf(" ")); //12 alert(text.lastIndexOf(" ")); //18
Rețineți că lastIndexOf() face același lucru, doar că caută de la sfârșitul propoziției.
Extragerea subșirurilor
Pentru această acțiune, au fost create trei metode aproximativ identice în js.
Să ne uităm mai întâi la asta subșir (început, sfârșit)Și felie (început, sfârșit). Ei lucrează la fel. Primul argument definește poziția de pornire din care va începe extracția, iar al doilea este responsabil pentru punctul final de oprire. În ambele metode, șirul este extras fără a include caracterul care se află la poziția finală.
var text = "Atmosfera"; alert(text.substring(4)); // va afișa „sphere” alert(text.substring(2, 5)); //afișează alertă „mos” (text.slice(2, 5)); //afișează „mos”
Acum să ne uităm la a treia metodă, care se numește substr(). De asemenea, trebuie să includă 2 argumente: startȘi lungime.
Prima specifică poziția de pornire, iar a doua specifică numărul de caractere care trebuie extrase. Pentru a urmări diferențele dintre aceste trei instrumente, am folosit exemplul anterior.
var text = "Atmosfera";
alert(text.substr(2, 5)); //afișează „mosfe”
Folosind mijloacele enumerate de a lua subșiruri, puteți elimina caracterele inutile din elementele de linie noi cu care programul funcționează apoi.
Răspuns()
Această metodă ajută la înlocuirea caracterelor și subșirurilor din text. Poate fi folosit și pentru a implementa înlocuiri globale, dar pentru a face acest lucru trebuie să includeți expresii regulate.
Acest exemplu va înlocui subșirul numai din primul cuvânt.
var text = "Atmosfera Atmosfera"; var newText = text.replace("Atmo","Strato") alert(newText) // Rezultat: Stratosphere Atmosphere
Și în această implementare software, datorită flagului expresiei obișnuite „g”, va fi efectuată o înlocuire globală.
var text = "Atmosfera Atmosfera"; var newText = text.replace(/Atmo/g,"Strato") alert(newText) // Rezultat: Stratosphere Stratosphere
Să facem conversia
JavaScript oferă doar trei tipuri de conversie a tipului de obiect:
- Numeric;
- Şir;
- boolean.
În publicația actuală voi vorbi despre 2 dintre ele, deoarece cunoștințele despre ele sunt mai necesare pentru lucrul cu șiruri.
Conversie numerică
Pentru a converti în mod explicit valoarea unui element într-o formă numerică, puteți utiliza Număr (valoare).
Există și o expresie mai scurtă: +"999".
var a = Number("999");
Conversie de șiruri
Executat de funcție alerta, precum și un apel explicit șir (text).
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.lungime + " 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 muncii 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ă: " + dupăLen + "
"); //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.
Ultima actualizare: 04/06/2018
Pentru a crea șiruri, putem fie aloca direct un șir unei variabile:
Let name = "Tom";
Obiectul String este proiectat să funcționeze cu șiruri, așa că puteți utiliza și constructorul String:
Nume var = new String ("Tom");
Dar, de regulă, se folosește prima metodă, mai scurtă. În primul caz, JavaScript convertește automat variabila de tip primitiv într-un obiect String, dacă este necesar.
Obiectul String are un set mare de proprietăți și metode cu care putem manipula șiruri.
Proprietatea length indică lungimea șirului:
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)); // Salut salut salut
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(cheie); 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); // Pa
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
Salutări tuturor cititorilor site-ului blog În acest articol ne vom uita la obiectul jscript încorporat – String, care este responsabil pentru procesarea textului.
Clasa internă js String a limbajului de programare al serverului de script oferă metode de manipulare a șirurilor, 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:
| // js Obiect String // length_string.js //************************************* var s1, s2; s1 = „text simplu” ; s2 = new String ("text 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)– Concatenare (unire) s1 și s2.
String.fromCharCode (c1,...,cN)- Generați un șir Unicode. În loc de simboluri, scriem coduri Unicode.
| //************************************* // js obiect String // Formarea unui șir// din CharCode_string.js //************************************* var MyResult; //return salut MyResult = String .fromCharCode (104 , 101 , 108 , 108 , 111 ) ; WScript.Echo(MyResult); |
s.indexOf(substr, startindex)– Această metodă a clasei js String vă permite să căutați subșirul subșirului în șirul s. Parametrul startindex specifică numărul caracterului de la care se începe căutarea dacă acest parametru lipsește, atunci căutarea se efectuează de la început; Procesul în sine are loc de la stânga la dreapta. indexOf returnează un număr - indexul caracterului de la care a fost găsită apariția dacă nu se găsește nimic, atunci va fi returnată valoarea -1. Să nu uităm asta numerotarea caracterelor începe de la zero.
| //************************************* // js Obiect String // Căutare în șir // indexOf_string.js //************************************* var MyStr= „unu, doi, trei și patru”, MyResult; MyResult= MyStr.indexOf(„două”, 2); WScript.Echo(MyResult); |
s.lastIndexOf(substr, startindex)– Similar cu indexOf, dar vom căuta în ordine inversă.
s.match(rgExp)– Această metodă js a clasei String vă permite să căutați s în text folosind expresii regulate (rgExp). Ca rezultat, se va obține o matrice care conține rezultatul. Primul element al matricei este textul găsit, al doilea este subșirul corespunzător primei subexpresii, al treilea este subșirul corespunzător celei de-a doua subexpresii și așa mai departe. De exemplu, ne vom uita la un script care analizează o adresă URL.
| //************************************* // String js // analizează adresele URL// match_string.js //************************************* var url = /(\w+):\/\/([\w.]+)\/(\S*)/ ; var text = „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] + " \n"; ) ) WScript.Echo (lista) ; |
s.slice(start, )– Obțineți o parte din text, parametri startȘi Sfârşit specifică pozițiile de început și, respectiv, de sfârșit și sunt numere întregi.
s.split(str)– Împărțiți textul în subșiruri și scrieți-le ca . Parametrul str specifică un semn simbolic care indică începutul partiției. La ieșire obținem o matrice.
| //************************************* // String js obiect // analizează șiruri în matrice// 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] + " \n"; ) 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 nu modifică valoarea inițială. Parametrii specifică pozițiile caracterelor de început și de sfârșit.