palabra - ¿Cómo comprobar si una cadena contiene una subcadena en JavaScript?




substring javascript (20)

Por lo general, esperaría un método String.contains() , pero no parece haber uno.

¿Cuál es una manera razonable de verificar esto?

https://code.i-harness.com


String.prototype.indexOf() o String.prototype.search() ?!

Como otros ya han mencionado, las cadenas de JavaScript tienen un método de search y String.prototype.indexOf .

La diferencia clave entre ambos, es que indexOf es solo para subcadenas simples, mientras que la search también admite expresiones regulares. Por supuesto, una ventaja de usar indexOf es que es más rápido.

Consulte también En JavaScript, ¿cuál es la diferencia entre indexOf () y search ()? .

Implementando su propio método String.prototype.contains()

Si desea agregar su propio método de contains a cada cadena, la mejor manera de hacerlo sería el enfoque de :

if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

Lo usarías así:

'Hello World'.contains('orl');

Implementando una biblioteca de utilidades personalizada

Por lo general, está mal visto agregar sus propios métodos personalizados a objetos estándar en JavaScript, por ejemplo, porque podría romper la compatibilidad.

Si realmente desea que su propio método de contención y / u otros métodos de cadena personalizados, es mejor crear su propia biblioteca de utilidades y agregar sus métodos de cadena personalizados a esa biblioteca:

var helper = {};

helper.string = {
    contains : function (haystack, needle) {
        return !!~haystack.indexOf(needle);
    },
    ...
};

Lo usarías así:

helper.string.contains('Hello World', 'orl');

Usando una biblioteca de utilidad de terceros

Si no desea crear su propia biblioteca auxiliar personalizada, existe, por supuesto, siempre la opción de utilizar una biblioteca de utilidades de terceros. Como mencionó , los más populares son Lodash y Underscore.js .

En Lodash, podrías usar _.includes() , que usas así:

_.includes('Hello World', 'orl');

En Underscore.js, puedes usar _.str.include() , que usas así:

_.str.include('Hello World', 'orl');

Aquí hay una lista de las posibilidades actuales:

1. (ES6) includes - ir a responder

var string = "foo",
    substring = "oo";
string.includes(substring);

2. ES5 y mayores indexOf

var string = "foo",
    substring = "oo";
string.indexOf(substring) !== -1;

String.prototype.indexOf devuelve la posición de la cadena en la otra cadena. Si no se encuentra, devolverá -1 .

3. search - ir a responder

var string = "foo",
    expr = /oo/;
string.search(expr);

4. Incluye lodash - ir a contestar

var string = "foo",
    substring = "oo";
_.includes(string, substring);

5. RegExp - ir a responder

var string = "foo",
    expr = /oo/;  // no quotes here
expr.test(string);

6. Match - ir a responder

var string = "foo",
    expr = /oo/;
string.match(expr);

Las pruebas de rendimiento muestran que indexOf podría ser la mejor opción, si se trata de un punto donde la velocidad es importante.


Como la pregunta es bastante popular, pensé que podría agregar un poco de sabor moderno al código.

// const           : creates an immutable constant
const allLinks   = document.getElementsByTagName("a");
// [].reduce.call  : gives access to the reduce method on a HTMLCollection
// () => {}        : ES6 arrow function
const foundLinks = [].reduce.call(allLinks, (sum, link) => {
     // bitwise OR : converts the boolean value to a number
     return sum + (link.classList.contains("title") | 0);
}, 0);

// template literal
console.log(`Found ${foundLinks || "no"} title class`);

Por cierto, la respuesta correcta es indexOf mal el indexOf o el indexOf no estándar. Cargar una biblioteca externa (especialmente si el código está escrito en JavaScript puro) o jugar con String.prototype o usar una expresión regular es un poco excesivo.


Debe llamar a indexOf con una "O" mayúscula como se mencionó. También se debe tener en cuenta que en la clase de JavaScript es una palabra reservada, debe usar className para obtener este atributo de datos. La razón por la que probablemente está fallando es porque está devolviendo un valor nulo. Puedes hacer lo siguiente para obtener el valor de tu clase ...

var test = elm.getAttribute("className");
//or
var test = elm.className

Ejemplo

var a  = "Test String";

if(a.search("ring")!=-1){
     //exist 
} else {
     //not found 
}

El problema con su código es que JavaScript distingue entre mayúsculas y minúsculas. Tu método de llamada

indexof()

en realidad debería ser

indexOf()

Intenta arreglarlo y ver si eso ayuda:

if (test.indexOf("title") !=-1) {
    alert(elm);
    foundLinks++;
}

En es5

var s = "foo";
alert(s.indexOf("oo") > -1);

En ES6 hay tres nuevos métodos: startsWith() , endsWith() , endsWith() .

var msg = "Hello world!";

console.log(msg.startsWith("Hello"));       // true
console.log(msg.endsWith("!"));             // true
console.log(msg.includes("o"));             // true

console.log(msg.startsWith("o", 4));        // true
console.log(msg.endsWith("o", 8));          // true
console.log(msg.includes("o", 8));          // false


En lugar de usar fragmentos de código que se encuentran aquí y allá en la web, también puede usar una biblioteca bien probada y documentada. Dos opciones recomendaría:

1ª opción: Usar Lodash : tiene un método de Lodash :

_.includes('foobar', 'ob');
// → true

Lodash es la dependencia de biblioteca javascript más popular para npm y tiene muchos métodos prácticos de utilidad de javascript. Así que para muchos proyectos querrías esto de todos modos ;-)

2ª opción: O usa Underscore.string : tiene un método de include :

_.str.include('foobar', 'ob');
// → true

Aquí está la descripción de Underscore.string, solo agrega 9kb pero le brinda todas las ventajas que una biblioteca bien probada y documentada tiene sobre los fragmentos de código de copiar y pegar:

Underscore.string es una biblioteca de JavaScript para una cómoda manipulación con cadenas, extensión para Underscore.js inspirada en Prototype.js, Right.js, Underscore y el hermoso lenguaje Ruby.

Underscore.string le proporciona varias funciones útiles: capitalizar, limpiar, incluye, contar, escapeHTML, unescapeHTML, insertar, empalmar, comienza con, termina con, titular, recortar, truncar, etc.

Tenga en cuenta que Underscore.string está influenciado por Underscore.js pero se puede usar sin él.

Por último, no menos importante: con la versión de JavaScript, ES6 incluye un método de inclusión integrado:

'foobar'.includes('ob');
// → true

La mayoría de los navegadores modernos ya lo admiten, tienen un ojo en la tabla de compatibilidad ES6 .


Esto acaba de funcionar para mí. Selecciona cadenas que no contienen el término "Eliminado:"

if (eventString.indexOf("Deleted:") == -1)

Hay una forma elegante y mejor de hacer esto y está utilizando el operador (BitWise NOT).

if(~"John".indexOf("J")) {
  alert("Found")
}
else {
  alert("Not Found");
}

Bitwise Not convierte "x" en - (x + 1), por lo tanto, si x resulta -1 del método indexOf, se convertirá en - (-1 + 1) = -0, que es un valor falso.


Para recoger algún tipo de soluciones válidas:

var stringVariable = "some text";
var findString = "text";

//using `indexOf()`
var containResult1 = stringVariable.indexOf(findString) != -1;
document.write(containResult1+', ');

//using `lastIndexOf()`
var containResult2 = stringVariable.lastIndexOf(findString) != -1;
document.write(containResult2+', ');

//using `search()`
var containResult3 = stringVariable.search(findString) != -1;
document.write(containResult3+', ');
     
//using `split()`
var containResult4 = stringVariable.split(findString)[0] != stringVariable;
document.write(containResult4+'');


Podrías usar el método search() JavaScript.

La sintaxis es: string.search(regexp)

Devuelve la posición de la coincidencia, o -1 si no se encuentra ninguna coincidencia.

Ver ejemplos allí: jsref_search

No necesitas una sintaxis de expresión regular complicada. Si no está familiarizado con ellos, una st.search("title") simple st.search("title") será suficiente. Si desea que su prueba no st.search(/title/i) mayúsculas y minúsculas, debe hacer una st.search(/title/i) .


Puedes usar jQuery's :contains selector.

$("div:contains('John')")

Compruébalo aquí: contains-selector


Si estaba buscando una alternativa para escribir el cheque feo -1, en lugar de eso, debe anteponer una tilde.

if (~haystack.indexOf('needle')) alert('found');

Joe Zimmerman : verá que el uso de ~ en -1 lo convierte en 0. El número 0 es un valor falso, lo que significa que se evaluará como falso cuando se convierta en un valor booleano. Puede que no parezca una gran idea al principio, pero recuerde que las funciones como indexOf devolverán -1 cuando no se encuentre la consulta. Esto significa que en lugar de escribir algo similar a esto:

if (someStr.indexOf("a") >= 0) {
  // Found it
} else  {
  // Not Found
}

Ahora puedes tener menos caracteres en tu código para que puedas escribirlo así:

if (~someStr.indexOf("a")) {
  // Found it
} else  {
  // Not Found
}

Más detalles aquí



Use la incorporada y la más simple, es decir, match() en la cadena. Para lograr lo que espera hacer esto:

var stringData ="anyString Data";

var subStringToSearch = "any";

// This will give back the substring if matches and if not returns null
var doesContains = stringData.match(subStringToSearch);

if(doesContains !=null) {
    alert("Contains Substring");
}

Ya que hay una queja sobre el uso del prototipo, y dado que el uso de indexOf hace que su código sea menos legible, y dado que regexp es excesivo:

function stringContains(inputString, stringToFind) {
    return (inputString.indexOf(stringToFind) != -1);
}

Ese es el compromiso por el que terminé yendo.


String.prototype.includes() se introdujo en ES6.

Determina si una cadena se puede encontrar dentro de otra cadena, devolviendo verdadero o falso según corresponda.

Sintaxis

var contained = str.includes(searchString [, position]);  

Parámetros

searchString

Una cadena para buscar dentro de esta cadena.

position

La posición en esta cadena en la que comenzar a buscar searchString predeterminada en 0.

Ejemplo

var str = "To be, or not to be, that is the question.";

console.log(str.includes("To be"));    // true
console.log(str.includes("question")); // true
console.log(str.includes("To be", 1)); // false  

Nota

Esto puede requerir ES6 Shim en los navegadores más antiguos.


JavaScript

 var str = "My big string contain apples and oranges";
 var n = str.indexOf("apples"); 
 alert(n); //will alert 22, -1 if not found

jQuery

  <p>My big string contain apples and oranges</p>
  alert($("p:contains(apples)")[0] != undefined); //will alert true if found

Una forma común de escribir un método contains en JavaScript es:

if (!String.prototype.contains) {
    String.prototype.contains = function (arg) {
        return !!~this.indexOf(arg);
    };
}

El operador de negación a nivel de bits ( ~ ) se usa para convertir -1 en 0 (falsey), y todos los demás valores serán distintos de cero (truey).

Los operadores de negación booleana doble se utilizan para convertir el número en un valor booleano.





string-matching