se termine avec JavaScript

Comment puis-je vérifier si une chaîne se termine par un caractère particulier en 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. Existe-t-il une 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 le meilleur moyen ou existe-t-il un autre moyen?

MISE À JOUR (24 novembre 2015):

Cette réponse a été initialement publiée en 2010 (SIX ans en arrière). Veuillez donc prendre note de ces commentaires perspicaces:

• Shauna - Mise à jour pour Googlers - On dirait que ECMA6 ajoute cette fonction. L'article MDN montre également un polyfill. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• TJ Crowder - La création de sous-chaînes n'est pas chère sur les navigateurs modernes; c'était peut-être en 2010 lorsque cette réponse a été publiée. De nos jours, l' this.substr(-suffix.length) === suffixapproche simple est la plus rapide sur Chrome, la même sur IE11 que indexOf, et seulement 4% plus lente (territoire fergetaboutit) sur Firefox: jsperf.com/endswith-stackoverflow/14 Et plus rapide dans tous les cas lorsque le résultat est faux: jsperf.com/endswith-stackoverflow-when-false Bien sûr, avec ES6 ajoutant des finsAvec, le point est sans objet. :-)

RÉPONSE ORIGINALE:

Je sais que c'est une question vieille d'un an ... mais j'en ai aussi besoin et j'en ai besoin pour travailler sur plusieurs navigateurs donc ... en combinant la réponse et les commentaires de chacun 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 la indexOffonction native pour des résultats plus rapides
• Ignorez les comparaisons inutiles en utilisant le deuxième paramètre de indexOfpour avancer
• Fonctionne dans Internet Explorer
• AUCUNE complication Regex

De plus, 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;
}

EDIT: Comme indiqué par @hamish dans les commentaires, si vous voulez vous tromper et vérifier si une implémentation a déjà été fournie, vous pouvez simplement ajouter une typeofvérification comme ceci:

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

/#$/.test(str)

fonctionnera sur tous les navigateurs, ne nécessite pas de correction de singe Stringet ne nécessite pas d'analyser la chaîne entière comme lastIndexOfil 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 '$', vous pouvez utiliser les éléments suivants:

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

et vous pouvez l'utiliser comme ceci

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

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

Allez, c'est la bonne endsWithmise en œuvre:

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

l'utilisation lastIndexOfcrée simplement des boucles CPU inutiles s'il n'y a pas de correspondance.

Cette version évite de créer une sous-chaîne et n'utilise pas d'expressions régulières (certaines réponses d'expression régulière fonctionneront 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 les performances sont importantes pour vous, il vaudrait la peine de vérifier si lastIndexOf sont réellement plus rapides que la création d'une sous-chaîne ou non. (Cela peut dépendre du moteur JS que vous utilisez ...) Cela peut être plus rapide dans le cas correspondant, et lorsque la chaîne est petite - mais lorsque la chaîne est énorme, elle doit regarder en arrière, même mais on s'en fout vraiment :(

Pour vérifier un seul caractère, trouver la longueur puis l'utiliser charAtest probablement le meilleur moyen.

Je n'ai pas vu d'approches avec la sliceméthode. Je laisse donc ça ici:

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

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 de un à la longueur de la chaîne de recherche et la chaîne de recherche est introuvable:

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

Une solution possible est

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

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

Sommaire

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

Syntaxe

str.endsWith(searchString [, position]);

Paramètres

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

• position : Rechercher dans cette chaîne comme si cette chaîne n'était que longue; par défaut, la longueur réelle de cette chaîne, fixé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 ou non 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 6th Edition (ECMA-262)

Compatibilité du navigateur

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

-- Ou --

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

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

Je ne sais pas pour vous, mais:

var s = "mystring#";
s.length >= 1 && s[s.length - 1] == '#'; // will do the thing!

Pourquoi des expressions régulières? Pourquoi jouer avec le prototype? substr? Allons y...

Juste une autre alternative rapide qui a fonctionné comme un charme pour moi, en utilisant regex:

// Would be equivalent to:
// "Hello World!".endsWith("World!")
"Hello World!".match("World!$") != null

Si vous utilisez lodash :

_.endsWith('abc', 'c'); // true

Si vous n'utilisez pas lodash, vous pouvez emprunter à sa source .

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.

function strEndsWith(str,suffix) {
  var reguex= new RegExp(suffix+'$');

  if (str.match(reguex)!=null)
      return true;

  return false;
}

Tant de choses pour un si petit problème, utilisez simplement cette expression régulière

var str = "mystring#";
var regex = /^.*#$/

if (regex.test(str)){
  //if it has a trailing '#'
}

Cela fait de nombreuses années pour cette question. Permettez-moi d'ajouter une mise à jour importante pour les utilisateurs qui souhaitent utiliser la réponse du chakrit la plus votée.

Les fonctions 'endsWith' sont déjà ajoutées à JavaScript dans le cadre d'ECMAScript 6 (technologie expérimentale)

Référez-le ici: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Par conséquent, il est fortement recommandé d'ajouter une vérification de l'existence d'une implémentation native comme mentionné dans la réponse.

function check(str)
{
    var lastIndex = str.lastIndexOf('/');
    return (lastIndex != -1) && (lastIndex  == (str.length - 1));
}

Un moyen de pérenniser et / ou d'empêcher l'écrasement du prototype existant serait de vérifier le test pour voir s'il a déjà été ajouté au prototype String. Voici mon point de vue sur la version très appréciée non regex.

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

La réponse acceptée de @ chakrit est un moyen solide de le faire vous-même. Si, cependant, vous recherchez une solution packagée, je vous recommande de jeter un œil à underscore.string , comme l'a souligné @mlunoe. En utilisant underscore.string, le code serait:

function endsWithHash(str) {
  return _.str.endsWith(str, '#');
}

si vous ne voulez pas utiliser lasIndexOf ou substr, alors pourquoi ne pas simplement regarder la chaîne dans son état naturel (c'est-à-dire un tableau)

String.prototype.endsWith = function(suffix) {
    if (this[this.length - 1] == suffix) return true;
    return false;
}

ou en tant que fonction autonome

function strEndsWith(str,suffix) {
    if (str[str.length - 1] == suffix) return true;
    return false;
}

String.prototype.endWith = function (a) {
    var isExp = a.constructor.name === "RegExp",
    val = this;
    if (isExp === false) {
        a = escape(a);
        val = escape(val);
    } else
        a = a.toString().replace(/(^\/)|(\/$)/g, "");
    return eval("/" + a + "$/.test(val)");
}

// example
var str = "Hello";
alert(str.endWith("lo"));
alert(str.endWith(/l(o|a)/));

Après tout ce long décompte de réponses, j'ai trouvé ce morceau de code simple et facile à comprendre!

function end(str, target) {
  return str.substr(-target.length) == target;
}

Ceci est la mise en œuvre de endsWith: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }

Il s'agit de la mise en œuvre de endsWith:

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

Cela s'appuie sur la réponse acceptée de @ charkit permettant à un tableau de chaînes ou à une chaîne de passer en argument.

if (typeof String.prototype.endsWith === 'undefined') {
    String.prototype.endsWith = function(suffix) {
        if (typeof suffix === 'String') {
            return this.indexOf(suffix, this.length - suffix.length) !== -1;
        }else if(suffix instanceof Array){
            return _.find(suffix, function(value){
                console.log(value, (this.indexOf(value, this.length - value.length) !== -1));
                return this.indexOf(value, this.length - value.length) !== -1;
            }, this);
        }
    };
}

Cela nécessite des traits de soulignement - mais peut probablement être ajusté pour supprimer la dépendance de soulignement.

if(typeof String.prototype.endsWith !== "function") {
    /**
     * String.prototype.endsWith
     * Check if given string locate at the end of current string
     * @param {string} substring substring to locate in the current string.
     * @param {number=} position end the endsWith check at that position
     * @return {boolean}
     *
     * @edition ECMA-262 6th Edition, 15.5.4.23
     */
    String.prototype.endsWith = function(substring, position) {
        substring = String(substring);

        var subLen = substring.length | 0;

        if( !subLen )return true;//Empty string

        var strLen = this.length;

        if( position === void 0 )position = strLen;
        else position = position | 0;

        if( position < 1 )return false;

        var fromIndex = (strLen < position ? strLen : position) - subLen;

        return (fromIndex >= 0 || subLen === -fromIndex)
            && (
                position === 0
                // if position not at the and of the string, we can optimise search substring
                //  by checking first symbol of substring exists in search position in current string
                || this.charCodeAt(fromIndex) === substring.charCodeAt(0)//fast false
            )
            && this.indexOf(substring, fromIndex) === fromIndex
        ;
    };
}

Avantages:

• Cette version ne se contente pas de réutiliser indexOf.
• Meilleure performance sur les cordes longues. Voici un test de vitesse http://jsperf.com/starts-ends-with/4
• Entièrement compatible avec la spécification ecmascript. Il passe les tests

N'utilisez pas d'expressions régulières. Ils sont lents même dans les langues rapides. Écrivez simplement une fonction qui vérifie la fin d'une chaîne. Cette bibliothèque a de bons exemples: groundjs / util.js . Soyez prudent en ajoutant une fonction à String.prototype. Ce code a de bons exemples de comment le faire: groundjs / prototype.js En général, c'est une belle bibliothèque au niveau du langage: groundjs Vous pouvez également jeter un œil à lodash

tous sont des exemples très utiles. AjouterString.prototype.endsWith = function(str) nous aidera à simplement appeler la méthode pour vérifier si notre chaîne se termine par ou non, bien regexp le fera également.

J'ai trouvé une meilleure solution que la mienne. Merci tout le monde.

Pour coffeescript

String::endsWith = (suffix) ->
  -1 != @indexOf suffix, @length - suffix.length