web-dev-qa-db-fra.com

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 ficelle

var str = "mystring#";

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

  1. Existe-t-il une méthode endsWith() en JavaScript?

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

Est-ce le meilleur moyen ou il existe un autre moyen?

javascriptstringends-with
1073
Bobby Kumar

UPDATE (24 novembre 2015):

Cette réponse a été publiée pour la première fois en 2010 (il y a six ans). Veuillez donc prendre note de ces commentaires éclairants:

RÉPONSE ORIGINALE:

Je sais que cette question remonte à un an ... mais j'en ai aussi besoin et je dois le faire fonctionner 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 fonction native indexOf pour des résultats rapides
  • Sautez les comparaisons inutiles en utilisant le deuxième paramètre de indexOf pour avancer.
  • Fonctionne dans Internet Explorer
  • Pas de complications de regex

De plus, si vous n'aimez pas insérer des éléments dans les prototypes de structure de données native, voici une version autonome:

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

EDIT: Comme l'a souligné @hamish dans les commentaires, si vous voulez vous tromper de sécurité et vérifier si une mise en oeuvre a déjà été fournie, vous pouvez ajoute simplement un typeof check comme ceci:

if (typeof String.prototype.endsWith !== 'function') {
    String.prototype.endsWith = function(suffix) {
        return this.indexOf(suffix, this.length - suffix.length) !== -1;
    };
}
1748
chakrit
/#$/.test(str)

fonctionnera sur tous les navigateurs, ne nécessite pas de correctif de la part de singe String, et ne nécessite pas d'analyser la chaîne entière comme le fait lastIndexOf lorsqu'il n'y a pas de correspondance.

Si vous souhaitez faire correspondre une chaîne constante pouvant 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 alors vous pouvez l'utiliser comme ça

makeSuffixRegExp("a[complicated]*suffix*").test(str)
291
Mike Samuel
  1. Malheureusement non.
  2. if( "mystring#".substr(-1) === "#" ) {}
87
Phillip B Oldham

Allez, ceci est la bonne implémentation endsWith:

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

utiliser lastIndexOf crée simplement des boucles de calcul inutiles s’il n’ya pas de correspondance.

66
Oskar Liljeblad

Cette version évite de créer une sous-chaîne et n’utilise pas d’expressions régulières (certaines réponses rationnelles 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 serait utile de vérifier si lastIndexOf est réellement plus rapide que la création d'une sous-chaîne ou non. (Cela peut bien 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, il faut même regarder en arrière bien que cela ne nous dérange pas vraiment :(

Pour vérifier un seul caractère, il est probablement préférable de rechercher la longueur, puis d'utiliser charAt.

56
Jon Skeet

Je n'ai pas vu l'approche avec la méthode slice. Donc, je le laisse juste ici:

function endsWith(str, suffix) {
    return str.slice(-suffix.length) === suffix
}
24
Nikita Koksharov
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 1 à la longueur de la chaîne de recherche et que celle-ci est introuvable:

lastIndexOf renvoie -1, puis vous ajoutez la longueur de la chaîne de recherche et vous restez 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
17
user73745

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

Sommaire

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

Syntaxe

str.endsWith(searchString [, position]);

Paramètres

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

  • position : Effectuez une recherche dans cette chaîne comme si cette chaîne était longue. La valeur par défaut est la longueur réelle de cette chaîne, fixée dans la plage définie 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

Spécification de langage ECMAScript, 6e édition (ECMA-262)

Compatibilité du navigateur

Browser compatibility

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

-- Ou --

if( ("mystring#").match(/#$/) )
9
duckyflip
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
Mohammed Rafeeq

Je ne sais pas pour vous, mais:

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

Pourquoi les expressions régulières? Pourquoi jouer avec le prototype? substrat? Allons y...

7
Tici

Si vous utilisez lodash :

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

Si vous n'utilisez pas lodash, vous pouvez emprunter auprès de source .

7
Dheeraj V.S.

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
6
Vinicius

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

Ensuite, en tant que 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 convient pas.

6
Ashley Davis

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 le plus voté.

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

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

Il est donc vivement recommandé d’ajouter une vérification de l’existence d’une implémentation native, comme indiqué dans la réponse.

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

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

  return false;
}
4
Tabish Usman

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 '#'
}
4
LahiruBandara
function check(str)
{
    var lastIndex = str.lastIndexOf('/');
    return (lastIndex != -1) && (lastIndex  == (str.length - 1));
}
2
manish

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

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

Un moyen de vérifier et/ou d’empêcher l’écrasement du prototype existant serait de vérifier si celui-ci a déjà été ajouté au prototype String. Voici mon point de vue sur la version très bien notée sans regex.

if (typeof String.endsWith !== 'function') {
    String.prototype.endsWith = function (suffix) {
        return this.indexOf(suffix, this.length - suffix.length) !== -1;
    };
}
2
Dan Doyon
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)/));
1
Ebubekir Dirican

Ceci est l'implémentation de endsWith:

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

1
Atuljssaten

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

Ceci est l'implémentation de endsWith: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }

1
Atuljssaten

Après toutes ces longues réponses, j'ai trouvé ce morceau de code simple et facile à comprendre!

function end(str, target) {
  return str.substr(-target.length) == target;
}
1
immazharkhan
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 de longues cordes. Voici un test de vitesse http://jsperf.com/starts-ends-with/4
  • Entièrement compatible avec la spécification ecmascript. Il passe le tests
0
termi

7 ans, mais je n’étais pas capable de comprendre les quelques top 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;
}
0
faisalbhagat

Pour le café

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

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

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

0
Bobby Kumar

Ceci 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 caractères de soulignement - mais peut probablement être ajusté pour supprimer la dépendance de soulignement.

0
Matthew Brown

N'utilisez pas d'expressions régulières. Ils sont lents même dans les langues rapides. Il suffit d'écrire une fonction qui vérifie la fin d'une chaîne. Cette bibliothèque a de beaux exemples: groundjs/util.js . Faites attention en ajoutant une fonction à String.prototype. Ce code contient des exemples Nice de la façon de le faire: groundjs/prototype.js En général, il s'agit d'une bibliothèque de niveaux de langage Nice: groundjs Vous pouvez également consulter lodash

0
Daniel Nuriyev