Como saber se uma string contém um determinado caractere em JavaScript?

Eu tenho uma página com uma caixa de texto em que um usuário deve digitar um código de registro de 24 caracteres (letras e números, sem distinção entre maiúsculas e minúsculas). Eu costumava maxlengthlimitar o usuário a inserir 24 caracteres.

Os códigos de registro geralmente são dados como grupos de caracteres separados por hífens, mas eu gostaria que o usuário inserisse os códigos sem os hífens.

Como posso escrever meu código JavaScript sem jQuery para verificar se uma determinada sequência que o usuário digita não contém hífens, ou melhor ainda, contém apenas caracteres alfanuméricos?

Para encontrar "olá" em your_string

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

Para o alfanumérico, você pode usar uma expressão regular:

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

Expressão regular alfanumérica

Com ES6 .includes ()

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

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

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

E: Não suportado pelo IE - você pode usar o operador Tilde ~( Bitwise NOT ) com .indexOf ()

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

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

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

Usado com um número, o operador Tilde efetivamente faz ~N => -(N+1). Use-o com dupla negação !!( Logical NOT ) para converter os números em bools:

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

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

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

Se você tiver o texto na variável foo:

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

Isso irá testar e certificar-se de que o usuário inseriu pelo menos um caractere, e entrou apenas caracteres alfanuméricos.

verifique se a string (palavra / frase ...) contém uma palavra / caractere específico

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

O ES6 contém o método embutido ( includes) em String prototype, que pode ser usado para verificar se a string contém outra ou não.

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

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

O polyfill a seguir pode ser usado para adicionar esse método em navegadores não suportados. ( Fonte )

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 uma expressão regular para fazer isso.

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

Vocês todos estão pensando demais. Basta usar uma expressão regular simples, é seu melhor 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

Aprenda Regex em 5 minutos?

Se você estiver procurando por caracteres no início ou no final da string, também poderá usar startsWitheendsWith

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

Para testar apenas caracteres alfanuméricos:

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

O regex está testando 1 ou mais (+) do conjunto de caracteres 0-9, AZ e az, começando com o início da entrada (^) e parando com o final da entrada ($).

A resposta de Kevins está correta, mas requer um número "mágico" da seguinte maneira:

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

Nesse caso, você precisa saber que -1 significa não encontrado . Eu acho que uma versão um pouco melhor seria:

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

Tente o seguinte:

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

Aqui está um exemplo: http://jsfiddle.net/oliverni/cb8xw/

A função de pesquisa de string também é útil. Ele procura por um caractere e uma sub_string em uma determinada string.

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

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

Se você estiver lendo dados do DOM, como a tag ap ou h1, por exemplo, desejará usar duas funções JavaScript nativas, isso é fácil, mas limitado ao es6, pelo menos para a solução que vou fornecer. Vou procurar todas as tags p no DOM, se o texto contiver um "T", o parágrafo inteiro será removido. Espero que este pequeno exemplo ajude alguém!

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

Funcionando perfeitamente. Este exemplo ajudará muito.

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

Demonstração: O método include () encontra o caractere "contains" em toda a string, retornando um true.

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

str.includes("contains");

//The output of this

  true

Verifique se a sequência é alfanumérica ou alfanumérica + alguns caracteres permitidos

O método alfanumérico mais rápido provavelmente é mencionado em: Melhor maneira de verificar alfanumérico em Javascript , pois opera diretamente em intervalos de números.

Em seguida, para permitir alguns outros caracteres extras com segurança, basta colocá-los em umaSet pesquisa rápida.

Acredito que esta implementação lidará com pares substitutos corretamente corretamente.

#!/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 upstream .

Testado no Node.js v10.15.1.