Überprüfen Sie, ob eine Eingabezeichenfolge eine Zahl in Javascript enthält

Mein Endziel ist es, ein Eingabefeld zu validieren. Die Eingabe kann entweder alphabetisch oder numerisch sein.

Wenn ich mich nicht irre, erfordert die Frage "enthält Nummer", nicht "ist Nummer". So:

function hasNumber(myString) {
  return /\d/.test(myString);
}

Sie können dies mit Javascript tun. Keine Notwendigkeit für Jquery oder Regex

function isNumeric(n) {
  return !isNaN(parseFloat(n)) && isFinite(n);
}

Während der Implementierung

var val = $('yourinputelement').val();
if(isNumeric(val)) { alert('number'); } 
else { alert('not number'); }

Update: Um zu überprüfen, ob eine Zeichenfolge Zahlen enthält, können Sie dazu reguläre Ausdrücke verwenden

var matches = val.match(/\d+/g);
if (matches != null) {
    alert('number');
}

function validate(){    
    var re = /^[A-Za-z]+$/;
    if(re.test(document.getElementById("textboxID").value))
       alert('Valid Name.');
    else
       alert('Invalid Name.');      
}

Es ist keineswegs kugelsicher, aber es hat für meine Zwecke funktioniert und vielleicht hilft es jemandem.

var value = $('input').val();
 if(parseInt(value)) {
  console.log(value+" is a number.");
 }
 else {
  console.log(value+" is NaN.");
 }

Verwenden regulärer Ausdrücke mit JavaScript . Ein regulärer Ausdruck ist eine spezielle Textzeichenfolge zur Beschreibung eines Suchmusters, die in Form von / pattern / modifiers geschrieben ist, wobei "pattern" der reguläre Ausdruck selbst ist und "modifiers" eine Reihe von Zeichen sind, die verschiedene Optionen angeben.
         Die Zeichenklasse ist das grundlegendste Regex-Konzept nach einer wörtlichen Übereinstimmung. Dadurch wird eine kleine Zeichenfolge mit einem größeren Zeichensatz übereinstimmen. Könnte beispielsweise [A-Z]für das Großbuchstaben stehen und \deine beliebige Ziffer bedeuten.

Aus dem folgenden Beispiel

• contains_alphaNumeric«Es wird geprüft, ob die Zeichenfolge entweder Buchstaben oder Zahlen (oder) sowohl Buchstaben als auch Zahlen enthält. Der Bindestrich (-) wird ignoriert .
• onlyMixOfAlphaNumeric«Es wird geprüft, ob Zeichenfolgen nur Buchstaben und Zahlen in beliebiger Reihenfolge enthalten.

Beispiel:

function matchExpression( str ) {
    var rgularExp = {
        contains_alphaNumeric : /^(?!-)(?!.*-)[A-Za-z0-9-]+(?<!-)$/,
        containsNumber : /\d+/,
        containsAlphabet : /[a-zA-Z]/,

        onlyLetters : /^[A-Za-z]+$/,
        onlyNumbers : /^[0-9]+$/,
        onlyMixOfAlphaNumeric : /^([0-9]+[a-zA-Z]+|[a-zA-Z]+[0-9]+)[0-9a-zA-Z]*$/
    }

    var expMatch = {};
    expMatch.containsNumber = rgularExp.containsNumber.test(str);
    expMatch.containsAlphabet = rgularExp.containsAlphabet.test(str);
    expMatch.alphaNumeric = rgularExp.contains_alphaNumeric.test(str);

    expMatch.onlyNumbers = rgularExp.onlyNumbers.test(str);
    expMatch.onlyLetters = rgularExp.onlyLetters.test(str);
    expMatch.mixOfAlphaNumeric = rgularExp.onlyMixOfAlphaNumeric.test(str);

    return expMatch;
}

// HTML Element attribute's[id, name] with dynamic values.
var id1 = "Yash", id2="777", id3= "Yash777", id4= "Yash777Image4"
    id11= "image5.64", id22= "55-5.6", id33= "image_Yash", id44= "image-Yash"
    id12= "_-.";
console.log( "Only Letters:\n ", matchExpression(id1) );
console.log( "Only Numbers:\n ", matchExpression(id2) );
console.log( "Only Mix of Letters and Numbers:\n ", matchExpression(id3) );
console.log( "Only Mix of Letters and Numbers:\n ", matchExpression(id4) );

console.log( "Mixed with Special symbols" );
console.log( "Letters and Numbers :\n ", matchExpression(id11) );
console.log( "Numbers [-]:\n ", matchExpression(id22) );
console.log( "Letters :\n ", matchExpression(id33) );
console.log( "Letters [-]:\n ", matchExpression(id44) );

console.log( "Only Special symbols :\n ", matchExpression(id12) );

Ausgabe:

Only Letters:
  {containsNumber: false, containsAlphabet: true, alphaNumeric: true, onlyNumbers: false, onlyLetters: true, mixOfAlphaNumeric: false}
Only Numbers:
  {containsNumber: true, containsAlphabet: false, alphaNumeric: true, onlyNumbers: true, onlyLetters: false, mixOfAlphaNumeric: false}
Only Mix of Letters and Numbers:
  {containsNumber: true, containsAlphabet: true, alphaNumeric: true, onlyNumbers: false, onlyLetters: false, mixOfAlphaNumeric: true}
Only Mix of Letters and Numbers:
  {containsNumber: true, containsAlphabet: true, alphaNumeric: true, onlyNumbers: false, onlyLetters: false, mixOfAlphaNumeric: true}
Mixed with Special symbols
Letters and Numbers :
  {containsNumber: true, containsAlphabet: true, alphaNumeric: false, onlyNumbers: false, onlyLetters: false, mixOfAlphaNumeric: false}
Numbers [-]:
  {containsNumber: true, containsAlphabet: false, alphaNumeric: false, onlyNumbers: false, onlyLetters: false, mixOfAlphaNumeric: false}
Letters :
  {containsNumber: false, containsAlphabet: true, alphaNumeric: false, onlyNumbers: false, onlyLetters: false, mixOfAlphaNumeric: false}
Letters [-]:
  {containsNumber: false, containsAlphabet: true, alphaNumeric: true, onlyNumbers: false, onlyLetters: false, mixOfAlphaNumeric: false}
Only Special symbols :
  {containsNumber: false, containsAlphabet: false, alphaNumeric: false, onlyNumbers: false, onlyLetters: false, mixOfAlphaNumeric: false}

Java Pattern Matching mit regulären Ausdrücken.

Um zu testen, ob ein Zeichen eine Zahl ohne Overkill ist, muss es nach Bedarf angepasst werden.

const s = "EMA618"

function hasInt(me){
  let i = 1,a = me.split(""),b = "",c = "";
  a.forEach(function(e){
   if (!isNaN(e)){
     console.log(`CONTAIN NUMBER «${e}» AT POSITION ${a.indexOf(e)} => TOTAL COUNT ${i}`)
     c += e
     i++
   } else {b += e}
  })
  console.log(`STRING IS «${b}», NUMBER IS «${c}»`)
  if (i === 0){
    return false
    // return b
  } else {
    return true
    // return +c
  }
}


hasInt(s)

Eine Möglichkeit, dies zu überprüfen, besteht darin, die Zeichenfolge zu durchlaufen und true (oder false, je nachdem, was Sie möchten) zurückzugeben, wenn Sie eine Zahl drücken.

function checkStringForNumbers(input){
    let str = String(input);
    for( let i = 0; i < str.length; i++){
              console.log(str.charAt(i));
        if(!isNaN(str.charAt(i))){           //if the string is a number, do the following
            return true;
        }
    }
}

Sie können dies mit Javascript tun. Keine Notwendigkeit für Jquery oder Regex

function isNumeric(n) {
  if(!isNaN(n))
    {
     return true
    }
  else
   {
    return false
   }
}

Dieser Code hilft auch bei "Erkennen von Zahlen in einer bestimmten Zeichenfolge", wenn Zahlen gefunden wurden, dass die Ausführung gestoppt wird.

function hasDigitFind(_str_) {
  this._code_ = 10;  /*When empty string found*/
  var _strArray = [];

  if (_str_ !== '' || _str_ !== undefined || _str_ !== null) {
    _strArray = _str_.split('');
    for(var i = 0; i < _strArray.length; i++) {
      if(!isNaN(parseInt(_strArray[i]))) {
        this._code_ = -1;
        break;
      } else {
        this._code_ = 1;
      }
    }

  }
  return this._code_;
}

parseInt liefert Ganzzahlen, wenn die Zeichenfolge mit der Darstellung einer Ganzzahl beginnt:

(parseInt '1a')  is  1

..so vielleicht:

isInteger = (s)->
  s is (parseInt s).toString()  and  s isnt 'NaN'

(isInteger 'a') is false
(isInteger '1a') is false
(isInteger 'NaN') is false
(isInteger '-42') is true

Verzeihen Sie mein CoffeeScript.

Sie können auch lodash versuchen:

const isNumeric = number => 
  _.isFinite(_.parseInt(number)) && !_.isNaN(_.parseInt(number))