includes - ¿Cómo comprobar si una cadena contiene una subcadena en JavaScript?
search for character in string javascript (30)
Por lo general, esperaría un método String.contains() , pero no parece haber uno.
¿Cuál es una manera razonable de verificar esto?
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.
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.
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
ES6 contiene String.prototype.includes .
https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/String/includes
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 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;
}
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 .
Esta pieza de código debería funcionar bien:
var str="This is testing for javascript search !!!";
if(str.search("for") != -1) {
//logic
}
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.
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
}
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) .
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; }; }
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í
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
Usa una expresión regular:
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");
}
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)
}
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.
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'')
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.
var index = haystack.indexOf(needle);