javascript - style - title label html

termina con JavaScript

Question

¿Cómo puedo verificar si una cadena termina con un carácter particular en JavaScript?

Ejemplo: tengo una cadena

var str = "mystring#";

Quiero saber si esa cadena termina con # . ¿Cómo puedo comprobarlo?

1. ¿Hay un método endsWith() en JavaScript?

2. Una de las soluciones que tengo es tomar la longitud de la cadena y obtener el último carácter y verificarlo.

¿Es esta la mejor manera o hay alguna otra manera?

Answer 1

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

Answer 2

Acabo de enterarme de esta biblioteca de cadenas:

http://stringjs.com/

Incluya el archivo js y luego use la variable S como esta:

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

También se puede utilizar en NodeJS al instalarlo:

npm install string

Entonces requiriéndolo como la variable S :

var S = require(''string'');

La página web también tiene enlaces a bibliotecas de cadenas alternativas, si esta no le interesa.

Answer 3

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

Resumen

El método endsWith() determina si una cadena termina con los caracteres de otra cadena, devolviendo verdadero o falso según sea apropiado.

Sintaxis

str.endsWith(searchString [, position]);

Parámetros

• searchString : los caracteres que se buscarán al final de esta cadena.

• posición : busque dentro de esta cadena como si esta cadena fuera tan larga; por defecto, la longitud real de esta cadena, sujeta dentro del rango establecido por la longitud de esta cadena.

Descripción

Este método le permite determinar si una cadena termina o no con otra cadena.

Ejemplos

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

Presupuesto

Especificación del lenguaje ECMAScript 6ª edición (ECMA-262)

Compatibilidad del navegador

Answer 4

Después de todo ese largo conteo de respuestas, ¡encontré esta pieza de código simple y fácil de entender!

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

Answer 5

Esta es la implementación de endsWith:

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

Answer 6

Esta versión evita la creación de una subcadena, y no usa expresiones regulares (algunas respuestas a expresiones regulares aquí funcionarán; otras no funcionarán):

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

Si el rendimiento es importante para usted, valdría la pena probar si lastIndexOf es realmente más rápido que crear una subcadena o no. (Puede depender del motor JS que use ...) Puede ser más rápido en el caso correspondiente, y cuando la cadena es pequeña, pero cuando la cadena es enorme, debe mirar hacia atrás a través de todo. aunque realmente no nos importa :(

Para verificar un solo carácter, encontrar la longitud y luego usar el carácter es probablemente la mejor manera.

Answer 7

Esto se basa en la respuesta aceptada de @ charkit y permite que una matriz de cadenas o una cadena se pase como argumento.

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

Esto requiere guiones bajos, pero probablemente se puede ajustar para eliminar la dependencia del guión bajo.

Answer 8

Han pasado muchos años para esta pregunta. Permítame agregar una actualización importante para los usuarios que quieran usar la respuesta de chakrit más votada.

Las funciones ''endsWith'' ya se agregaron a JavaScript como parte de ECMAScript 6 (tecnología experimental)

Consulte aquí: https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

Por lo tanto, se recomienda encarecidamente agregar verificación para la existencia de implementación nativa como se menciona en la respuesta.

Answer 9

La respuesta aceptada de @chakrit es una forma sólida de hacerlo usted mismo. Sin embargo, si está buscando una solución empaquetada, recomiendo echar un vistazo a underscore.string , como lo señaló @mlunoe. Usando underscore.string, el código sería:

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

Answer 10

No sé de ti, pero:

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

¿Por qué las expresiones regulares? ¿Por qué meterse con el prototipo? substr? vamos...

Answer 11

No utilice expresiones regulares. Son lentos incluso en idiomas rápidos. Solo escribe una función que verifique el final de una cadena. Esta biblioteca tiene buenos ejemplos: groundjs/util.js Tenga cuidado al agregar una función a String.prototype. Este código tiene buenos ejemplos de cómo hacerlo: groundjs/prototype.js En general, esta es una buena biblioteca a nivel de idioma: groundjs También puede echar un vistazo a lodash

Answer 12

No vimos apporach con el método de la slice . Así que sólo lo dejo aquí:

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

Answer 13

Para coffeescript

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

Answer 14

Si estás usando lodash :

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

Si no usa lodash, puede pedir prestado de su source .

Answer 15

Si no desea utilizar lasIndexOf o substr, entonces ¿por qué no mirar la cadena en su estado natural (es decir, una matriz)?

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

o como una función independiente

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

Answer 16

Solo otra alternativa rápida que funcionó como un encanto para mí, usando regex:

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

Answer 17

Tantas cosas para un problema tan pequeño, solo use esta expresión regular

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

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

Answer 18

Todos ellos son ejemplos muy útiles. Agregar String.prototype.endsWith = function(str) nos ayudará a simplemente llamar al método para verificar si nuestra cadena termina con eso o no, así que regexp también lo hará.

Encontré una solución mejor que la mía. Gracias a todos.

Answer 19

Una forma de probar en el futuro y / o evitar la sobrescritura del prototipo existente sería una verificación de prueba para ver si ya se ha agregado al prototipo String. Aquí está mi opinión sobre la versión de alta calificación no regex.

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

Answer 20

Una publicación de 7 años, pero no pude entender las pocas publicaciones principales, porque son complejas. Entonces, escribí mi propia solución:

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

Answer 21

Vamos, este es el endsWith correcto endsWith implementación:

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

el uso de lastIndexOf simplemente crea bucles de CPU innecesarios si no hay coincidencia.

Answer 22

ACTUALIZACIÓN (24 de noviembre de 2015):

Esta respuesta se publicó originalmente en el año 2010 (SEIS años atrás). Por lo tanto, tome nota de estos comentarios perspicaces:

• Shauna - Actualización para Googlers - Parece que ECMA6 agrega esta función. El artículo de MDN también muestra un polyfill. https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/endsWith

• TJ Crowder : crear subcadenas no es costoso en los navegadores modernos; bien puede haber sido en 2010 cuando se publicó esta respuesta. En estos días, el this.substr(-suffix.length) === suffix simple de this.substr(-suffix.length) === suffix es el más rápido en Chrome, el mismo en IE11 como indexOf, y solo un 4% más lento (territorio de fergetabitit) en Firefox: jsperf.com/endswith-/14 Y más rápido a través del tablero cuando el resultado es falso: jsperf.com/endswith--when-false Por supuesto, con ES6 agregando endsWith, el punto es discutible. :-)

RESPUESTA ORIGINAL:

Sé que esta es una pregunta de hace un año ... pero también la necesito y la necesito para que funcione en múltiples navegadores, así que ... combinando las respuestas y los comentarios de todos y simplificándolos un poco:

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

• No crea una subcadena
• Utiliza la función nativa indexOf para resultados más rápidos
• Omita las comparaciones innecesarias utilizando el segundo parámetro de indexOf para saltar hacia adelante
• Funciona en Internet Explorer
• NO hay complicaciones Regex

Además, si no te gusta rellenar cosas en prototipos de estructuras de datos nativos, aquí hay una versión independiente:

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

EDITAR: Según lo señalado por @hamish en los comentarios, si desea errar en el lado seguro y verificar si ya se ha proporcionado una implementación, puede agregar un tipo de verificación como:

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

Answer 23

/#$/.test(str)

funcionará en todos los navegadores, no requiere la String parches de mono y no requiere escanear toda la cadena como lastIndexOf hace lastIndexOf cuando no hay coincidencia.

Si desea hacer coincidir una cadena constante que pueda contener caracteres especiales de expresiones regulares, como ''$'' , puede usar lo siguiente:

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

y luego puedes usarlo así

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

Answer 24

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

Answer 25

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

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

espero que esto ayude

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 forma tradicional

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

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

Answer 26

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

Answer 27

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

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

  return false;
}

Answer 28

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

- o -

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

Answer 29

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

Beneficios:

• Esta versión no es solo la reutilización de indexOf.
• El mejor rendimiento en cuerdas largas. Aquí hay una prueba de velocidad http://jsperf.com/starts-ends-with/4
• Totalmente compatible con la especificación de ecmascript. Pasa las tests

Answer 30

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

no funciona en el caso de que la longitud de la cadena original sea menor que la longitud de la cadena de búsqueda y no se encuentre la cadena de búsqueda:

lastIndexOf devuelve -1, luego agrega la longitud de la cadena de búsqueda y queda con la longitud de la cadena original.

Una posible solución es

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