Il modo migliore per il controllo alfanumerico in Javascript

Qual è il modo migliore per eseguire un controllo alfanumerico su un INPUTcampo in JSP? Ho allegato il mio codice attuale

<script type="text/javascript">
  function validateCode(){
      var TCode = document.getElementById('TCode').value;
      for(var i=0; i<TCode.length; i++)
      {
        var char1 = TCode.charAt(i);
        var cc = char1.charCodeAt(0);

        if((cc>47 && cc<58) || (cc>64 && cc<91) || (cc>96 && cc<123))
        {

        }
         else {
         alert('Input is not alphanumeric');
         return false;
         }
      }
     return true;     
   }

Puoi usare questa regex /^[a-z0-9]+$/i

L'inclinazione originale del richiedente all'uso str.charCodeAt(i)sembra essere più veloce dell'alternativa delle espressioni regolari. Nel mio test su jsPerf l'opzione RegExp è più lenta del 66% in Chrome 36 (e leggermente più lenta in Firefox 31).

Ecco una versione pulita del codice di convalida originale che riceve una stringa e restituisce trueo false:

function isAlphaNumeric(str) {
  var code, i, len;

  for (i = 0, len = str.length; i < len; i++) {
    code = str.charCodeAt(i);
    if (!(code > 47 && code < 58) && // numeric (0-9)
        !(code > 64 && code < 91) && // upper alpha (A-Z)
        !(code > 96 && code < 123)) { // lower alpha (a-z)
      return false;
    }
  }
  return true;
};

Naturalmente, potrebbero esserci altre considerazioni, come la leggibilità. Un'espressione regolare di una riga è decisamente più carina da guardare. Ma se sei strettamente interessato alla velocità, potresti prendere in considerazione questa alternativa.

Controllalo con una regex.

Le espressioni regolari JavaScript non hanno classi di caratteri POSIX, quindi devi scrivere manualmente gli intervalli di caratteri:

if (!input_string.match(/^[0-9a-z]+$/))
  show_error_or_something()

Qui ^significa l'inizio della stringa e $significa fine della stringa e [0-9a-z]+significa uno o più caratteri da 0a 9OR da aa z.

Maggiori informazioni su Javascript regexen qui: https://developer.mozilla.org/en/JavaScript/Guide/Regular_Expressions

Non è necessario farlo uno alla volta. Basta fare un test per quelli che non sono alfanumerici. Se ne viene trovato uno, la convalida non riesce.

function validateCode(){
    var TCode = document.getElementById('TCode').value;
    if( /[^a-zA-Z0-9]/.test( TCode ) ) {
       alert('Input is not alphanumeric');
       return false;
    }
    return true;     
 }

Se c'è almeno una corrispondenza di un non alfanumerico, lo farà return false.

Creerei un metodo di prototipo String:

String.prototype.isAlphaNumeric = function() {
  var regExp = /^[A-Za-z0-9]+$/;
  return (this.match(regExp));
};

Quindi, l'utilizzo sarebbe:

var TCode = document.getElementById('TCode').value;
return TCode.isAlphaNumeric()

    // On keypress event call the following method
    function AlphaNumCheck(e) {
        var charCode = (e.which) ? e.which : e.keyCode;
        if (charCode == 8) return true;

        var keynum;
        var keychar;
        var charcheck = /[a-zA-Z0-9]/;
        if (window.event) // IE
        {
            keynum = e.keyCode;
        }
        else {
            if (e.which) // Netscape/Firefox/Opera
            {
                keynum = e.which;
            }
            else return true;
        }

        keychar = String.fromCharCode(keynum);
        return charcheck.test(keychar);
    }

Inoltre, questo articolo aiuta anche a comprendere la convalida alfanumerica JavaScript.

Scusatemi tutti, nessuna polemica. Ma affinché la comunità cresca come è cresciuta io in questi anni, è bene prendere appunti.

La vera stringa alfanumerica è come "0a0a0a0b0c0d"e non come "000000"o "qwertyuio".

Tutte le risposte che ho letto qui, sono tornate truein entrambi i casi. E perdonami, IMHO, questo non è giusto .

Se voglio controllare se la mia "00000"stringa è alfanum, la mia risposta "umana" è senza dubbio FALSA.

Perché? Semplice. Non riesco a trovare nessuna lettera char. Quindi, è una semplice stringa numerica [0-9].

D'altra parte, se volessi controllare la mia "abcdefg"stringa, la mia risposta "umana" è addirittura FALSA. Non vedo i numeri, quindi non è alfanumerico. Solo alfa [a-zA-Z].

La risposta di Michael Martin-Smucker è stata illuminante.

Tuttavia, mirava a ottenere prestazioni migliori invece di regex. Questo è vero, usando un modo di basso livello c'è una performance migliore. Ma i risultati sono gli stessi. Le stringhe "0123456789"(solo numeriche), "qwertyuiop"(solo alfa) e "0a1b2c3d4f4g"(alfanumeriche) restituiscono TRUEcome alfanumeriche. Stesso /^[a-z0-9]+$/imodo regex . Il motivo per cui la regex non funziona è tanto semplice quanto ovvio. La sintassi []indica o , non e . Quindi, se è solo numerico o se è solo lettere, regex restituisce true.

Tuttavia, la risposta di Michael Martin-Smucker è stata comunque illuminante. Per me. Mi ha permesso di pensare a "basso livello", di creare una vera funzione che processa in modo univoco una stringa alfanumerica. L'ho chiamata come funzione relativa di PHP ctype_alnum( modifica 2020-02-18: dove, tuttavia, questo controlla OR e non AND ).

Ecco il codice:

function ctype_alnum(str) {
  var code, i, len;
    var isNumeric = false, isAlpha = false; //I assume that it is all non-alphanumeric



  for (i = 0, len = str.length; i < len; i++) {
    code = str.charCodeAt(i);


        switch (true){
            case code > 47 && code < 58: // check if 0-9
                isNumeric = true;
                break;
            case (code > 64 && code < 91) || (code > 96 && code < 123): //check if A-Z or a-z
                isAlpha = true;
                break;
            default: // not 0-9, not A-Z or a-z
                return false; //stop function with false result, no more checks

        }

  }

  return isNumeric && isAlpha; //return the loop results, if both are true, the string is certainly alphanumeric
};

... ed ecco la DEMO

Sono arrivato a questa discussione perché cercavo un'alternativa in javascript alla funzione PHP. Non ho trovato la risposta "ready-to-go", ma come spesso accade su Stackoverflow, il concetto di conoscenza e confronto tra loro è qualcosa di sublime, che ti porta a pensare alla risposta di qualcuno e trovare insieme la soluzione che eri cercando, ma non pensavi di saperlo.

E condividilo!

Migliore

Oscar

In un ciclo stretto, probabilmente è meglio evitare regex e codificare i tuoi caratteri:

const CHARS = new Set("0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ");
function isAlphanumeric(char) {
    return CHARS.has(char);
}

Per verificare se input_string è alfanumerico, usa semplicemente:

input_string.match(/[^\w]|_/) == null