Come sapere se una stringa contiene un determinato carattere in JavaScript?

Ho una pagina con una casella di testo in cui un utente dovrebbe inserire un codice di registrazione di 24 caratteri (lettere e numeri, senza distinzione tra maiuscole e minuscole). Ho usato maxlengthper limitare l'utente a inserire 24 caratteri.

I codici di registrazione sono generalmente indicati come gruppi di caratteri separati da trattini, ma vorrei che l'utente inserisse i codici senza i trattini.

Come posso scrivere il mio codice JavaScript senza jQuery per verificare che una determinata stringa che l'utente immette non contenga trattini o, meglio ancora, contenga solo caratteri alfanumerici?

Per trovare "ciao" in your_string

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

Per il numero alfa puoi usare un'espressione regolare:

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

Espressione regolare alfanumerica

Con ES6 .includes ()

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

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

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

E: Non supportato da IE - invece puoi usare Tilde opperator ~( Bitwise NOT ) con .indexOf ()

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

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

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

Utilizzato con un numero, l'operatore Tilde lo fa efficace ~N => -(N+1). Usalo con doppia negazione !!( Logical NOT ) per convertire i numeri in bool:

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

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

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

Se hai il testo in variabile foo:

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

Questo verificherà e si assicurerà che l'utente abbia inserito almeno un carattere e abbia inserito solo caratteri alfanumerici.

controlla se la stringa (parola / frase ...) contiene parole / caratteri specifici

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

ES6 contiene il metodo incorporato ( includes) in String's prototype, che può essere utilizzato per verificare se la stringa contiene o meno un'altra stringa.

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

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

Il seguente polyfill può essere utilizzato per aggiungere questo metodo nei browser non supportati. ( 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;
    }
  };
}

Utilizzare un'espressione regolare per ottenere questo risultato.

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

Stai pensando troppo. Basta usare una semplice espressione regolare, è il tuo migliore amico.

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

Impara Regex in 5 minuti?

Se stai cercando caratteri all'inizio o alla fine della stringa, puoi anche usare startsWitheendsWith

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

Per verificare solo caratteri alfanumerici:

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

Il regex sta testando 1 o più (+) dell'insieme di caratteri 0-9, AZ e az, iniziando con l'inizio dell'input (^) e terminando con la fine dell'input ($).

La risposta di Kevins è corretta ma richiede un numero "magico" come segue:

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

In tal caso, devi sapere che -1 sta per non trovato . Penso che una versione leggermente migliore sarebbe:

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

Prova questo:

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

Ecco un esempio: http://jsfiddle.net/oliverni/cb8xw/

Anche la funzione di ricerca di String è utile. Cerca un carattere e una stringa secondaria in una determinata stringa.

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

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

Se stai leggendo dati dal DOM come tag ap o h1, ad esempio, vorrai utilizzare due funzioni JavaScript native, è abbastanza semplice ma limitato a es6, almeno per la soluzione che sto per fornire. Cercherò tutti i tag p all'interno del DOM, se il testo contiene una "T" verrà rimosso l'intero paragrafo. Spero che questo piccolo esempio aiuti qualcuno!

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

Funziona perfettamente. Questo esempio aiuterà molto.

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

Dimostrazione: il metodo include () trova il carattere "contiene" in tutta la stringa, restituirà un valore vero.

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

str.includes("contains");

//The output of this

  true

Controlla se la stringa è alfanumerica o alfanumerica + alcuni caratteri consentiti

Il metodo alfanumerico più veloce è probabilmente come menzionato in: Il modo migliore per controllare alfanumerico in Javascript mentre opera direttamente su intervalli di numeri.

Quindi, per consentire alcuni altri caratteri in modo sano possiamo semplicemente metterli in unaSet ricerca veloce.

Credo che questa implementazione gestirà correttamente le coppie surrogate .

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

Testato in Node.js v10.15.1.