Jak stwierdzić, czy ciąg zawiera określony znak w JavaScript?

Mam stronę z polem tekstowym, w której użytkownik powinien wprowadzić 24-znakowy kod rejestracyjny (litery i cyfry, bez rozróżniania wielkości liter). Kiedyś maxlengthograniczałem użytkownika do wprowadzania 24 znaków.

Kody rejestracyjne są zazwyczaj podawane jako grupy znaków oddzielone myślnikami, ale chciałbym, aby użytkownik wprowadził kody bez myślników.

Jak napisać kod JavaScript bez jQuery, aby sprawdzić, czy dany ciąg znaków wprowadzony przez użytkownika nie zawiera myślników, a jeszcze lepiej, zawiera tylko znaki alfanumeryczne?

Aby znaleźć „cześć” w your_string

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

W przypadku wartości alfanumerycznych można użyć wyrażenia regularnego:

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

Wyrażenie regularne alfanumeryczne

Z ES6 .includes ()

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

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

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

E: Nieobsługiwany przez IE - zamiast tego możesz użyć narzędzia Tilde ~( Bitwise NOT ) z .indexOf ()

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

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

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

W połączeniu z liczbą skuteczny jest operator Tilde ~N => -(N+1). Użyj go z podwójną negacją !!( logiczne NIE ), aby przekonwertować liczby w boolach:

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

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

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

Jeśli masz tekst w zmiennej foo :

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

Spowoduje to przetestowanie i upewnienie się, że użytkownik wprowadził co najmniej jeden znak i wprowadził tylko znaki alfanumeryczne.

sprawdź, czy łańcuch (słowo / zdanie ...) zawiera określone słowo / znak

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

ES6 zawiera wbudowaną metodę ( includes) w String prototype, której można użyć do sprawdzenia, czy łańcuch zawiera inny ciąg, czy nie.

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

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

Aby dodać tę metodę w nieobsługiwanych przeglądarkach, można użyć następującego wypełniania. ( Źródło )

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

Aby to zrobić, użyj wyrażenia regularnego.

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

Wszyscy za bardzo się zastanawiacie. Wystarczy użyć prostego wyrażenia regularnego, to twój najlepszy przyjaciel.

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

Dowiedz się Regex w 5 minut?

Jeśli szukasz znaków na początku lub na końcu ciągu, możesz także użyć startsWithiendsWith

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

Aby przetestować tylko znaki alfanumeryczne:

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

Wyrażenie regularne testuje 1 lub więcej (+) zestawu znaków 0-9, AZ i az, zaczynając od początku wejścia (^) i kończąc na końcu wejścia ($).

Odpowiedź Kevinsa jest poprawna, ale wymaga „magicznej” liczby w następujący sposób:

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

W takim przypadku musisz wiedzieć, że -1 oznacza „ nie znaleziono” . Myślę, że nieco lepsza wersja to:

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

Spróbuj tego:

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

Oto przykład: http://jsfiddle.net/oliverni/cb8xw/

Przydaje się również funkcja wyszukiwania ciągu. Wyszukuje zarówno znak, jak i podłańcuch w danym ciągu.

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

'apple'.search('x') powrót -1

Jeśli czytasz dane z DOM, takie jak na przykład znacznik ap lub h1, będziesz chciał użyć dwóch rodzimych funkcji JavaScript, jest to ciche łatwe, ale ograniczone do es6, przynajmniej dla rozwiązania, które zamierzam dostarczyć. Przeszukam wszystkie tagi p w DOM, jeśli tekst zawiera „T”, cały akapit zostanie usunięty. Mam nadzieję, że ten mały przykład pomoże komuś pomóc!

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

Działa idealnie. Ten przykład pomoże dużo.

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

Demonstracja: Metoda include () znajduje znak „zawiera” w całym ciągu, zwraca wartość true.

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

str.includes("contains");

//The output of this

  true

Sprawdź, czy ciąg znaków jest alfanumeryczny czy alfanumeryczny + niektóre dozwolone znaki

Najszybsza metoda alfanumeryczna jest prawdopodobnie wymieniona w: Najlepszy sposób na sprawdzenie alfanumeryczne w JavaScript ponieważ działa bezpośrednio na zakresach liczb.

Następnie, aby pozwolić na kilka innych dodatkowych znaków, możemy po prostu umieścić je wSet celu szybkiego wyszukiwania.

Uważam, że ta implementacja poprawnie poradzi sobie z parami zastępczymi .

#!/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 w górę .

Testowane w Node.js 10.15.1.