JavaScript
stringhe

Sintassi

• "stringa letterale"
• 'stringa letterale'
• "string letterale con 'virgolette errate'" // nessun errore; le virgolette sono diverse
• "stringa letterale con" virgolette di escape "" // nessun errore; le virgolette sono sfuggite.
• `stringa del modello $ {espressione}`
• String ("ab c") // restituisce una stringa quando viene chiamata nel contesto non di costruzione
• new String ("ab c") // l'oggetto String, non la stringa primitiva

Informazioni di base e concatenazione di stringhe

Le stringhe in JavaScript possono essere racchiuse tra virgolette singole 'hello' , i doppi apici "Hello" e (dal ES2015, ES6) in Template letterali (backticks) `hello` .

var hello  = "Hello";
var world  = 'world';
var helloW = `Hello World`;              // ES2015 / ES6

Le stringhe possono essere create da altri tipi usando la funzione String() .

var intString = String(32); // "32"
var booleanString = String(true); // "true"
var nullString = String(null); // "null" 

Oppure, toString() può essere utilizzato per convertire numeri, booleani o oggetti in stringhe.

var intString = (5232).toString(); // "5232"
var booleanString = (false).toString(); // "false"
var objString = ({}).toString(); // "[object Object]"

Le stringhe possono anche essere create utilizzando il metodo String.fromCharCode .

String.fromCharCode(104,101,108,108,111) //"hello"

La creazione di un oggetto String usando la new parola chiave è consentita, ma non è consigliata in quanto si comporta come gli oggetti a differenza delle stringhe primitive.

var objectString = new String("Yes, I am a String object");
typeof objectString;//"object"
typeof objectString.valueOf();//"string"

Stringhe concatenanti

La concatenazione delle stringhe può essere eseguita con l'operatore di concatenazione + o con il metodo concat() integrato sul prototipo dell'oggetto String.

var foo = "Foo";
var bar = "Bar";
console.log(foo + bar);        // => "FooBar"
console.log(foo + " " + bar);  // => "Foo Bar"

foo.concat(bar)            // => "FooBar"
"a".concat("b", " ", "d")  // => "ab d"

Le stringhe possono essere concatenate con variabili non stringa, ma convertiranno le variabili non stringa in stringhe.

var string = "string";
var number = 32;
var boolean = true;

console.log(string + number + boolean); // "string32true"

Modelli di stringa

var greeting = `Hello`;

var place = `World`;
var greet = `Hello ${place}!`

console.log(greet); // "Hello World!"

`a\\b` // =  a\b
String.raw`a\\b` // = a\\b

Citazione di fuga

Se la tua stringa è racchiusa tra le virgolette singole (es.) Devi sfuggire alla citazione letterale interiore con la barra rovesciata \

var text = 'L\'albero means tree in Italian';
console.log( text ); \\ "L'albero means tree in Italian"

Lo stesso vale per le virgolette:

var text = "I feel \"high\"";

Un'attenzione particolare deve essere data alle citazioni di escape se si memorizzano rappresentazioni HTML all'interno di una stringa, poiché le stringhe HTML fanno ampio uso di quotazioni, ad esempio negli attributi:

var content = "<p class=\"special\">Hello World!</p>";        // valid String
var hello   = '<p class="special">I\'d like to say "Hi"</p>'; // valid String

Le virgolette in stringhe HTML possono anche essere rappresentate usando ' (o ' ) come singola citazione e " (o " ) come doppi apici.

var hi    = "<p class='special'>I'd like to say &quot;Hi&quot;</p>"; // valid String
var hello = '<p class="special">I&apos;d like to say "Hi"</p>';      // valid String

Nota: l'uso di ' e " non sovrascriverà le virgolette che i browser possono posizionare automaticamente sulle virgolette degli attributi. Ad esempio <p class=special> fatto in <p class="special"> , usando " può portare a <p class=""special""> dove \" sarà <p class="special"> .

var x = `"Escaping " and ' can become very annoying`;

Stringa inversa

Il modo più "popolare" di invertire una stringa in JavaScript è il seguente frammento di codice, che è abbastanza comune:

function reverseString(str) {
    return str.split('').reverse().join('');
}

reverseString('string');    // "gnirts"

Tuttavia, funzionerà solo fino a quando la stringa invertita non contiene coppie sostitutive. I simboli astrali, cioè i caratteri al di fuori del piano multilingue di base, possono essere rappresentati da due unità di codice e porteranno questa tecnica ingenua a produrre risultati errati. Inoltre, i personaggi con segni combinati (ad es. Diaeresi) appariranno sul logico carattere "successivo" invece di quello originale con cui è stato combinato.

'𝌆■.'.split('').reverse().join(''); //fails

Mentre il metodo funzionerà bene per la maggior parte delle lingue, un algoritmo di rispetto della codifica veramente accurato per l'inversione delle stringhe è leggermente più coinvolto. Una di queste implementazioni è una piccola libreria chiamata Esrever , che usa espressioni regolari per abbinare segni combinati e coppie surrogate per eseguire perfettamente l'inversione.

Spiegazione

Usando l'operatore di diffusione

function reverseString(str) {
    return [...String(str)].reverse().join('');    
}

console.log(reverseString('stackoverflow'));  // "wolfrevokcats"
console.log(reverseString(1337));             // "7331"
console.log(reverseString([1, 2, 3]));        // "3,2,1"

Funzione di reverse() personalizzata reverse()

function reverse(string) {
    var strRev = "";
    for (var i = string.length - 1; i >= 0; i--) {
        strRev += string[i];
    }
    return strRev; 
}

reverse("zebra");  // "arbez"

Tagliare gli spazi bianchi

Per tagliare gli spazi bianchi dai bordi di una stringa, utilizzare String.prototype.trim :

"    some whitespaced string  ".trim();  // "some whitespaced string"

Molti motori JavaScript, ma non Internet Explorer , hanno implementato metodi trimLeft e trimRight non standard. Esiste una proposta , attualmente nella Fase 1 del processo, per i metodi trimStart e trimEnd standardizzati, alias per trimLeft e trimRight per la compatibilità.

// Stage 1 proposal
"    this is me    ".trimStart();  // "this is me    "
"    this is me    ".trimEnd();  // "    this is me"

// Non-standard methods, but currently implemented by most engines
"    this is me    ".trimLeft();  // "this is me    "
"    this is me    ".trimRight();  // "    this is me"

Sottostringhe con fetta

Usa .slice() per estrarre sottostringhe date due indici:

var s = "0123456789abcdefg";
s.slice(0, 5);  // "01234"
s.slice(5, 6);  // "5"

Dato un indice, ci vorranno da quell'indice alla fine della stringa:

s.slice(10);    // "abcdefg"

Divisione di una stringa in una matrice

Usa .split per passare dalle stringhe a un array delle sottostringhe divise:

var s = "one, two, three, four, five"
s.split(", ");  // ["one", "two", "three", "four", "five"]

Usa il metodo array .join per tornare a una stringa:

s.split(", ").join("--");  // "one--two--three--four--five"

Le stringhe sono unicode

Tutte le stringhe JavaScript sono unicode!

var s = "some ∆≈ƒ unicode ¡™£¢¢¢";
s.charCodeAt(5);  // 8710

Non ci sono byte grezzi o stringhe binarie in JavaScript. Per gestire in modo efficace i dati binari, utilizzare matrici tipizzate .

Rilevare una stringa

Per rilevare se un parametro è una stringa primitiva , utilizzare typeof :

var aString = "my string";
var anInt = 5;
var anObj = {};
typeof aString === "string";   // true
typeof anInt === "string";     // false
typeof anObj === "string";     // false

Se si dispone di un oggetto String , tramite new String("somestr") , il precedente non funzionerà. In questo caso, possiamo usare instanceof :

var aStringObj = new String("my string");
aStringObj instanceof String;    // true

Per coprire entrambe le istanze, possiamo scrivere una semplice funzione di supporto:

var isString = function(value) {
    return typeof value === "string" || value instanceof String;
};

var aString = "Primitive String";
var aStringObj = new String("String Object");
isString(aString); // true
isString(aStringObj); // true
isString({}); // false
isString(5); // false

Oppure possiamo usare la funzione toString di Object . Questo può essere utile se dobbiamo controllare anche altri tipi di dire in una dichiarazione switch, poiché questo metodo supporta anche altri tipi di dati, proprio come typeof .

var pString = "Primitive String";
var oString = new String("Object Form of String");
Object.prototype.toString.call(pString);//"[object String]"
Object.prototype.toString.call(oString);//"[object String]"    

Una soluzione più efficace è quella di non rilevare alcuna stringa, piuttosto di controllare solo quale funzionalità è richiesta. Per esempio:

var aString = "Primitive String";
// Generic check for a substring method
if(aString.substring) {

}
// Explicit check for the String substring prototype method
if(aString.substring === String.prototype.substring) {
    aString.substring(0, );
}

Confronto tra stringhe e lessicograficamente

Per confrontare le stringhe in ordine alfabetico, utilizzare localeCompare() . Ciò restituisce un valore negativo se la stringa di riferimento è lessicograficamente (alfabeticamente) prima della stringa confrontata (il parametro), un valore positivo se viene dopo e un valore di 0 se sono uguali.

var a = "hello";
var b = "world";

console.log(a.localeCompare(b)); // -1

Gli operatori > e < possono anche essere usati per confrontare le stringhe lessicograficamente, ma non possono restituire un valore pari a zero (questo può essere verificato con l'operatore == uguaglianza). Di conseguenza, una forma della funzione localeCompare() può essere scritta in questo modo:

function strcmp(a, b) {
    if(a === b) {
        return 0;
    }

    if (a > b) {
        return 1;
    }

    return -1;
}

console.log(strcmp("hello", "world")); // -1
console.log(strcmp("hello", "hello")); //  0
console.log(strcmp("world", "hello")); //  1

Ciò è particolarmente utile quando si utilizza una funzione di ordinamento che si confronta in base al segno del valore restituito (come l' sort ).

var arr = ["bananas", "cranberries", "apples"];
arr.sort(function(a, b) {
    return a.localeCompare(b);
});
console.log(arr); // [ "apples", "bananas", "cranberries" ]

Stringa in maiuscolo

String.prototype.toUpperCase ():

console.log('qwerty'.toUpperCase()); // 'QWERTY'

Da stringa a minuscola

String.prototype.toLowerCase ()

console.log('QWERTY'.toLowerCase()); // 'qwerty'

Contatore di parole

Supponiamo di avere una <textarea> e di voler recuperare informazioni sul numero di:

• Personaggi (totale)
• Personaggi (senza spazi)
• Parole
• Linee

function wordCount( val ){
    var wom = val.match(/\S+/g);
    return {
        charactersNoSpaces : val.replace(/\s+/g, '').length,
        characters         : val.length,
        words              : wom ? wom.length : 0,
        lines              : val.split(/\r*\n/).length
    };
}


// Use like:
wordCount( someMultilineText ).words;   // (Number of words)

esempio jsFiddle

Accesso al carattere all'indice in stringa

Usa charAt() per ottenere un carattere sull'indice specificato nella stringa.

var string = "Hello, World!";
console.log( string.charAt(4) ); // "o"

In alternativa, poiché le stringhe possono essere trattate come matrici, utilizzare l'indice tramite la notazione delle parentesi .

var string = "Hello, World!";
console.log( string[4] ); // "o"

Per ottenere il codice carattere del personaggio in un indice specificato, utilizzare charCodeAt() .

var string = "Hello, World!";
console.log( string.charCodeAt(4) ); // 111

Si noti che questi metodi sono tutti metodi getter (restituiscono un valore). Le stringhe in JavaScript sono immutabili. In altre parole, nessuno di essi può essere utilizzato per impostare un carattere in una posizione nella stringa.

String Trova e sostituisci funzioni

Per cercare una stringa all'interno di una stringa, ci sono diverse funzioni:

lastIndexOf( searchString ) indexOf( searchString ) e lastIndexOf( searchString )

indexOf() restituirà l'indice della prima occorrenza di searchString nella stringa. Se searchString non viene trovato, viene restituito -1 .

var string = "Hello, World!";
console.log( string.indexOf("o") ); // 4
console.log( string.indexOf("foo") ); // -1

Analogamente, lastIndexOf() restituirà l'indice dell'ultima occorrenza di searchstring o -1 se non trovato.

var string = "Hello, World!";
console.log( string.lastIndexOf("o") );   // 8
console.log( string.lastIndexOf("foo") ); // -1

includes( searchString, start )

includes() restituirà un valore booleano che indica se searchString esiste nella stringa, a partire dall'indice start (predefinito su 0). Questo è meglio di indexOf() se hai semplicemente bisogno di testare l'esistenza di una sottostringa.

var string = "Hello, World!";
console.log( string.includes("Hello") ); // true
console.log( string.includes("foo") );   // false

replace( regexp|substring, replacement|replaceFunction )

replace() restituirà una stringa che contiene tutte le occorrenze di sottostringhe che corrispondono alla regexp RegExp o alla substring di substring con una replacement stringa o il valore restituito di replaceFunction .

Si noti che questo non modifica la stringa sul posto, ma restituisce la stringa con le sostituzioni.

var string = "Hello, World!";
string = string.replace( "Hello", "Bye" );
console.log( string ); // "Bye, World!"

string = string.replace( /W.{3}d/g, "Universe" );
console.log( string ); // "Bye, Universe!"

replaceFunction può essere utilizzato per sostituzioni condizionali per gli oggetti espressioni regolari (per esempio, con l'uso con regexp ). I parametri sono nel seguente ordine:

Si noti che tutti i parametri sono opzionali.

var string = "heLlo, woRlD!";
string = string.replace( /([a-zA-Z])([a-zA-Z]+)/g, function(match, g1, g2) {
    return g1.toUpperCase() + g2.toLowerCase();
}); 
console.log( string ); // "Hello, World!"

Trova l'indice di una sottostringa all'interno di una stringa

Il metodo .indexOf restituisce l'indice di una sottostringa all'interno di un'altra stringa (se esiste, o -1 se diversamente)

'Hellow World'.indexOf('Wor');    // 7

.indexOf accetta anche un argomento numerico aggiuntivo che indica su quale indice deve iniziare la funzione

"harr dee harr dee harr".indexOf("dee", 10); // 14

Dovresti notare che .indexOf è case sensitive

 'Hellow World'.indexOf('WOR');    // -1

Rappresentazioni stringa di numeri

JavaScript ha una conversione nativa da Number alla sua rappresentazione String per qualsiasi base da 2 a 36 .

La rappresentazione più comune dopo il decimale (base 10) è esadecimale (base 16) , ma il contenuto di questa sezione funziona per tutte le basi dell'intervallo.

Per convertire un numero da decimale (base 10) in esadecimale (base 16) rappresentazione di stringa, il metodo toString può essere utilizzato con radix 16 .

// base 10 Number
var b10 = 12;

// base 16 String representation
var b16 = b10.toString(16); // "c"

Se il numero rappresentato è un numero intero, l'operazione inversa per questo può essere eseguita con parseInt e la radix 16 nuovo

// base 16 String representation
var b16 = 'c';

// base 10 Number
var b10 = parseInt(b16, 16); // 12

Per convertire un numero arbitrario (cioè non intero) dalla sua rappresentazione in stringa in un numero , l'operazione deve essere divisa in due parti; la parte intera e la parte frazione.

let b16 = '3.243f3e0370cdc';
// Split into integer and fraction parts
let [i16, f16] = b16.split('.');

// Calculate base 10 integer part
let i10 = parseInt(i16, 16); // 3

// Calculate the base 10 fraction part
let f10 = parseInt(f16, 16) / Math.pow(16, f16.length); // 0.14158999999999988

// Put the base 10 parts together to find the Number
let b10 = i10 + f10; // 3.14159

Nota 1: Prestare attenzione al verificarsi di piccoli errori nel risultato a causa delle differenze in ciò che è possibile rappresentare in basi diverse. Potrebbe essere opportuno eseguire una sorta di arrotondamento in seguito.
Nota 2: Rappresentazioni di numeri molto lunghe possono anche causare errori dovuti all'accuratezza e ai valori massimi dei numeri dell'ambiente in cui si verificano le conversioni.

Ripeti una stringa

"abc".repeat(3);  // Returns "abcabcabc"
"abc".repeat(0);  // Returns ""
"abc".repeat(-1); // Throws a RangeError

var myString = "abc";
var n = 3;

new Array(n + 1).join(myString);  // Returns "abcabcabc"

Codice del personaggio

Il metodo charCodeAt recupera il codice carattere Unicode di un singolo carattere:

var charCode = "µ".charCodeAt(); // The character code of the letter µ is 181

Per ottenere il codice carattere di un carattere in una stringa, la posizione a 0 del carattere viene passata come parametro a charCodeAt :

var charCode = "ABCDE".charCodeAt(3); // The character code of "D" is 68

// The Grinning Face Emoji has code point 128512 or 0x1F600
var codePoint = "😀".codePointAt();