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





palabra caracter (25)


Otra opción para hacer esto es:

Puedes usar la función de coincidencia, es decir, algo como:

x = "teststring";

if (x.match("test")) {
     // Code
}

match () también puede trabajar con expresiones regulares:

x = "teststring";

if (x.match(/test/i)) {
     // Code
}

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

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




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.




Ejemplo

var a  = "Test String";

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



var index = haystack.indexOf(needle);



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



Usted buscaba .indexOf String.prototype.indexOf .

indexOf devolverá un índice a la subcadena coincidente. El índice se correlacionará con donde comienza la subcadena. Si no hay coincidencia, se devuelve un -1. Aquí hay una simple demostración de ese concepto:

var str = "Hello World"; // For example, lets search this string,
var term = "World"; // for the term "World",
var index = str.indexOf(term); // and get its index.
if (index != -1) { // If the index is not -1 then the term was matched in the string,
  alert(index); // and we can do some work based on that logic. (6 is alerted)
}




En ES6 , tenemos algo que incluye las llamadas que hacen exactamente lo que usted quiere: así que simplemente puede hacer esto:

'str1'.includes('str2');

También en ES5 , si lo usas ampliamente, simplemente puedes agregarlo así:

String.prototype.includes = String.prototype.includes || function(str) {
  return this.indexOf(str) > -1;
}



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



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




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.




Esta pieza de código debería funcionar bien:

var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
   //logic
} 



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



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+'');




Solución simple

if (!String.prototype.contains) {
  String.prototype.contains= function() {
    return String.prototype.indexOf.apply(this, arguments) !== -1;
  };
}

Se puede utilizar de la siguiente manera.

"hello".contains("he") // true
"hello world".contains("lo w")//true
"hello world".contains("lo wa")//false
"hello world".contains(" ")//true
"hello world".contains("  ")//false

Referencia de MDN




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) .




Puede agregar fácilmente un método de contenido a Cadena con esta declaración:

String.prototype.contains = function(it) { return this.indexOf(it) != -1; };

Nota: vea los comentarios a continuación para un argumento válido para no usar esto. Mi consejo: usa tu propio juicio.

Alternativamente:

if (typeof String.prototype.contains === 'undefined') { String.prototype.contains = function(it) { return this.indexOf(it) != -1; }; }



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



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 .







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.







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.




Hay una string.includes en ES6 :

"potato".includes("to");
> true

Tenga en cuenta que es posible que deba cargar es6-shim o similar para que esto funcione en navegadores más antiguos.

require('es6-shim')



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.




Cómo se lo explicaría a un niño de seis años:

¿Sabes cómo los adultos pueden ser dueños de una casa y la llaman su hogar? Cuando una madre tiene un hijo, el niño realmente no posee nada, ¿verdad? Pero los padres son dueños de una casa, por lo que cada vez que alguien le pregunta al niño "¿Dónde está tu casa?", Él / ella puede responder "esa casa" y señalar la casa de sus padres. Un "cierre" es la capacidad del niño de poder siempre (incluso si está en el extranjero) poder decir que tiene un hogar, aunque en realidad los padres son los dueños de la casa.







javascript string substring contains string-matching