25 – metodi per stringhe

Vediamo ora una rassegna dei principali metodi per  le stringhe, ovviamente per approfondimenti vedere la documentazione.

Una particolarità: tutti i metodi non andranno mai a modificare il valore originale della stringa, ma restituiranno una copia modificata della stessa.

Mi creo il br e la funzione writeIn per non ripetere ogni volta il codice

var br = "<br>";

function writeln(messaggio) {
    document.write(messaggio + br);
}

var image = prompt("Inserire il nome di una immagine");
if (image.endsWith(".png")) {
 writeln("Immagini png non supportate");
}

endsWith (stringa) verifica se una stringa termina per la stringa passata come parametro. La funzione prompt è come un alert con l’input

if (image.includes("sex")) {
    writeln("Immagine probabilmente non appropriata ...");
}

includes(stringa[,posizione]) verifica se la stringa contiene la stringa parametro (sex). Restituisce true o false.

Opzionale la posizione:

var CF = "RSSMRT71R71D150H";
if (CF.includes("71", 9)) {
    writeln("Femmina, nata il 31 del mese di ");
}

contiene il 71 a partire dalla posizione 9 della stringa del codice fiscale

var bitString = "1001010001110011";
if (bitString.indexOf("111", 8) > -1) {
    writeln("Dato corrotto");
}

indexOf: posizione di una stringa a partire da una certa posizione

writeln("Il primo bit a zero è in posizione " + bitString.indexOf("0"));

senza posizione di partenza la ricerca inizia da 0

writeln("Ultima coppia di bit a 1 alla posizione"
    + bitString.lastIndexOf("11"));

lastIndexOf come indexOf ma guarda per l’ultima occorrenza, nella variabile bitString = “1001010001110011”  l’ultimo parametro 11 è alla posizione 14

writeln("101 trovato alla posizione "
 + bitString.lastIndexOf("101", 7));

fermandosi ad una certa posizione se indicata. Cerca il 101 ma fino alla posizione 7. Il risultato è posizione 3

//padEnd(lunghezza, stringa)  se stringa viene omessa si  usa lo spazio
bitString = "".padEnd(16, "01"); //01010101...
writeln(bitString);

padEnd : estende la stringa fino  fino a raggiungere una massima lunghezza indicata nel primo parametro, di un valore riempitivo passato come secondo

for (var i = 1; i <= 100; i++) {
    writeln((i + "").padEnd(3, "-"));
}

a
in questo esempio padEnd stampa di numeri a larghezza fissa con segnaposti, allunga fino a 3 cifre i numeri
1–
2–
10-
100

In maniera analoga il padStart , il riempitivo (lo zero) lo mette prima

for (var i = 1; i <= 100; i++) {
    writeln((i + "").padStart(3, "0"));
}

001

002

010

100

bitString = "0".repeat(32);
writeln(bitString); //32 bit a zero

Il repeat restituisce una stringa ripetendo n volte (32) quella di partenza

//replace(la_stringa, con_questa) SOLO LA PRIMA TROVATA

var s = "Tutto quel che e' stato e' stato e quel che non e' a volte e'";
s = s.replace("e'", "è");
writeln(s); //solo la prima viene rimpiazzata..

replace sostituisce la stringa indicata come primo parametro ( e’ ) con quella indicata come secondo. Verra cambiata solo la prima occorrenza trovata e non tutte.

Per farlo su tutto bisogna usare le espressioni regolari

/replace(espressione regolare, con_questa) MOLTO PIU' FLESSIBILE
//NB: case sensitive
s = s.replace(/e'/g, "è"); //espressione regolare, g=global=tutte
writeln(s);

Una possibilità di usare le regexp è quella di racchiudere l’espressione tra una coppia di forward slash . La g è il modificatore sull’azione del comando e sta per global , ovvero cerca in tutta la astringa

//search(espressione_regolare)  posizione della prima occorrenza o -1
s = "Tutto quel che è stato è stato e quel che non è a volte è";
writeln("Ho trovato 'stato' alla posizione " + s.search("stato")); //17

search cerca la posizione della prima stringa passata come argomento

CF = "RSSMRT71R71D150H";
writeln("Caratteri nominativo: " + CF.slice(0, 6));

slice (inizio, fine) estrae una porzione di stringa

s = "Tutto quel che è stato è stato e quel che non è a volte è"
var risultato = s.split(" "); //risultato è un array non un singolo valore
for (var i = 0; i < risultato.length; i++) {
    writeln(risultato[i]);
}  //parole separate

split (separatore, limite) RESTITUISCE UN ARRAY!,  per avere tutte le parole uso un ciclo for che come contatore usa l’indice [i] dell’array generato (risultato) e stampa per la lunghezza dell’array (risultato.lenght)

risultato = s.split(" ", 4); //max 4 porzioni nel risultato
for (var i = 0; i < risultato.length; i++) {
    writeln(risultato[i]);
}  //parole separate

posso anche limitare il numero di spezzoni di stringa che vengono restituiti, indicandolo come secondo parametro (4).

Di seguito alcuni esempi di split con i commenti nel codice

risultato = s.split(""); //risultato è un array non un singolo valore
for (var i = 0; i < risultato.length; i++) {
    writeln(risultato[i]);
}  //tutti i singoli caratteri

risultato = s.split("è"); //risultato è un array non un singolo valore
for (var i = 0; i < risultato.length; i++) {
    writeln(risultato[i]);
}  //porzioni di stringa tra le è

risultato = s.split("stato"); //il separatore può essere una intera stringa
for (var i = 0; i < risultato.length; i++) {
    writeln(risultato[i]);
}

avevamo visto EndWith, ecco il simmetrico

//startsWith(stringa, posizione)
CF = "FRRMRT71R71D150H";
if (CF.startsWith("FRR")) {
    writeln("E' un Ferrari");
}

startWith, inizia con FRR, nel codice fiscale, vuol dire che il cognome è Ferrari

s = "   sono una stringa davvero spaziosa          ";
alert("#" + s.trim() + "#");

trim rimuove gli spazi all’inizio e alla fine di una stringa

alert("#" + s.trimLeft() + "#");

trimLeft rimuove gli spazi solo all’inizio

alert("#" + s.trimRight() + "#");

trimRight rimuove gli spazi solo alla fine