Acest articol se bazează pe Free Code Camp Basic Algorithm ScriptingTitlu Caz o frază”.

În acest algoritm, vrem să schimbăm un șir de text, astfel încât acesta să aibă întotdeauna o literă mare la începutul fiecărui cuvânt.

În acest articol, voi explica trei abordări. Mai întâi cu o buclă FOR, al doilea folosind metoda map () și al treilea folosind metoda replace ().

Algorithm Challenge

Întoarceți șirul furnizat cu prima literă a fiecărui cuvânt cu majuscule. Asigurați-vă că restul cuvântului este cu litere mici.

În scopul acestui exercițiu, ar trebui să scrieți cu majusculă cuvinte de legătură precum „cel” și „al”.

Cazuri de test furnizate

  • titleCase („Sunt un ceainic mic”) ar trebui să returneze un șir.
  • titleCase („Sunt un ceainic mic”) ar trebui să returneze „Sunt un mic ceainic”.
  • titleCase („sHoRt Și sToUt”) ar trebui să returneze „Short And Stout”.
  • titleCase („AICI ESTE MÂNECUL MEU AICI ESTE SPOUTUL MEU”) ar trebui să returneze „Aici este mânerul meu Aici este gura mea”.

1. Titlul caz o frază cu buclă FOR

Pentru această soluție, vom folosi metoda String.prototype.toLowerCase (), metoda String.prototype.split (), metoda String.prototype.charAt (), metoda String.prototype.slice () și Array. metoda prototype.join ().

  • toLowerCase () metoda returnează valoarea șirului de apel convertit în minuscule
  • Despică() metoda împarte un obiect String într-o matrice de șiruri prin separarea șirului în șiruri de caractere.
  • charAt () metoda returnează caracterul specificat dintr-un șir.
  • felie() metoda extrage o secțiune dintr-un șir și returnează un șir nou.
  • a te alatura() metoda unește toate elementele unui tablou într-un șir.

Va trebui să adăugăm un spațiu gol între paranteze Despică()metodă,

ad-banner
var strSplit = "I'm a little tea pot".split(' ');

care va genera o serie de cuvinte separate:

var strSplit = ["I'm", "a", "little", "tea", "pot"];

Dacă nu adăugați spațiul din paranteză, veți avea această ieșire:

var strSplit = ["I", "'", "m", " ", "a", " ", "l", "i", "t", "t", "l", "e", " ", "t", "e", "a", " ", "p", "o", "t"];

Vom concatena

str[i].charAt(0).toUpperCase()

– care va majuscula caracterul index 0 al șirului curent în bucla FOR –

și

str[i].slice(1)

– care va extrage din indexul 1 până la sfârșitul șirului.

Vom seta întregul șir cu litere mici pentru scopuri de normalizare.

Cu comentarii:


function titleCase(str) {
  // Step 1. Lowercase the string
  str = str.toLowerCase();
  // str = "I'm a little tea pot".toLowerCase();
  // str = "i'm a little tea pot";
  
  // Step 2. Split the string into an array of strings
  str = str.split(' ');
  // str = "i'm a little tea pot".split(' ');
  // str = ["i'm", "a", "little", "tea", "pot"];
  
  // Step 3. Create the FOR loop
  for (var i = 0; i < str.length; i++) {
    str[i] = str[i].charAt(0).toUpperCase() + str[i].slice(1); 
  /* Here str.length = 5
    1st iteration: str[0] = str[0].charAt(0).toUpperCase() + str[0].slice(1);
                   str[0] = "i'm".charAt(0).toUpperCase()  + "i'm".slice(1);
                   str[0] = "I"                            + "'m";
                   str[0] = "I'm";
    2nd iteration: str[1] = str[1].charAt(0).toUpperCase() + str[1].slice(1);
                   str[1] = "a".charAt(0).toUpperCase()    + "a".slice(1);
                   str[1] = "A"                            + "";
                   str[1] = "A";
    3rd iteration: str[2] = str[2].charAt(0).toUpperCase()   + str[2].slice(1);
                   str[2] = "little".charAt(0).toUpperCase() + "little".slice(1);
                   str[2] = "L"                              + "ittle";
                   str[2] = "Little";
    4th iteration: str[3] = str[3].charAt(0).toUpperCase() + str[3].slice(1);
                   str[3] = "tea".charAt(0).toUpperCase()  + "tea".slice(1);
                   str[3] = "T"                            + "ea";
                   str[3] = "Tea";
    5th iteration: str[4] = str[4].charAt(0).toUpperCase() + str[4].slice(1);
                   str[4] = "pot".charAt(0).toUpperCase() + "pot".slice(1);
                   str[4] = "P"                           + "ot";
                   str[4] = "Pot";                                                         
    End of the FOR Loop*/
  }
  
  // Step 4. Return the output
  return str.join(' '); // ["I'm", "A", "Little", "Tea", "Pot"].join(' ') => "I'm A Little Tea Pot"
}

titleCase("I'm a little tea pot");

Fara comentarii:

function titleCase(str) {
  str = str.toLowerCase().split(' ');
  for (var i = 0; i < str.length; i++) {
    str[i] = str[i].charAt(0).toUpperCase() + str[i].slice(1); 
  }
  return str.join(' ');
}
titleCase("I'm a little tea pot");

2. Titlul Caz o frază cu metoda map ()

Pentru această soluție, vom folosi metoda Array.prototype.map ().

  • Hartă() metoda creează o nouă matrice cu rezultatele apelării unei funcții furnizate pe fiecare element din această matrice. Utilizarea hărții va apela o funcție de apelare furnizată o dată pentru fiecare element dintr-o matrice, în ordine și va construi o nouă matrice din rezultate.

Vom micșora și vom împărți șirul așa cum se vede în exemplul anterior înainte de a aplica metoda map ().

În loc să folosim o buclă FOR, vom aplica metoda map () ca condiție pe aceeași concatenare din exemplul anterior.

(word.charAt(0).toUpperCase() + word.slice(1));

Cu comentarii:


function titleCase(str) {
  // Step 1. Lowercase the string
  str = str.toLowerCase() // str = "i'm a little tea pot";
  
  // Step 2. Split the string into an array of strings
           .split(' ') // str = ["i'm", "a", "little", "tea", "pot"];
         
  // Step 3. Map over the array
           .map(function(word) {
    return (word.charAt(0).toUpperCase() + word.slice(1));
    /* Map process
    1st word: "i'm"    => (word.charAt(0).toUpperCase() + word.slice(1));
                          "i'm".charAt(0).toUpperCase() + "i'm".slice(1);
                                "I"                     +     "'m";
                          return "I'm";
    2nd word: "a"      => (word.charAt(0).toUpperCase() + word.slice(1));
                          "a".charAt(0).toUpperCase()   + "".slice(1);
                                "A"                     +     "";
                          return "A";
    3rd word: "little" => (word.charAt(0).toUpperCase()    + word.slice(1));
                          "little".charAt(0).toUpperCase() + "little".slice(1);
                                "L"                        +     "ittle";
                          return "Little";
    4th word: "tea"    => (word.charAt(0).toUpperCase() + word.slice(1));
                          "tea".charAt(0).toUpperCase() + "tea".slice(1);
                                "T"                     +     "ea";
                          return "Tea";
    5th word: "pot"    => (word.charAt(0).toUpperCase() + word.slice(1));
                          "pot".charAt(0).toUpperCase() + "pot".slice(1);
                                "P"                     +     "ot";
                          return "Pot";                                                        
    End of the map() method */
});

 // Step 4. Return the output
 return str.join(' '); // ["I'm", "A", "Little", "Tea", "Pot"].join(' ') => "I'm A Little Tea Pot"
}

titleCase("I'm a little tea pot");

Fara comentarii:

function titleCase(str) {
  return str.toLowerCase().split(' ').map(function(word) {
    return (word.charAt(0).toUpperCase() + word.slice(1));
  }).join(' ');
}
titleCase("I'm a little tea pot");

3. Titlul Caz o frază Cu metodele map () și substitut ()

Pentru această soluție, vom continua să folosim metoda Array.prototype.map () și vom adăuga metoda String.prototype.replace ().

  • a inlocui() metoda returnează un șir nou cu unele sau toate potrivirile unui model înlocuit cu un înlocuitor.

În cazul nostru, modelul pentru metoda replace () va fi un șir care va fi înlocuit cu un nou înlocuitor și va fi tratat ca un șir textual. Putem folosi și un expresie uzuala ca model pentru rezolvarea acestui algoritm.

Vom micșora și împărți șirul așa cum se vede în primul exemplu înainte de a aplica metoda map ().

Cu comentarii:


function titleCase(str) {
  // Step 1. Lowercase the string
  str = str.toLowerCase() // str = "i'm a little tea pot";
  
  // Step 2. Split the string into an array of strings
           .split(' ') // str = ["i'm", "a", "little", "tea", "pot"];
         
  // Step 3. Map over the array
           .map(function(word) {
    return word.replace(word[0], word[0].toUpperCase());
    /* Map process
    1st word: "i'm" => word.replace(word[0], word[0].toUpperCase());
                       "i'm".replace("i", "I");
                       return word => "I'm"
    2nd word: "a" => word.replace(word[0], word[0].toUpperCase());
                     "a".replace("a", "A");
                      return word => "A"
    3rd word: "little" => word.replace(word[0], word[0].toUpperCase());
                          "little".replace("l", "L");
                          return word => "Little"
    4th word: "tea" => word.replace(word[0], word[0].toUpperCase());
                       "tea".replace("t", "T");
                       return word => "Tea"
    5th word: "pot" => word.replace(word[0], word[0].toUpperCase());
                       "pot".replace("p", "P");
                       return word => "Pot"                                                        
    End of the map() method */
});

 // Step 4. Return the output
 return str.join(' '); // ["I'm", "A", "Little", "Tea", "Pot"].join(' ') => "I'm A Little Tea Pot"
}

titleCase("I'm a little tea pot");

Fara comentarii:

function titleCase(str) {
  return str.toLowerCase().split(' ').map(function(word) {
    return word.replace(word[0], word[0].toUpperCase());
  }).join(' ');
}
titleCase("I'm a little tea pot");

Sper că ți s-a părut de ajutor. Aceasta face parte din seria mea de articole „How to Solve FCC Algorithms” despre Provocările Algoritmului Taberei Codului Liber, unde propun mai multe soluții și explic pas cu pas ce se întâmplă sub capotă.

Trei moduri de a repeta un șir în JavaScript
În acest articol, vă voi explica cum să rezolvați provocarea Routech „Repetează un șir repetă un șir”. Aceasta implică…

Două modalități de a confirma sfârșitul unui șir în JavaScript
În acest articol, vă voi explica cum să rezolvați provocarea „Confirmă sfârșitul” Routech.

Trei moduri de a inversa un șir în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Reverse a String”

Trei moduri de a factorializa un număr în JavaScript
Acest articol se bazează pe algoritmul de bază Free Code Camp Scripting „Factorializați un număr”

Două moduri de a verifica palindromii în JavaScript
Acest articol se bazează pe Free Code Camp Basic Algorithm Scripting „Verificați dacă există palindromuri”.

Trei moduri de a găsi cel mai lung cuvânt într-un șir în JavaScript
Acest articol se bazează pe algoritmul de bază Free Code Camp Scripting „Găsiți cel mai lung cuvânt într-un șir”.

Trei moduri în care puteți găsi cel mai mare număr dintr-o matrice folosind JavaScript
În acest articol, vă voi explica cum să rezolvați provocarea „Returnează cele mai mari numere din matrice” din Free Code Camp. Acest…

Dacă aveți propria soluție sau sugestii, împărtășiți-le mai jos în comentarii.

Sau poți să mă urmărești mai departe Mediu, Stare de nervozitate, Github și LinkedIn.

# StayCurious, # KeepOnHacking & # MakeItHappen!

Resurse