Comment vérifier si une chaîne "démarre avec" une autre chaîne?

Comment pourrais-je écrire l'équivalent de C # String.StartsWithen JavaScript?

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

haystack.startsWith(needle) == true

Remarque: Il s'agit d'une vieille question et, comme indiqué dans les commentaires, ECMAScript 2015 (ES6) a introduit la .startsWithméthode. Cependant, au moment de la rédaction de cette mise à jour (2015), la prise en charge du navigateur est loin d'être complète .

Vous pouvez utiliser la String.prototype.startsWith()méthode ECMAScript 6 , mais elle n'est pas encore prise en charge dans tous les navigateurs . Vous voudrez utiliser un shim / polyfill pour l'ajouter sur les navigateurs qui ne le prennent pas en charge. La création d'une implémentation conforme à tous les détails énoncés dans la spécification est un peu compliquée. Si vous voulez une cale fidèle, utilisez soit:

• La String.prototype.startsWithcale de Matthias Bynens , ou
• La cale es6 , qui calque autant de spécifications ES6 que possible, y compris String.prototype.startsWith.

Une fois que vous avez modifié la méthode (ou si vous ne supportez que les navigateurs et les moteurs JavaScript qui l'ont déjà), vous pouvez l'utiliser comme ceci:

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

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

Une autre alternative avec .lastIndexOf:

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

Cela regarde en arrière à travers haystackpour une occurrence de needlepartir de l'index 0de haystack. En d'autres termes, il vérifie uniquement si haystackcommence par needle.

En principe, cela devrait présenter des avantages en termes de performances par rapport à d'autres approches:

• Il ne recherche pas l'intégralité haystack.
• Il ne crée pas de nouvelle chaîne temporaire, puis la supprime immédiatement.

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

Sans fonction d'assistance, il suffit d'utiliser la .testméthode de regex :

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

Pour ce faire avec une chaîne dynamique plutôt qu'une chaîne codée en dur (en supposant que la chaîne ne contiendra aucun caractère de contrôle regexp):

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

Vous devriez vérifier Y a-t-il une fonction RegExp.escape en Javascript? si la possibilité existe que des caractères de contrôle d'expression rationnelle apparaissent dans la chaîne.

Meilleure solution:

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

Et voici la fin Avec si vous en avez besoin aussi:

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

Pour ceux qui préfèrent le prototyper en 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;
});

Usage:

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

Avec méthode:

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

Je voulais juste ajouter mon opinion à ce sujet.

Je pense que nous pouvons simplement utiliser comme ceci:

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

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

Voici une amélioration mineure à la solution de 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

Vérifier si la fonction existe déjà dans le cas où un futur navigateur l'implémenterait en code natif ou si elle est implémentée par une autre bibliothèque. Par exemple, la bibliothèque de prototypes implémente déjà cette fonction.

L'utilisation !est légèrement plus rapide et plus concise que === 0si elle n'est pas aussi lisible.

Consultez également underscore.string.js . Il est livré avec un tas de méthodes de test et de manipulation de chaînes utiles, dont une startsWithméthode. De la documentation:

commence avec _.startsWith(string, starts)

Cette méthode vérifie si string commence par starts.

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

Je me suis récemment posé la même question.
Il existe plusieurs solutions possibles, en voici 3 valides:

• s.indexOf(starter) === 0
• s.substr(0,starter.length) === starter
• s.lastIndexOf(starter, 0) === 0(ajouté après avoir vu la réponse de Mark Byers )

• en utilisant une boucle:

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

Je n'ai pas trouvé la dernière solution qui utilise une boucle.
Étonnamment, cette solution surpasse les 3 premiers d'une marge significative.
Voici le test jsperf que j'ai effectué pour arriver à cette conclusion: http://jsperf.com/startswith2/2

Paix

ps: ecmascript 6 (harmonie) introduit une startsWithméthode native pour les chaînes.
Imaginez combien de temps aurait été gagné s'ils avaient pensé à inclure cette méthode si nécessaire dans la version initiale elle-même.

Mise à jour

Comme Steve l'a souligné (le premier commentaire sur cette réponse), la fonction personnalisée ci-dessus générera une erreur si le préfixe donné est plus court que la chaîne entière. Il a corrigé cela et ajouté une optimisation de boucle qui peut être consultée sur http://jsperf.com/startswith2/4 .

Notez qu'il y a 2 optimisations de boucle que Steve a incluses, la première des deux a montré de meilleures performances, donc je posterai ce code ci-dessous:

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

Étant donné que cela est si populaire, je pense qu'il convient de souligner qu'il existe une implémentation de cette méthode dans ECMA 6 et qu'en préparation, il convient d'utiliser le polyfill `` officiel '' afin d'éviter de futurs problèmes et larmes.

Heureusement, les experts de Mozilla nous en fournissent un:

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

Veuillez noter que cela a l'avantage d'être ignoré avec élégance lors de la transition vers ECMA 6.

La solution la plus performante consiste à cesser d'utiliser les appels de bibliothèque et à reconnaître simplement que vous travaillez avec deux tableaux. Une implémentation roulée à la main est à la fois courte et aussi plus rapide que toutes les autres solutions que j'ai vues ici.

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

Pour des comparaisons de performances (succès et échec), voir http://jsperf.com/startswith2/4 . (Assurez-vous de vérifier les versions ultérieures qui peuvent avoir trompé la mienne.)

Je viens d'apprendre cette bibliothèque de chaînes:

http://stringjs.com/

Incluez le fichier js, puis utilisez la Svariable comme ceci:

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

Il peut également être utilisé dans NodeJS en l'installant:

npm install string

Le nécessitant ensuite comme Svariable:

var S = require('string');

La page Web contient également des liens vers d'autres bibliothèques de chaînes, si celle-ci ne vous convient pas.

2019. La question est un peu ancienne, mais je voulais écrire cette réponse pour vous montrer quelques repères que j'ai faits sur la base de toutes les réponses fournies ici et du jsperf partagé par Jim Buck.

J'avais essentiellement besoin d'un moyen rapide pour savoir si une longue aiguille se trouve dans une longue botte de foin et elles sont très similaires, sauf pour les derniers caractères.

Voici le code que j'ai écrit qui pour chaque fonction (épissure, sous-chaîne, démarre avec, etc.) teste à la fois quand ils retournent faux et vrai contre une chaîne de botte de foin ( nestedString) de 1.000.0001 caractères et une chaîne d'aiguille fausse ou véridique de 1.000.000 caractères ( testParentStringFalseet testParentStringTrue, respectivement):

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

J'ai exécuté ce test de référence sur Chrome 75 , Firefox 67 , Safari 12 et Opera 62 .

Je n'ai pas inclus Edge et IE car je ne les ai pas sur cette machine, mais si quelqu'un d'entre vous veut exécuter le script contre Edge et au moins IE 9 et partager la sortie ici, je serais très curieux de voir les résultats.

N'oubliez pas que vous devez recréer les 3 longues chaînes et enregistrer le script dans un fichier que vous ouvrez ensuite dans votre navigateur car le copier / coller sur la console du navigateur le bloquera car la longueur de chaque chaîne est> = 1.000.000).

Voici les sorties:

Chrome 75 ( substringgagne):

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 ( indexOfgagne):

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 ( slicegagne pour de faux résultats, startsWithgagne pour de vrais résultats, Safari est également le plus rapide en termes de temps total pour exécuter l'ensemble du 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 ( substringvictoires. Les résultats sont similaires à Chrome et je ne suis pas surpris car Opera est basé sur Chrome et 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}

Il s'avère que chaque navigateur a ses propres détails d'implémentation (à l'exception d'Opera, qui est basé sur Chrome et Blink de Chrome).

Bien sûr, un test supplémentaire avec différents cas d'utilisation pourrait et devrait être effectué (par exemple, lorsque l'aiguille est vraiment courte par rapport à la botte de foin, lorsque la botte de foin est plus courte que l'aiguille, etc.), mais dans mon cas, je devais comparer de très longues cordes et voulait le partager ici.

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

Sur la base des réponses ici, c'est la version que j'utilise maintenant, car elle semble donner les meilleures performances basées sur les tests JSPerf (et est fonctionnellement complète pour autant que je sache).

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

Ceci était basé sur startsWith2 à partir d'ici: http://jsperf.com/startswith2/6 . J'ai ajouté un petit ajustement pour une amélioration minime des performances, et depuis j'ai également ajouté une vérification pour que la chaîne de comparaison soit nulle ou non définie, et je l'ai convertie pour l'ajouter au prototype String en utilisant la technique dans la réponse de CMS.

Notez que cette implémentation ne prend pas en charge le paramètre "position" qui est mentionné dans cette page Mozilla Developer Network , mais qui ne semble pas faire partie de la proposition ECMAScript de toute façon.

Je ne suis pas sûr pour javascript mais en tapuscrit j'ai fait quelque chose comme

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

Je suppose que cela devrait aussi fonctionner sur js. J'espère que ça aide!

Si vous travaillez avec startsWith()et endsWith()alors vous devez faire attention aux espaces de tête. Voici un exemple complet:

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

Vous pouvez également renvoyer tous les membres d'un tableau commençant par une chaîne en créant votre propre prototype / extension au prototype du tableau, alias

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

Et pour l'utiliser:

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