Regex chaîne se termine avec pas de travail en Javascript

Je ne suis pas très familier avec la regex. J'étais en train de tester si une chaîne de caractères se termine par une autre chaîne. Le code ci-dessous renvoie la valeur null lorsque je m'attendais à vrai. Quel est le problème avec le code?

var id = "John";
var exists  ="blahJohn".match(/id$/);
alert(exists);

OriginalL'auteur Tony_Henrich | 2011-02-14

javascript regex

19

Bien, avec cette approche, vous devez utiliser le RegExp constructeur, pour construire une expression régulière à l'aide de votre id variable:
```
var id = "John";
var exists = new RegExp(id+"$").test("blahJohn");
alert(exists);
```
Mais il existe de nombreuses façons d'y parvenir, par exemple, vous pouvez prendre le dernier id.length caractères de la chaîne, et de la comparer avec id:
```
var id = "John";
var exist = "blahJohn".slice(-id.length) == id; //true
```
var id = "Ke$ha";

OriginalL'auteur CMS
4

Vous devez utiliser un RegExp() objet de faire, pas un littéral:
```
var id = "John",
    reg = new RegExp(id+"$");

alert( reg.test("blahJon") );
```
Qui est, si vous ne connaissez pas la valeur de test pour l'avance de l'exécution. Sinon, vous pouvez faire:
```
alert( /John$/.test("blahJohn") );
```
Devrait être /Jean -$/.test("blahJohn")

OriginalL'auteur James Sumners
1

De la plus belle façon de le faire est d'utiliser RegExp.test:
```
(new RegExp(id + '$')).test('blahJohn'); //true
(new RegExp(id + '$')).test('blahJohnblah'); //false
```
Encore plus sympa serait de construire une fonction simple comme ceci:
```
function strEndsWith (haystack, needle) {
    return needle === haystack.substr(0 - needle.length);
}

strEndsWith('blahJohn', id); //true
strEndsWith('blahJohnblah', id); //false
```
Le substr méthode sur IE < 9 est buggé, il ne peut pas gérer les négatifs des indices, par exemple, les essais de: 'abc'.substr(-1) == 'c' échoue, c'est à dire du substr retourne l'ensemble de la chaîne. Je recommanderais le slice à la place. Des acclamations.
Merci. Je ne vais pas la changer, car votre réponse est acceptée.

OriginalL'auteur lonesomeday
0

Essayer ce -
```
var reg = "/" + id + "$/";
var exists  ="blahJohn".match(reg);
```
Il ne fonctionne pas.
Pourquoi ne pas ce travail? Pouvez-vous m'expliquer s'il vous plaît? Je pense que cela devrait fonctionner.

OriginalL'auteur Sachin Shanbhag

var id = new RegExp("John");
var exists  ="blahJohn".match(id);
alert(exists);

essayer cette

OriginalL'auteur Stewie Griffin

0

Pourquoi utiliser RegExp? Son cher.
```
function EndsWith( givenStr, subst )
{
var ln = givenStr.length;
var idx = ln-subst.length;
return ( giventStr.subst(idx)==subst );
}
```
Beaucoup plus facile et rentable, est-il?

cela ne fonctionnera pas si la chaîne est blahJohnblah
c'est toute la question, votre réponse est incorrecte

OriginalL'auteur Alexander Sobolev
0

J'aime @lonesomeday 's solution, mais je suis fan de l'extension de la Chaîne.prototype dans ces scénarios. Voici mon adaptation de sa solution
```
String.prototype.endsWith = function (needle) {
     return needle === this.substr(0 - needle.length);
}
```
Donc peut être vérifié avec
```
if(myStr.endsWith("test")) //Do awesome things here. 
```
Savoureux...

OriginalL'auteur stephen mc

Si vous en avez besoin pour remplacer la fonction, examiner cette regExp:

var eventStr = "Hello% World%";

eventStr = eventStr.replace(/[\%]$/, "").replace(/^[\%]/, ""); //replace eds with, and also start with %.

//sortie: eventStr = "Bonjour% Monde";

OriginalL'auteur Dudi

0
```
var id = "John";

(new RegExp(`${id}$`)).test('blahJohn');  //true
(new RegExp(`${id}$`)).test('blahJohna'); //false
```
`${id}$` est un code JavaScript Modèle de chaînes de caractères qui sera compilé pour " Jean -$'.

La $ après Jean en RegExp est synonyme de la fin de la chaîne donc testé chaîne ne doit pas avoir quoi que ce soit après l'id de la valeur (c'est à dire John) afin de faire passer le test.

new RegExp(`${id}$`) - permettra de compiler pour /John$/ (donc si l'id ne doit pas être dynamique, vous pouvez simplement utiliser /Jean - $/à la place de new RegExp(`${id}$`) )

Merci pour cet extrait de code, qui peut fournir une aide immédiate. Une explication correcte améliorerait grandement sa valeur éducative, en montrant pourquoi est-ce une bonne solution au problème, et de le rendre plus utile pour les futurs lecteurs similaires, mais pas identiques, les questions. Merci de modifier votre réponse à ajouter explication, et de donner une indication de ce que les limites et les hypothèses s'appliquent.
Cool, en fait :). Espérons que l'explication que j'ai ajouté les aide à comprendre la solution.

OriginalL'auteur Alexander

-1

Ici est une chaîne de prototype de la fonction qui utilise des regex. Vous pouvez l'utiliser pour vérifier si un objet chaîne de caractères se termine par un particulier de la chaîne de valeur:

Prototype de la fonction:

String.prototype.endsWith = function (endString) {
    if(this && this.length) {
        result = new RegExp(endString + '$').test(this);
        return result;
    }
    return false;
}

Exemple D'Utilisation:

var s1 = "My String";
s1.endsWith("ring"); //returns true;
s1.endsWith("deez"); //returns false;

Vous devez expliquer pourquoi ceci répond à la question.

OriginalL'auteur Ben Ronan

Vous devez vous connecter pour publier un commentaire.