¿Cómo saber si una cadena contiene cierto carácter en JavaScript?

Tengo una página con un cuadro de texto donde se supone que un usuario debe ingresar un código de registro de 24 caracteres (letras y números, sin distinción entre mayúsculas y minúsculas). Solía maxlengthlimitar al usuario a ingresar 24 caracteres.

Los códigos de registro generalmente se dan como grupos de caracteres separados por guiones, pero me gustaría que el usuario ingrese los códigos sin guiones.

¿Cómo puedo escribir mi código JavaScript sin jQuery para verificar que una cadena dada que el usuario ingresa no contiene guiones, o mejor aún, solo contiene caracteres alfanuméricos?

Para encontrar "hola" en your_string

if (your_string.indexOf('hello') > -1)
{
  alert("hello found inside your_string");
}

Para el alfanumérico puede usar una expresión regular:

http://www.regular-expressions.info/javascript.html

Expresión regular alfanumérica

Con ES6. Incluye ()

"FooBar".includes("oo"); // true

"FooBar".includes("foo"); // false

"FooBar".includes("oo", 2); // false

E: No es compatible con IE; en su lugar, puede usar el operador Tilde ~( Bitwise NOT ) con .indexOf ()

~"FooBar".indexOf("oo"); // -2 -> true

~"FooBar".indexOf("foo"); // 0 -> false

~"FooBar".indexOf("oo", 2); // 0 -> false

Utilizado con un número, el operador de Tilde efectivamente lo hace ~N => -(N+1). Úselo con doble negación !!( NO lógico ) para convertir los números en bools:

!!~"FooBar".indexOf("oo"); // true

!!~"FooBar".indexOf("foo"); // false

!!~"FooBar".indexOf("oo", 2); // false

Si tiene el texto en variable foo:

if (! /^[a-zA-Z0-9]+$/.test(foo)) {
    // Validation failed
}

Esto probará y garantizará que el usuario haya ingresado al menos un carácter y haya ingresado solo caracteres alfanuméricos.

verificar si la cadena (palabra / oración ...) contiene una palabra / carácter específico

if ( "write something here".indexOf("write som") > -1 )  { alert( "found it" );  } 

ES6 contiene el método incorporado ( includes) en String's prototype, que se puede usar para verificar si la cadena contiene otra cadena o no.

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

console.log(str.includes('To be')); 

El siguiente polyfill se puede usar para agregar este método en navegadores no compatibles. ( Fuente )

if (!String.prototype.includes) {
  String.prototype.includes = function(search, start) {
    'use strict';
    if (typeof start !== 'number') {
      start = 0;
    }
    
    if (start + search.length > this.length) {
      return false;
    } else {
      return this.indexOf(search, start) !== -1;
    }
  };
}

Use una expresión regular para lograr esto.

function isAlphanumeric( str ) {
 return /^[0-9a-zA-Z]+$/.test(str);
}

Todos ustedes piensan demasiado. Solo usa una expresión regular simple, es tu mejor amigo.

var string1 = "Hi Stack Overflow. I like to eat pizza."
var string2 = "Damn, I fail."

var regex = /(pizza)/g // Insert whatever phrase or character you want to find

string1.test(regex); // => true
string2.test(regex); // => false

Aprende Regex en 5 minutos?

Si está buscando caracteres al principio o al final de la cadena, también puede usar startsWithyendsWith

const country = "pakistan";
country.startsWith('p'); // true
country.endsWith('n');  // true

Para probar solo caracteres alfanuméricos:

if (/^[0-9A-Za-z]+$/.test(yourString))
{
    //there are only alphanumeric characters
}
else
{
    //it contains other characters
}

La expresión regular está probando 1 o más (+) del conjunto de caracteres 0-9, AZ y az, comenzando con el comienzo de la entrada (^) y deteniéndose con el final de la entrada ($).

La respuesta de Kevins es correcta pero requiere un número "mágico" como sigue:

var containsChar = s.indexOf(somechar) !== -1;

En ese caso, debe saber que -1 significa no encontrado . Creo que una versión un poco mejor sería:

var containsChar = s.indexOf(somechar) >= 0;

Prueba esto:

if ('Hello, World!'.indexOf('orl') !== -1)
    alert("The string 'Hello World' contains the substring 'orl'!");
else
    alert("The string 'Hello World' does not contain the substring 'orl'!");

Aquí hay un ejemplo: http://jsfiddle.net/oliverni/cb8xw/

La función de búsqueda de String también es útil. Busca un carácter y una subcadena en una cadena determinada.

'apple'.search('pl') devoluciones 2

'apple'.search('x') regreso -1

Si está leyendo datos del DOM, como la etiqueta ap o h1, por ejemplo, querrá usar dos funciones nativas de JavaScript, es bastante fácil pero limitado a es6, al menos para la solución que voy a proporcionar. Buscaré todas las etiquetas p dentro del DOM, si el texto contiene una "T", se eliminará todo el párrafo. ¡Espero que este pequeño ejemplo ayude a alguien!

HTML

<p>Text you need to read one</p>
<p>Text you need to read two</p>
<p>Text you need to read three</p>

JS

let paras = document.querySelectorAll('p');

paras.forEach(p => {
  if(p.textContent.includes('T')){
       p.remove();
    } 
});

Funciona perfectamente. Este ejemplo ayudará mucho.

<script>    
    function check()
    {
       var val = frm1.uname.value;
       //alert(val);
       if (val.indexOf("@") > 0)
       {
          alert ("email");
          document.getElementById('isEmail1').value = true;
          //alert( document.getElementById('isEmail1').value);
       }else {
          alert("usernam");
          document.getElementById('isEmail1').value = false;
          //alert( document.getElementById('isEmail1').value);
       }
    }
</script>

<body>
    <h1>My form </h1>
    <form action="v1.0/user/login" method="post" id = "frm1">
        <p>
            UserName : <input type="text" id = "uname" name="username" />
        </p>
        <p>
            Password : <input type="text" name="password" />
        </p>
        <p>
            <input type="hidden" class="email" id = "isEmail1" name = "isEmail"/>
        </p>
        <input type="submit" id = "submit" value="Add User" onclick="return check();"/>
    </form>
</body>

Demostración: El método include () encuentra el carácter "contiene" en toda la cadena, devolverá un verdadero.

var string = "This is a tutsmake.com and this tutorial contains javascript include() method examples."

str.includes("contains");

//The output of this

  true

Compruebe si la cadena es alfanumérica o alfanumérica + algunos caracteres permitidos

Es probable que el método alfanumérico más rápido se mencione en: La mejor forma de verificación alfanumérica en Javascript, ya que opera en rangos de números directamente.

Luego, para permitir algunos otros caracteres adicionales, podemos ponerlos en unaSet búsqueda rápida.

Creo que esta implementación tratará correctamente los pares sustitutos correctamente.

#!/usr/bin/env node

const assert = require('assert');

const char_is_alphanumeric = function(c) {
  let code = c.codePointAt(0);
  return (
    // 0-9
    (code > 47 && code < 58) ||
    // A-Z
    (code > 64 && code < 91) ||
    // a-z
    (code > 96 && code < 123)
  )
}

const is_alphanumeric = function (str) {
  for (let c of str) {
    if (!char_is_alphanumeric(c)) {
      return false;
    }
  }
  return true;
};

// Arbitrarily defined as alphanumeric or '-' or '_'.
const is_almost_alphanumeric = function (str) {
  for (let c of str) {
    if (
      !char_is_alphanumeric(c) &&
      !is_almost_alphanumeric.almost_chars.has(c)
    ) {
      return false;
    }
  }
  return true;
};
is_almost_alphanumeric.almost_chars = new Set(['-', '_']);

assert( is_alphanumeric('aB0'));
assert(!is_alphanumeric('aB0_-'));
assert(!is_alphanumeric('aB0_-*'));
assert(!is_alphanumeric('你好'));

assert( is_almost_alphanumeric('aB0'));
assert( is_almost_alphanumeric('aB0_-'));
assert(!is_almost_alphanumeric('aB0_-*'));
assert(!is_almost_alphanumeric('你好'));

GitHub aguas arriba .

Probado en Node.js v10.15.1.