Como verificar se uma string "Começa com" outra string?

Como eu escreveria o equivalente a c # String.StartsWithem JavaScript?

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

haystack.startsWith(needle) == true

Nota: Essa é uma pergunta antiga e, como apontado nos comentários, o ECMAScript 2015 (ES6) introduziu o .startsWithmétodo. No entanto, no momento da redação desta atualização (2015), o suporte ao navegador está longe de estar completo .

Você pode usar o String.prototype.startsWith()método do ECMAScript 6 , mas ainda não é suportado em todos os navegadores . Você deseja usar um shim / polyfill para adicioná-lo em navegadores que não o suportam. Criar uma implementação que atenda a todos os detalhes apresentados nas especificações é um pouco complicado. Se você deseja um calço fiel, use:

• Matthias Bynens String.prototype.startsWithcalço , ou
• O es6-shim , que calha o máximo possível das especificações do ES6, inclusive String.prototype.startsWith.

Depois de alterar o método (ou se você estiver suportando apenas navegadores e mecanismos JavaScript que já o possuem), poderá usá-lo da seguinte maneira:

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

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

Outra alternativa com .lastIndexOf:

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

Isso procura haystackuma ocorrência de needlepartida a partir do índice 0de haystack. Em outras palavras, ele apenas verifica se haystackcomeça com needle.

Em princípio, isso deve ter vantagens de desempenho em relação a outras abordagens:

• Não pesquisa o todo haystack.
• Ele não cria uma nova sequência temporária e a descarta imediatamente.

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

Sem uma função auxiliar, apenas usando o .testmétodo regex :

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

Para fazer isso com uma sequência dinâmica, em vez de codificada (assumindo que a sequência não contenha caracteres de controle regexp):

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

Você deve verificar Existe uma função RegExp.escape em Javascript? se existir a possibilidade de os caracteres de controle regexp aparecerem na string.

Melhor solução:

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

E aqui está o endsWith, se você precisar disso também:

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

Para aqueles que preferem prototipá-lo em 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

Com método:

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

Eu só queria adicionar minha opinião sobre isso.

Eu acho que podemos usar assim:

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

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

Aqui está uma pequena melhoria na solução do 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

Verificando se a função já existe, caso um navegador futuro a implemente em código nativo ou se ela é implementada por outra biblioteca. Por exemplo, a Prototype Library já implementa essa função.

O uso !é um pouco mais rápido e conciso do === 0que não é tão legível.

Verifique também underscore.string.js . Ele vem com vários métodos úteis de teste e manipulação de strings, incluindo um startsWithmétodo. Dos documentos:

começa com _.startsWith(string, starts)

Este método verifica se stringcomeça com starts.

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

Recentemente, me fiz a mesma pergunta.
Existem várias soluções possíveis, aqui estão três válidas:

• s.indexOf(starter) === 0
• s.substr(0,starter.length) === starter
• s.lastIndexOf(starter, 0) === 0(adicionado depois de ver a resposta de Mark Byers )

• usando um loop:

  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;
  }

Não encontrei a última solução que faz uso de um loop.
Surpreendentemente, esta solução supera os 3 primeiros por uma margem significativa.
Aqui está o teste jsperf que realizei para chegar a esta conclusão: http://jsperf.com/startswith2/2

Paz

ps: ecmascript 6 (harmonia) introduz um startsWithmétodo nativo para strings.
Imagine quanto tempo teria sido economizado se eles tivessem pensado em incluir esse método tão necessário na própria versão inicial.

Atualizar

Como Steve apontou (o primeiro comentário sobre esta resposta), a função personalizada acima gerará um erro se o prefixo fornecido for menor que a string inteira. Ele corrigiu isso e adicionou uma otimização de loop que pode ser visualizada em http://jsperf.com/startswith2/4 .

Observe que existem 2 otimizações de loop que Steve incluiu, a primeira das duas apresentou melhor desempenho, portanto postarei esse código abaixo:

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;
}

Como isso é tão popular, acho que vale a pena ressaltar que existe uma implementação para esse método no ECMA 6 e, em preparação para isso, deve-se usar o polyfill 'oficial' para evitar futuros problemas e lágrimas.

Felizmente, os especialistas da Mozilla nos fornecem um:

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;
    };
}

Observe que isso tem a vantagem de ser ignorado normalmente na transição para o ECMA 6.

A melhor solução de desempenho é parar de usar chamadas de biblioteca e apenas reconhecer que você está trabalhando com duas matrizes. Uma implementação manual é curta e também mais rápida do que qualquer outra solução que eu já vi aqui.

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;
}

Para comparações de desempenho (êxito e falha), consulte http://jsperf.com/startswith2/4 . (Verifique se há versões posteriores que podem ter superado as minhas.)

Acabei de aprender sobre esta biblioteca de strings:

http://stringjs.com/

Inclua o arquivo js e use a Svariável assim:

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

Também pode ser usado no NodeJS instalando-o:

npm install string

Em seguida, exigindo-o como a Svariável:

var S = require('string');

A página da web também possui links para bibliotecas de cadeias de caracteres alternativas, se esta não lhe agradar.

2019. A pergunta é um pouco antiga, mas eu queria escrever esta resposta para mostrar alguns benchmarks que fiz com base em todas as respostas fornecidas aqui e no jsperf compartilhado por Jim Buck.

Basicamente, eu precisava de uma maneira rápida de descobrir se uma agulha longa está dentro de um palheiro longo e elas são muito semelhantes, exceto os últimos caracteres.

Aqui está o código que escrevi que para cada função (emenda, substring, inicia com, etc.) testa quando retorna falso e verdadeiro em uma cadeia de feno ( nestedString) de 1.000.0001 caracteres e uma cadeia de agulha falsa ou truculenta de 1.000.000 caracteres ( testParentStringFalsee testParentStringTrue, respectivamente):

// 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)
}

Fiz esse teste de benchmark no Chrome 75 , Firefox 67 , Safari 12 e Opera 62 .

Não incluí o Edge e o IE porque não os tenho nesta máquina, mas se alguém quiser executar o script no Edge e pelo menos no IE 9 e compartilhar a saída aqui, ficaria muito curioso para ver os resultados.

Lembre-se de que você precisa recriar as três seqüências longas e salvar o script em um arquivo que você abre no navegador, pois copiar / colar no console do navegador a bloqueia, pois o comprimento de cada sequência é> = 1.000.000).

Aqui estão as saídas:

Chrome 75 ( substringvitórias):

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 ( indexOfvitórias):

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 ( slicevitórias por resultados falsos, startsWithvitórias por resultados verdadeiros, também o Safari é o mais rápido em termos de tempo total para executar todo o teste):

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 ( substringvitórias. Os resultados são semelhantes ao Chrome e não estou surpreso, pois o Opera é baseado em 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}

Acontece que todo navegador tem seus próprios detalhes de implementação (além do Opera, que é baseado no Chromium e Blink do Chrome).

Obviamente, testes adicionais com diferentes casos de uso podem e devem ser realizados (por exemplo, quando a agulha é realmente curta comparada ao palheiro, quando o palheiro é mais curto que a agulha, etc ...), mas no meu caso eu precisava comparar cordas muito longas e queria compartilhá-lo aqui.

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

Com base nas respostas aqui, esta é a versão que estou usando agora, pois parece oferecer o melhor desempenho com base no teste JSPerf (e é funcionalmente completo, tanto quanto eu sei).

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;
    }
}

Isso foi baseado no beginWith2 a partir daqui: http://jsperf.com/startswith2/6 . Eu adicionei um pequeno ajuste para uma pequena melhoria no desempenho e, desde então, também adicionei uma verificação para a seqüência de comparação ser nula ou indefinida, e a converti para adicionar ao protótipo de String usando a técnica na resposta do CMS.

Observe que esta implementação não suporta o parâmetro "position" mencionado nesta página da Mozilla Developer Network , mas que, de qualquer maneira, não parece fazer parte da proposta do ECMAScript.

Eu não tenho certeza para javascript, mas no texto datilografado eu fiz algo como

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

Eu acho que deve funcionar em js também. Espero que ajude!

Se você está trabalhando startsWith()e endsWith()precisa ter cuidado com os espaços à frente. Aqui está um exemplo 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

Você também pode retornar todos os membros de uma matriz que começam com uma cadeia de caracteres, criando seu próprio protótipo / extensão para o protótipo da matriz, também conhecido como

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 para usá-lo:

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