Comment savoir si une chaîne contient un certain caractère en JavaScript?

J'ai une page avec une zone de texte où un utilisateur est censé entrer un code d'enregistrement de 24 caractères (lettres et chiffres, insensible à la casse). J'avais l'habitude maxlengthde limiter l'utilisateur à la saisie de 24 caractères.

Les codes d'enregistrement sont généralement donnés sous forme de groupes de caractères séparés par des tirets, mais j'aimerais que l'utilisateur saisisse les codes sans les tirets.

Comment puis-je écrire mon code JavaScript sans jQuery pour vérifier qu'une chaîne donnée que l'utilisateur saisit ne contient pas de tirets, ou mieux encore, ne contient que des caractères alphanumériques?

Pour trouver "bonjour" dans your_string

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

Pour l'alpha numérique, vous pouvez utiliser une expression régulière:

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

Expression régulière alphanumérique

Avec ES6. Inclut ()

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

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

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

E: non pris en charge par IE - à la place, vous pouvez utiliser l'opperateur Tilde ~( Bitwise NOT ) avec .indexOf ()

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

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

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

Utilisé avec un nombre, l'opérateur Tilde le fait ~N => -(N+1). Utilisez-le avec double négation !!( NOT logique ) pour convertir les nombres en bools:

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

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

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

Si vous avez le texte en variable foo:

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

Cela permettra de tester et de s'assurer que l'utilisateur a entré au moins un caractère et n'a saisi que des caractères alphanumériques.

vérifier si la chaîne (mot / phrase ...) contient un mot / caractère spécifique

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

ES6 contient une méthode intégrée ( includes) dans les chaînes prototype, qui peut être utilisée pour vérifier si la chaîne contient une autre chaîne ou non.

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

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

Le polyfill suivant peut être utilisé pour ajouter cette méthode dans les navigateurs non pris en charge. ( Source )

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

Utilisez une expression régulière pour accomplir cela.

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

Vous pensez tous trop fort. Utilisez simplement une expression régulière simple, c'est votre meilleur ami.

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

Apprenez Regex en 5 minutes?

Si vous recherchez des caractères au début ou à la fin de la chaîne, vous pouvez également utiliser startsWithetendsWith

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

Pour tester uniquement les caractères alphanumériques:

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

L'expression régulière teste 1 ou plusieurs (+) de l'ensemble de caractères 0-9, AZ et az, en commençant par le début de l'entrée (^) et en s'arrêtant par la fin de l'entrée ($).

La réponse de Kevins est correcte mais elle nécessite un nombre "magique" comme suit:

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

Dans ce cas, vous devez savoir que -1 signifie non trouvé . Je pense qu'une version un peu meilleure serait:

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

Essaye ça:

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

Voici un exemple: http://jsfiddle.net/oliverni/cb8xw/

La fonction de recherche de String est également utile. Il recherche un caractère ainsi qu'une sous-chaîne dans une chaîne donnée.

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

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

Si vous lisez des données du DOM telles que la balise ap ou h1, par exemple, vous voudrez utiliser deux fonctions natives JavaScript, c'est assez simple mais limité à es6, au moins pour la solution que je vais fournir. Je vais rechercher toutes les balises p dans le DOM, si le texte contient un "T", le paragraphe entier sera supprimé. J'espère que ce petit exemple aide quelqu'un!

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

Fonctionne parfaitement.Cet exemple vous aidera beaucoup.

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

Démonstration: La méthode include () trouve le caractère «contient» dans la chaîne entière, elle retournera un vrai.

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

str.includes("contains");

//The output of this

  true

Vérifiez si la chaîne est alphanumérique ou alphanumérique + certains caractères autorisés

La méthode alphanumérique la plus rapide est probablement celle mentionnée à: Meilleur moyen de vérification alphanumérique en Javascript car elle opère directement sur les plages de nombres.

Ensuite, pour autoriser quelques autres caractères supplémentaires en toute sécurité, nous pouvons simplement les mettre dans uneSet recherche rapide.

Je pense que cette mise en œuvre correctement les paires de substitution .

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

Testé dans Node.js v10.15.1.