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


Answers

Puede agregar fácilmente un método contains a String con esta instrucció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; }; }
Question

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

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







Otra opción para hacer esto es:

Puede usar la función de coincidencia, es decir, algo así como:

x = "teststring";

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

match () también puede funcionar con expresión regular:

x = "teststring";

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



var index = haystack.indexOf(needle);



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

La sintaxis es: string.search(regexp)

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

Ver ejemplos allí: jsref_search

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




Si estabas buscando una alternativa para escribir la fea -1 verificación, antepones una tilde en su lugar.

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

Joe Zimmerman : verás que usar ~ en -1 lo convierte en 0. El número 0 es un valor de Falsey, lo que significa que se evaluará como falso cuando se convierta en Booleano. Puede que no parezca una gran idea al principio, pero recuerde funciones como indexOf devolverá -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 puede tener menos caracteres en su código para que pueda escribirlo así:

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

Más detalles aquí




Solución simple

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

puedes usar 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 MDN




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




La forma más fácil es usar indexOf . Para simplemente verificar una cadena de caracteres para un substr puede usar este método:

string = "asdf";
substr = "as";
alert(string.indexOf(substr) == -1 ? false : true);

Como quería la función string.contains() , puede implementarla usted mismo así:

String.prototype.contains = function(test) {
    return this.indexOf(test) == -1 ? false : true;
};

Ahora puede usar este método ecen más corto para verificar si una cadena contiene una subcadena especial:

string = "asdf";
alert(string.contains("as"));

Aquí hay un JSFiddle también.




Puede usar jQuery's :contains selector.

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

Verifíquelo aquí: contains-selector




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



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

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

Bitwise Not convierte "x" en - (x + 1) entonces, si la x resulta -1 del método indexOf.then se convertirá en - (-1 + 1) = -0 que es un valor falsy.




Estabas buscando .indexOf String.prototype.indexOf .

indexOf va a devolver un índice a la subcadena coincidente. El índice se correlacionará con el lugar donde comienza la subcadena. Si no hay coincidencia, se devuelve -1. Aquí hay una demostración simple 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)
}




Código JavaScript para usar el método contains en una matriz:

<html>
    <head>
        <h2>Use of contains() method</h2>
        <script>
            Array.prototype.contains = function (element) {
                for (var i = 0; i < this.length; i++) {
                    if (this[i] == element) {
                        return true;
                    }
                }
                return false;
            }
            arr1 = ["Rose", "India", "Technologies"];
            document.write("The condition is "+arr1.contains("India")+"<br>");
        </script>
    </head>

    <b>[If the specified element is present in the array, it returns true otherwise
    returns false.]</b>

</html>

En el código dado, el método contains determina si el elemento especificado está presente en la matriz o no. Si el elemento especificado está presente en la matriz, devuelve verdadero; de lo contrario, devuelve falso.




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 bit a bit ( ~ ) se usa para convertir -1 en 0 (falsey), y todos los demás valores serán distintos de cero (verdad).

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