Question endsWith en JavaScript


Comment puis-je vérifier si une chaîne se termine par un caractère particulier dans JavaScript?

Exemple: j'ai une chaîne

var str = "mystring#";

Je veux savoir si cette chaîne se termine par #. Comment puis-je le vérifier?

  1. y a t-il endsWith() méthode en JavaScript?

  2. Une solution que j'ai est de prendre la longueur de la chaîne et d'obtenir le dernier caractère et de le vérifier.

Est-ce la meilleure façon ou il y a un autre moyen?


1014
2017-11-11 11:15


origine


Réponses:


MISE À JOUR (24 novembre 2015):

Cette réponse est publiée à l'origine en 2010 (il y a six ans.) Donc s'il vous plaît prendre note de ces commentaires perspicaces:


RÉPONSE ORIGINALE

Je sais que c'est une question vieille d'un an ... mais j'ai aussi besoin de ça et j'en ai besoin pour travailler en cross-browser donc ... combiner la réponse et les commentaires de tout le monde et en simplifiant un peu:

String.prototype.endsWith = function(suffix) {
    return this.indexOf(suffix, this.length - suffix.length) !== -1;
};
  • Ne crée pas de sous-chaîne
  • Utilise natif indexOf fonction pour des résultats plus rapides
  • Ignorer les comparaisons inutiles en utilisant le deuxième paramètre de indexOf aller de l'avant
  • Fonctionne dans Internet Explorer
  • PAS de complications Regex

Aussi, si vous n'aimez pas bourrer les choses dans les prototypes de la structure de données native, voici une version autonome:

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

MODIFIER: Comme noté par @hamish dans les commentaires, si vous voulez errer du bon côté et vérifier si une implémentation a déjà été fournie, vous pouvez juste ajouter un typeof vérifier comme ça:

if (typeof String.prototype.endsWith !== 'function') {
    String.prototype.endsWith = function(suffix) {
        return this.indexOf(suffix, this.length - suffix.length) !== -1;
    };
}

1703
2018-03-30 19:40



/#$/.test(str)

fonctionnera sur tous les navigateurs, ne nécessite pas de correction de singe String, et ne nécessite pas d'analyser toute la chaîne comme lastIndexOf fait quand il n'y a pas de correspondance.

Si vous souhaitez faire correspondre une chaîne constante qui peut contenir des caractères spéciaux d'expression régulière, tels que '$', alors vous pouvez utiliser ce qui suit:

function makeSuffixRegExp(suffix, caseInsensitive) {
  return new RegExp(
      String(suffix).replace(/[$%()*+.?\[\\\]{|}]/g, "\\$&") + "$",
      caseInsensitive ? "i" : "");
}

et alors vous pouvez l'utiliser comme ça

makeSuffixRegExp("a[complicated]*suffix*").test(str)

285
2018-03-24 20:32



  1. Malheureusement non.
  2. if( "mystring#".substr(-1) === "#" ) {}

82
2017-11-11 11:20



Allez, c'est la bonne endsWith la mise en oeuvre:

String.prototype.endsWith = function (s) {
  return this.length >= s.length && this.substr(this.length - s.length) == s;
}

en utilisant lastIndexOf crée simplement des boucles CPU inutiles s'il n'y a pas de correspondance.


66
2017-09-27 08:34



Cette version évite de créer une sous-chaîne, et n'utilise pas d'expressions régulières (certaines réponses regex fonctionnent ici, d'autres sont cassées):

String.prototype.endsWith = function(str)
{
    var lastIndex = this.lastIndexOf(str);
    return (lastIndex !== -1) && (lastIndex + str.length === this.length);
}

Si la performance est importante pour vous, il vaudrait la peine de tester si lastIndexOf est en fait plus rapide que de créer une sous-chaîne ou non. (Cela dépendra peut-être du moteur JS que vous utilisez ...) Il peut être plus rapide dans le cas correspondant, et quand la chaîne est petite - mais quand la chaîne est énorme, elle doit regarder en arrière tout le long bien que nous ne nous soucions pas vraiment :(

Pour vérifier un seul caractère, trouver la longueur et ensuite utiliser charAt est probablement le meilleur moyen.


55
2017-11-11 11:58



Je n'ai pas vu l'apporach avec slice méthode. Donc, je suis juste laisser ici:

function endsWith(str, suffix) {
    return str.slice(-suffix.length) === suffix
}

23
2018-06-09 07:17



return this.lastIndexOf(str) + str.length == this.length;

ne fonctionne pas dans le cas où la longueur de la chaîne d'origine est inférieure à la longueur de la chaîne de recherche et que la chaîne de recherche est introuvable:

lastIndexOf renvoie -1, puis vous ajoutez la longueur de la chaîne de recherche et il vous reste la longueur de la chaîne d'origine.

Une solution possible est

return this.length >= str.length && this.lastIndexOf(str) + str.length == this.length

17
2018-03-04 15:58



De developer.mozilla.org String.prototype.endsWith ()

Résumé

le endsWith() La méthode détermine si une chaîne se termine par les caractères d'une autre chaîne, en renvoyant true ou false selon le cas.

Syntaxe

str.endsWith(searchString [, position]);

Paramètres

  • searchString : Les caractères à rechercher à la fin de cette chaîne.

  • position : Cherchez dans cette chaîne comme si cette chaîne n'était que longue; par défaut à la longueur réelle de cette chaîne, bloquée dans la plage établie par la longueur de cette chaîne.

La description

Cette méthode vous permet de déterminer si une chaîne se termine par une autre chaîne.

Exemples

var str = "To be, or not to be, that is the question.";

alert( str.endsWith("question.") );  // true
alert( str.endsWith("to be") );      // false
alert( str.endsWith("to be", 19) );  // true

Caractéristiques

ECMAScript Language Specification 6ème édition (ECMA-262)

Compatibilité du navigateur

Browser compatibility


13
2018-03-05 14:57



String.prototype.endsWith = function(str) 
{return (this.match(str+"$")==str)}

String.prototype.startsWith = function(str) 
{return (this.match("^"+str)==str)}

J'espère que ça aide

var myStr = “  Earth is a beautiful planet  ”;
var myStr2 = myStr.trim();  
//==“Earth is a beautiful planet”;

if (myStr2.startsWith(“Earth”)) // returns TRUE

if (myStr2.endsWith(“planet”)) // returns TRUE

if (myStr.startsWith(“Earth”)) 
// returns FALSE due to the leading spaces…

if (myStr.endsWith(“planet”)) 
// returns FALSE due to trailing spaces…

la manière traditionnelle

function strStartsWith(str, prefix) {
    return str.indexOf(prefix) === 0;
}

function strEndsWith(str, suffix) {
    return str.match(suffix+"$")==suffix;
}

8
2017-10-17 10:55



if( ("mystring#").substr(-1,1) == '#' )

-- Ou --

if( ("mystring#").match(/#$/) )

7
2017-11-11 11:26