javascript endswith




endsWith en JavaScript (20)

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

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 une méthode endsWith() 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?


7 ans, mais je n'ai pas été en mesure de comprendre les quelques premiers posts, car ils sont complexes. J'ai donc écrit ma propre solution:

function strEndsWith(str, endwith)
{
    var lastIndex = url.lastIndexOf(endsWith);
    var result = false;
    if (lastIndex > 0 && (lastIndex + "registerc".length) == url.length)
    {
        result = true;
    }
    return result;
}

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

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

Cela se base sur la réponse acceptée de @ charkit permettant soit un tableau de chaînes, soit une chaîne de caractères à 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 underscorejs - mais peut probablement être ajusté pour supprimer la dépendance de soulignement.


De developer.mozilla.org https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Résumé

La méthode endsWith() 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 : Recherche dans cette chaîne comme si cette chaîne était seulement 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


Il a été de nombreuses années pour cette question. Permettez-moi d'ajouter une mise à jour importante pour les utilisateurs qui veulent utiliser la réponse de chakrit la plus votée.

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

Reportez-vous ici: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

D'où il est fortement recommandé d'ajouter vérifier l'existence de l'implémentation native comme mentionné dans la réponse.


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

http://stringjs.com/

Incluez le fichier js, puis utilisez la variable S comme ceci:

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

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

npm install string

Puis l'exigeant comme la variable S :

var S = require('string');

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


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

N'a pas vu apporach avec la méthode de slice . Donc, je suis juste laisser ici:

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

N'utilisez pas d'expressions régulières. Ils sont lents même dans des langues rapides. Il suffit d'écrire 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 la façon de le faire: groundjs/prototype.js En général, il s'agit d'une belle bibliothèque au niveau du langage: groundjs Vous pouvez aussi jeter un oeil à lodash


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

Si vous utilisez lodash :

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

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


Un moyen de prouver l'avenir et / ou d'empêcher l'écrasement du prototype existant serait de vérifier si cela a déjà été ajouté au prototype String. Voici mon avis sur la version non-regex hautement cotée.

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

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

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


/#$/.test(str)

fonctionnera sur tous les navigateurs, ne nécessite pas de String correction de singe, et ne nécessite pas l'analyse de la chaîne entière comme lastIndexOf 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 '$' , 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)

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

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

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

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

  return false;
}

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 longues cordes. Voici un test de vitesse http://jsperf.com/starts-ends-with/4
  • Entièrement compatible avec la spécification ecmascript. Il passe les tests

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




ends-with