finisce con JavaScript

Come posso verificare se una stringa termina con un carattere particolare in JavaScript?

Esempio: ho una stringa

var str = "mystring#";

Voglio sapere se quella stringa sta finendo #. Come posso controllarlo?

1. Esiste un endsWith()metodo in JavaScript?

2. Una soluzione che ho è prendere la lunghezza della stringa e ottenere l'ultimo carattere e controllarlo.

È questo il modo migliore o c'è un altro modo?

AGGIORNAMENTO (24 novembre 2015):

Questa risposta è stata originariamente pubblicata nell'anno 2010 (SIX anni fa.) Quindi prendi nota di questi commenti perspicaci:

• Shauna - Aggiornamento per googler - Sembra che ECMA6 abbia aggiunto questa funzione. L'articolo MDN mostra anche un polyfill. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• TJ Crowder - La creazione di sottostringhe non è costosa sui browser moderni; potrebbe essere stato nel 2010 quando questa risposta è stata pubblicata. Al giorno d'oggi, l' this.substr(-suffix.length) === suffixapproccio semplice è più veloce su Chrome, lo stesso su IE11 di indexOf, e solo il 4% più lento (territorio fergetaboutit) su Firefox: jsperf.com/endswith-stackoverflow/14 E più veloce su tutta la linea quando il risultato è falso: jsperf.com/endswith-stackoverflow-when-false Naturalmente, con ES6 che aggiunge le estremità Con il punto è controverso. :-)

RISPOSTA ORIGINALE:

So che questa è una domanda di un anno ... ma ne ho bisogno anche io e ne ho bisogno per funzionare su più browser, quindi ... combinando la risposta e i commenti di tutti e semplificandola un po ':

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

• Non crea una sottostringa
• Utilizza la indexOffunzione nativa per risultati più rapidi
• Salta i confronti non necessari utilizzando il secondo parametro di indexOfper saltare in avanti
• Funziona in Internet Explorer
• NO complicazioni Regex

Inoltre, se non ti piace inserire oggetti nei prototipi della struttura di dati nativi, ecco una versione autonoma:

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

EDIT: Come notato da @hamish nei commenti, se vuoi sbagliare sul lato sicuro e verificare se un'implementazione è già stata fornita, puoi semplicemente aggiungere un typeofcontrollo in questo modo:

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

/#$/.test(str)

funzionerà su tutti i browser, non richiede patch scimmia Stringe non richiede la scansione dell'intera stringa come lastIndexOfquando non c'è corrispondenza.

Se si desidera abbinare una stringa costante che potrebbe contenere caratteri speciali di espressioni regolari, ad esempio '$', è possibile utilizzare quanto segue:

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

e quindi puoi usarlo in questo modo

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

1. Sfortunatamente no.
2. if( "mystring#".substr(-1) === "#" ) {}

Dai, questa è l' endsWithimplementazione corretta :

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

l'utilizzo lastIndexOfcrea semplicemente cicli CPU non necessari se non vi è corrispondenza.

Questa versione evita di creare una sottostringa e non usa espressioni regolari (alcune risposte regex qui funzioneranno; altre sono rotte):

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

Se le prestazioni sono importanti per te, varrebbe la pena testare se lastIndexOfè effettivamente più veloce della creazione di una sottostringa o meno. (Potrebbe dipendere dal motore JS che stai usando ...) Potrebbe essere più veloce nel caso di abbinamento, e quando la stringa è piccola - ma quando la stringa è enorme deve guardare indietro attraverso tutto anche se non ci interessa davvero :(

Per controllare un singolo carattere, trovare la lunghezza e quindi usare charAtè probabilmente il modo migliore.

Non ho visto l'apporach con il slicemetodo. Quindi lo lascio qui:

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

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

non funziona nel caso in cui la lunghezza della stringa originale sia inferiore alla lunghezza della stringa di ricerca e la stringa di ricerca non venga trovata:

lastIndexOf restituisce -1, quindi aggiungi la lunghezza della stringa di ricerca e ti rimane la lunghezza della stringa originale.

Una possibile soluzione è

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

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

Sommario

Il endsWith()metodo determina se una stringa termina con i caratteri di un'altra stringa, restituendo vero o falso come appropriato.

Sintassi

str.endsWith(searchString [, position]);

parametri

• searchString : i caratteri da cercare alla fine di questa stringa.

• posizione : cerca all'interno di questa stringa come se questa stringa fosse solo così lunga; il valore predefinito è la lunghezza effettiva di questa stringa, bloccata nell'intervallo stabilito dalla lunghezza di questa stringa.

Descrizione

Questo metodo consente di determinare se una stringa termina o meno con un'altra stringa.

Esempi

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

specificazioni

ECMAScript Language Specification 6th Edition (ECMA-262)

Compatibilità del browser

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

-- O --

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

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

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

spero che questo possa essere d'aiuto

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…

il modo tradizionale

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

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

Non ti conosco, ma:

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

Perché espressioni regolari? Perché scherzare con il prototipo? substr? Andiamo, forza...

Solo un'altra rapida alternativa che ha funzionato come un incantesimo per me, usando regex:

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

Se stai usando lodash :

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

Se non usi lodash, puoi prendere in prestito dalla sua fonte .

Ho appena imparato a conoscere questa libreria di stringhe:

http://stringjs.com/

Includi il file js e usa la Svariabile in questo modo:

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

Può anche essere utilizzato in NodeJS installandolo:

npm install string

Quindi richiedendolo come Svariabile:

var S = require('string');

La pagina web contiene anche collegamenti a librerie di stringhe alternative, se questa non ti piace.

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

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

  return false;
}

Tante cose per un problema così piccolo, basta usare questa espressione regolare

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

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

Sono passati molti anni per questa domanda. Vorrei aggiungere un aggiornamento importante per gli utenti che desiderano utilizzare la risposta del chakrit più votata.

Le funzioni 'EndWith' sono già state aggiunte a JavaScript come parte di ECMAScript 6 (tecnologia sperimentale)

Riferiscilo qui: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Pertanto si consiglia vivamente di aggiungere il controllo dell'esistenza dell'implementazione nativa, come indicato nella risposta.

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

Un modo per la prova futura e / o impedire la sovrascrittura del prototipo esistente sarebbe il test di verifica per vedere se è già stato aggiunto al prototipo String. Ecco la mia opinione sulla versione molto apprezzata non regex.

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

La risposta accettata di @ chakrit è un modo solido per farlo da soli. Se, tuttavia, stai cercando una soluzione in pacchetto, ti consiglio di dare un'occhiata a underscore.string , come ha sottolineato @mlunoe. Usando underscore.string, il codice sarebbe:

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

se non vuoi usare lasIndexOf o substr allora perché non guardare semplicemente la stringa nel suo stato naturale (es. un array)

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

o come funzione autonoma

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

Dopo tutte quelle lunghe risposte, ho trovato questo pezzo di codice semplice e facile da capire!

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

Questa è l'implementazione di EndWith: String.prototype.endsWith = function (str) { return this.length >= str.length && this.substr(this.length - str.length) == str; }

Questa è l'implementazione di endsWith:

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

Questo si basa sulla risposta accettata di @ charkit che consente a una matrice di stringhe o alla stringa di passare come argomento.

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

Ciò richiede underscorejs, ma probabilmente può essere regolato per rimuovere la dipendenza del trattino basso.

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

Benefici:

• Questa versione non sta semplicemente riutilizzando indexOf.
• Massime prestazioni su corde lunghe. Ecco un test di velocità http://jsperf.com/starts-ends-with/4
• Pienamente compatibile con le specifiche ecmascript. Supera i test

Non usare espressioni regolari. Sono lenti anche nelle lingue veloci. Basta scrivere una funzione che controlla la fine di una stringa. Questa libreria ha belle esempi: groundjs / util.js . Fare attenzione ad aggiungere una funzione a String.prototype. Questo codice contiene dei bei esempi su come farlo: groundjs / prototype.js In generale, questa è una bella libreria a livello linguistico: groundjs Puoi anche dare un'occhiata a lodash

tutti sono esempi molto utili. AggiuntaString.prototype.endsWith = function(str) ci aiuterà a chiamare semplicemente il metodo per verificare se la nostra stringa finisce con essa o meno, anche regexp lo farà.

Ho trovato una soluzione migliore della mia. Grazie a tutti.

Per coffeescript

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