Mein Endziel ist es, ein Eingabefeld zu validieren. Die Eingabe kann entweder alphabetisch oder numerisch sein.
Mein Endziel ist es, ein Eingabefeld zu validieren. Die Eingabe kann entweder alphabetisch oder numerisch sein.
Antworten:
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');
}
matches != null
bedeutet nicht undefined
oder null
während matches !== null
bedeutet spezifisch nicht null
aber geht vorbei undefined
.
match()
gibt ein Array zurück oder null
. Also if (matches !== null)
sollte es in Ordnung sein (und es wird JSHint gefallen.) Quelle: developer.mozilla.org/en/docs/Web/JavaScript/Reference/…
isFinite(parseFloat(n))
im ersten Beispiel sein. isNumeric("5,000")
schlägt fehl.
isFinite()
gibt true an, wenn der übergebene Wert eine finite
Zahl ist und number 5,000
eine formatierte Zeichenfolge ist, keine endliche Zahl.
isNaN
? Ich würde vorschlagen, entweder den Parse-Float zu entfernen isNaN
oder ihn ebenfalls hinzuzufügen, um isFinite
darin zu bestehen.
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.");
}
Boolean(parseInt(3)) -> true; Boolean(parseInt("3")) -> true; Boolean(parseInt("three")) -> false
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 \d
eine 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
}
}
function isNumeric(n) { return !isNaN(n); }
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.