Come verificare se una stringa "Inizia con" un'altra stringa?

Come scriverei l'equivalente di C # String.StartsWithin JavaScript?

var haystack = 'hello world';
var needle = 'he';

haystack.startsWith(needle) == true

Nota: questa è una vecchia domanda e, come sottolineato nei commenti, ECMAScript 2015 (ES6) ha introdotto il .startsWithmetodo. Tuttavia, al momento della stesura di questo aggiornamento (2015) il supporto del browser è lungi dall'essere completo .

È possibile utilizzare il String.prototype.startsWith()metodo ECMAScript 6 , ma non è ancora supportato in tutti i browser . Ti consigliamo di utilizzare uno shim / polyfill per aggiungerlo ai browser che non lo supportano. La creazione di un'implementazione conforme a tutti i dettagli indicati nelle specifiche è un po 'complicata. Se vuoi uno spessore fedele, usa:

• Lo String.prototype.startsWithspessore di Matthias Bynens , o
• L'ES6-spessore , che spessori tanto della specifica ES6 possibile, compresi String.prototype.startsWith.

Dopo aver ignorato il metodo (o se stai supportando solo browser e motori JavaScript che già lo hanno), puoi usarlo in questo modo:

"Hello World!".startsWith("He"); // true

var haystack = "Hello world";
var prefix = 'orl';
haystack.startsWith(prefix); // false

Un'altra alternativa con .lastIndexOf:

haystack.lastIndexOf(needle, 0) === 0

Questo guarda indietro haystackper un'occorrenza di needlepartenza dall'indice 0di haystack. In altre parole, controlla solo se haystackinizia con needle.

In linea di principio, ciò dovrebbe avere vantaggi in termini di prestazioni rispetto ad altri approcci:

• Non cerca l'intero haystack.
• Non crea una nuova stringa temporanea e quindi la scarta immediatamente.

data.substring(0, input.length) === input

Senza una funzione di supporto, basta usare il .testmetodo regex :

/^He/.test('Hello world')

Per fare ciò con una stringa dinamica piuttosto che con una hardcoded (supponendo che la stringa non conterrà alcun carattere di controllo regexp):

new RegExp('^' + needle).test(haystack)

Dovresti dare un'occhiata Esiste una funzione RegExp.escape in Javascript? se esiste la possibilità che i caratteri di controllo regexp compaiano nella stringa.

Soluzione migliore:

function startsWith(str, word) {
    return str.lastIndexOf(word, 0) === 0;
}

Ed ecco qui, anche se ne hai bisogno:

function endsWith(str, word) {
    return str.indexOf(word, str.length - word.length) !== -1;
}

Per quelli che preferiscono prototiparlo in String:

String.prototype.startsWith || (String.prototype.startsWith = function(word) {
    return this.lastIndexOf(word, 0) === 0;
});

String.prototype.endsWith   || (String.prototype.endsWith = function(word) {
    return this.indexOf(word, this.length - word.length) !== -1;
});

Uso:

"abc".startsWith("ab")
true
"c".ensdWith("c") 
true

Con metodo:

startsWith("aaa", "a")
true
startsWith("aaa", "ab")
false
startsWith("abc", "abc")
true
startsWith("abc", "c")
false
startsWith("abc", "a")
true
startsWith("abc", "ba")
false
startsWith("abc", "ab")
true

Volevo solo aggiungere la mia opinione su questo.

Penso che possiamo usare così:

var haystack = 'hello world';
var needle = 'he';

if (haystack.indexOf(needle) == 0) {
  // Code if string starts with this substring
}

Ecco un piccolo miglioramento alla soluzione CMS:

if(!String.prototype.startsWith){
    String.prototype.startsWith = function (str) {
        return !this.indexOf(str);
    }
}

"Hello World!".startsWith("He"); // true

 var data = "Hello world";
 var input = 'He';
 data.startsWith(input); // true

Verifica se la funzione esiste già nel caso in cui un browser futuro la implementi nel codice nativo o se è implementata da un'altra libreria. Ad esempio, la Libreria prototipi implementa già questa funzione.

L'uso !è leggermente più veloce e più conciso di === 0quanto non sia così leggibile.

Dai un'occhiata anche a underscore.string.js . Viene fornito con un sacco di utili metodi di test e manipolazione delle stringhe, incluso un startsWithmetodo. Dai documenti:

inizia con _.startsWith(string, starts)

Questo metodo controlla se stringinizia con starts.

_("image.gif").startsWith("image")
=> true

Di recente mi sono posto la stessa domanda.
Esistono più soluzioni possibili, eccone 3 valide:

• s.indexOf(starter) === 0
• s.substr(0,starter.length) === starter
• s.lastIndexOf(starter, 0) === 0(aggiunto dopo aver visto la risposta di Mark Byers )

• usando un ciclo:

  function startsWith(s,starter) {
    for (var i = 0,cur_c; i < starter.length; i++) {
      cur_c = starter[i];
      if (s[i] !== starter[i]) {
        return false;
      }
    }
    return true;
  }

Non ho trovato l'ultima soluzione che utilizza un ciclo.
Sorprendentemente questa soluzione supera i primi 3 di un margine significativo.
Ecco il test jsperf che ho eseguito per giungere a questa conclusione: http://jsperf.com/startswith2/2

Pace

ps: ecmascript 6 (armonia) introduce un startsWithmetodo nativo per le stringhe.
Basti pensare a quanto tempo sarebbe stato risparmiato se avessero pensato di includere questo tanto necessario metodo nella versione iniziale stessa.

Aggiornare

Come ha sottolineato Steve (il primo commento su questa risposta), la funzione personalizzata sopra genererà un errore se il prefisso dato è più corto dell'intera stringa. Lo ha risolto e ha aggiunto un'ottimizzazione del loop che può essere visualizzata su http://jsperf.com/startswith2/4 .

Nota che ci sono 2 ottimizzazioni di loop che Steve ha incluso, il primo dei due ha mostrato prestazioni migliori, quindi posterò quel codice qui sotto:

function startsWith2(str, prefix) {
  if (str.length < prefix.length)
    return false;
  for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
    continue;
  return i < 0;
}

Dato che è così popolare, penso che valga la pena sottolineare che esiste un'attuazione per questo metodo nell'ECMA 6 e in preparazione a ciò si dovrebbe usare il polifill "ufficiale" per prevenire futuri problemi e lacrime.

Fortunatamente gli esperti di Mozilla ci forniscono uno:

https://developer.mozilla.org/de/docs/Web/JavaScript/Reference/Global_Objects/String/startsWith

if (!String.prototype.startsWith) {
    String.prototype.startsWith = function(searchString, position) {
        position = position || 0;
        return this.indexOf(searchString, position) === position;
    };
}

Si noti che ciò ha il vantaggio di essere ignorato con garbo durante la transizione a ECMA 6.

La soluzione con le migliori prestazioni è smettere di usare le chiamate in libreria e riconoscere semplicemente che si sta lavorando con due array. Un'implementazione eseguita a mano è breve e anche più veloce di ogni altra soluzione che ho visto qui.

function startsWith2(str, prefix) {
    if (str.length < prefix.length)
        return false;
    for (var i = prefix.length - 1; (i >= 0) && (str[i] === prefix[i]); --i)
        continue;
    return i < 0;
}

Per i confronti delle prestazioni (esito positivo e negativo), consultare http://jsperf.com/startswith2/4 . (Assicurati di controllare le versioni successive che potrebbero aver battuto il mio.)

Ho appena imparato a conoscere questa libreria di stringhe:

http://stringjs.com/

Includi il file js e usa la Svariabile in questo modo:

S('hi there').endsWith('hi there')

Può anche essere utilizzato in NodeJS installandolo:

npm install string

Quindi richiedendolo come Svariabile:

var S = require('string');

La pagina web contiene anche collegamenti a librerie di stringhe alternative, se questa non ti piace.

2019. La domanda è un po 'vecchia, ma volevo scrivere questa risposta per mostrarti alcuni parametri di riferimento che ho fatto sulla base di tutte le risposte fornite qui e del jsperf condiviso da Jim Buck.

Fondamentalmente avevo bisogno di un modo rapido per scoprire se un ago lungo si trova all'interno di un lungo pagliaio e sono molto simili, tranne per gli ultimi personaggi.

Ecco il codice che ho scritto che per ogni funzione (giuntura, sottostringa, inizia con, ecc.) Verifica sia quando restituiscono falso che vero contro una stringa di pagliaio ( nestedString) di 1.000.0001 caratteri e una stringa di ago falsa o veritiera di 1.000.000 caratteri ( testParentStringFalsee testParentStringTrue, rispettivamente):

// nestedString is made of 1.000.001 '1' repeated characters.
var nestedString = '...'

// testParentStringFalse is made of 1.000.000 characters,
// all characters are repeated '1', but the last one is '2',
// so for this string the test should return false.
var testParentStringFalse = '...'

// testParentStringTrue is made of 1.000.000 '1' repeated characters,
// so for this string the test should return true.
var testParentStringTrue = '...'

// You can make these very long strings by running the following bash command
// and edit each one as needed in your editor
// (NOTE: on OS X, `pbcopy` copies the string to the clipboard buffer,
//        on Linux, you would probably need to replace it with `xclip`):
// 
//     printf '1%.0s' {1..1000000} | pbcopy
// 

function testString() {
    let dateStart
    let dateEnd
    let avg
    let count = 100000
    const falseResults = []
    const trueResults = []

    /* slice */
    console.log('========> slice')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.slice(0, testParentStringFalse.length) === testParentStringFalse
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'slice',
        avg
    }
    console.log(`testString() slice = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.slice(0, testParentStringTrue.length) === testParentStringTrue
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'slice',
        avg
    }
    console.log(`testString() slice = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== slice')
    console.log('')
    /* slice END */

    /* lastIndexOf */
    console.log('========> lastIndexOf')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.lastIndexOf(testParentStringFalse, 0) === 0
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'lastIndexOf',
        avg
    }
    console.log(`testString() lastIndexOf = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.lastIndexOf(testParentStringTrue, 0) === 0
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'lastIndexOf',
        avg
    }
    console.log(`testString() lastIndexOf = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== lastIndexOf')
    console.log('')
    /* lastIndexOf END */

    /* indexOf */
    console.log('========> indexOf')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.indexOf(testParentStringFalse) === 0
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'indexOf',
        avg
    }
    console.log(`testString() indexOf = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.indexOf(testParentStringTrue) === 0
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'indexOf',
        avg
    }
    console.log(`testString() indexOf = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== indexOf')
    console.log('')
    /* indexOf END */

    /* substring */
    console.log('========> substring')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.substring(0, testParentStringFalse.length) === testParentStringFalse
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'substring',
        avg
    }
    console.log(`testString() substring = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.substring(0, testParentStringTrue.length) === testParentStringTrue
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'substring',
        avg
    }
    console.log(`testString() substring = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== substring')
    console.log('')
    /* substring END */

    /* startsWith */
    console.log('========> startsWith')
    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.startsWith(testParentStringFalse)
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    falseResults[falseResults.length] = {
        label: 'startsWith',
        avg
    }
    console.log(`testString() startsWith = false`, res, 'avg: ' + avg + 'ms')

    dateStart = +new Date()
    var res
    for (let j = 0; j < count; j++) {
        res = nestedString.startsWith(testParentStringTrue)
    }
    dateEnd = +new Date()
    avg = (dateEnd - dateStart)/count
    trueResults[trueResults.length] = {
        label: 'startsWith',
        avg
    }
    console.log(`testString() startsWith = true`, res, 'avg: ' + avg + 'ms')
    console.log('<======== startsWith')
    console.log('')
    /* startsWith END */

    falseResults.sort((a, b) => a.avg - b.avg)
    trueResults.sort((a, b) => a.avg - b.avg)

    console.log('false results from fastest to slowest avg:', falseResults)
    console.log('true results from fastest to slowest avg:', trueResults)
}

Ho eseguito questo test di riferimento su Chrome 75 , Firefox 67 , Safari 12 e Opera 62 .

Non ho incluso Edge e IE perché non li ho su questa macchina, ma se qualcuno di voi vuole eseguire lo script su Edge e almeno IE 9 e condividere l'output qui, sarei molto curioso di vedere i risultati.

Basta ricordare che è necessario ricreare le 3 stringhe lunghe e salvare lo script in un file che si apre nel browser in quanto copia / incolla sulla console del browser lo bloccherà poiché la lunghezza di ogni stringa è> = 1.000.000).

Ecco gli output:

Chrome 75 ( substringvittorie):

false results from fastest to slowest avg:
1)  {"label":"substring","avg":0.08271}
2)  {"label":"slice","avg":0.08615}
3)  {"label":"lastIndexOf","avg":0.77025}
4)  {"label":"indexOf","avg":1.64375}
5)  {"label":"startsWith","avg":3.5454}

true results from fastest to slowest avg:
1)  {"label":"substring","avg":0.08213}
2)  {"label":"slice","avg":0.08342}
3)  {"label":"lastIndexOf","avg":0.7831}
4)  {"label":"indexOf","avg":0.88988}
5)  {"label":"startsWith","avg":3.55448}

Firefox 67 ( indexOfvince):

false results from fastest to slowest avg
1)  {"label":"indexOf","avg":0.1807}
2)  {"label":"startsWith","avg":0.74621}
3)  {"label":"substring","avg":0.74898}
4)  {"label":"slice","avg":0.78584}
5)  {"label":"lastIndexOf","avg":0.79668}

true results from fastest to slowest avg:
1)  {"label":"indexOf","avg":0.09528}
2)  {"label":"substring","avg":0.75468}
3)  {"label":"startsWith","avg":0.76717}
4)  {"label":"slice","avg":0.77222}
5)  {"label":"lastIndexOf","avg":0.80527}

Safari 12 ( slicevince per risultati falsi, startsWithvince per risultati veri, anche Safari è il più veloce in termini di tempo totale per eseguire l'intero test):

false results from fastest to slowest avg:
1) "{\"label\":\"slice\",\"avg\":0.0362}"
2) "{\"label\":\"startsWith\",\"avg\":0.1141}"
3) "{\"label\":\"lastIndexOf\",\"avg\":0.11512}"
4) "{\"label\":\"substring\",\"avg\":0.14751}"
5) "{\"label\":\"indexOf\",\"avg\":0.23109}"

true results from fastest to slowest avg:
1) "{\"label\":\"startsWith\",\"avg\":0.11207}"
2) "{\"label\":\"lastIndexOf\",\"avg\":0.12196}"
3) "{\"label\":\"substring\",\"avg\":0.12495}"
4) "{\"label\":\"indexOf\",\"avg\":0.33667}"
5) "{\"label\":\"slice\",\"avg\":0.49923}"

Opera 62 ( substringvince. I risultati sono simili a quelli di Chrome e non mi sorprende poiché Opera si basa su Chromium e Blink):

false results from fastest to slowest avg:
{"label":"substring","avg":0.09321}
{"label":"slice","avg":0.09463}
{"label":"lastIndexOf","avg":0.95347}
{"label":"indexOf","avg":1.6337}
{"label":"startsWith","avg":3.61454}

true results from fastest to slowest avg:
1)  {"label":"substring","avg":0.08855}
2)  {"label":"slice","avg":0.12227}
3)  {"label":"indexOf","avg":0.79914}
4)  {"label":"lastIndexOf","avg":1.05086}
5)  {"label":"startsWith","avg":3.70808}

Si scopre che ogni browser ha i propri dettagli di implementazione (a parte Opera, che si basa su Chrome Chromium e Blink).

Naturalmente, ulteriori test con diversi casi d'uso potrebbero e dovrebbero essere eseguiti (ad es. Quando l'ago è molto corto rispetto al pagliaio, quando il pagliaio è più corto dell'ago, ecc ...), ma nel mio caso avevo bisogno di confrontare stringhe molto lunghe e volevo condividerlo qui.

var str = 'hol';
var data = 'hola mundo';
if (data.length >= str.length && data.substring(0, str.length) == str)
    return true;
else
    return false;

Sulla base delle risposte qui, questa è la versione che sto usando ora, in quanto sembra offrire le migliori prestazioni in base ai test JSPerf (ed è funzionalmente completa per quanto posso dire).

if(typeof String.prototype.startsWith != 'function'){
    String.prototype.startsWith = function(str){
        if(str == null) return false;
        var i = str.length;
        if(this.length < i) return false;
        for(--i; (i >= 0) && (this[i] === str[i]); --i) continue;
        return i < 0;
    }
}

Questo si basava su startWith2 da qui: http://jsperf.com/startswith2/6 . Ho aggiunto una piccola modifica per un piccolo miglioramento delle prestazioni e da allora ho anche aggiunto un controllo per la stringa di confronto che è nulla o non definita, e l'ho convertito per aggiungerlo al prototipo String usando la tecnica nella risposta di CMS.

Nota che questa implementazione non supporta il parametro "position" menzionato in questa pagina della rete di sviluppatori Mozilla , ma che comunque non sembra far parte della proposta ECMAScript.

Non sono sicuro per JavaScript ma in dattiloscritto ho fatto qualcosa di simile

var str = "something";
(<String>str).startsWith("some");

Immagino che dovrebbe funzionare anche su js. Spero possa essere d'aiuto!

Se stai lavorando con startsWith()e endsWith()poi devi stare attento agli spazi iniziali. Ecco un esempio completo:

var str1 = " Your String Value Here.!! "; // Starts & ends with spaces    
if (str1.startsWith("Your")) { }  // returns FALSE due to the leading spaces…
if (str1.endsWith("Here.!!")) { } // returns FALSE due to trailing spaces…

var str2 = str1.trim(); // Removes all spaces (and other white-space) from start and end of `str1`.
if (str2.startsWith("Your")) { }  // returns TRUE
if (str2.endsWith("Here.!!")) { } // returns TRUE

È inoltre possibile restituire tutti i membri di un array che iniziano con una stringa creando il proprio prototipo / estensione sul prototipo di array, ovvero

Array.prototype.mySearch = function (target) {
    if (typeof String.prototype.startsWith != 'function') {
        String.prototype.startsWith = function (str){
        return this.slice(0, str.length) == str;
      };
    }
    var retValues = [];
    for (var i = 0; i < this.length; i++) {
        if (this[i].startsWith(target)) { retValues.push(this[i]); }
    }
    return retValues;
};

E per usarlo:

var myArray = ['Hello', 'Helium', 'Hideout', 'Hamster'];
var myResult = myArray.mySearch('Hel');
// result -> Hello, Helium