Mon objectif final est de valider un champ de saisie. L'entrée peut être alphabétique ou numérique.
Mon objectif final est de valider un champ de saisie. L'entrée peut être alphabétique ou numérique.
Réponses:
Si je ne me trompe pas, la question demande "contient un nombre", pas "est un nombre". Alors:
function hasNumber(myString) {
return /\d/.test(myString);
}
Vous pouvez le faire en utilisant javascript. Pas besoin de Jquery ou Regex
function isNumeric(n) {
return !isNaN(parseFloat(n)) && isFinite(n);
}
Lors de la mise en œuvre
var val = $('yourinputelement').val();
if(isNumeric(val)) { alert('number'); }
else { alert('not number'); }
Mise à jour: pour vérifier si une chaîne contient des nombres, vous pouvez utiliser des expressions régulières pour le faire
var matches = val.match(/\d+/g);
if (matches != null) {
alert('number');
}
matches != null
signifie pas undefined
ou null
alors que matches !== null
signifie spécifiquement non null
mais passe undefined
.
match()
renvoie un tableau ou null
. Donc ça if (matches !== null)
devrait aller (et ça plaira à JSHint.) Source: developer.mozilla.org/en/docs/Web/JavaScript/Reference/...
isFinite(parseFloat(n))
dans le premier exemple. isNumeric("5,000")
échoue.
isFinite()
donne true si la valeur passée est unfinite
nombre et que nombre 5,000
est une chaîne formatée de nombre et non un nombre fini.
isNaN
? Je suggérerais de supprimer le flottant d'analyse isNaN
ou de l'ajouter àisFinite
celui-ci.
function validate(){
var re = /^[A-Za-z]+$/;
if(re.test(document.getElementById("textboxID").value))
alert('Valid Name.');
else
alert('Invalid Name.');
}
Ce n'est en aucun cas à l'épreuve des balles, mais cela a fonctionné pour mes besoins et peut-être que cela aidera quelqu'un.
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
Utilisation d' expressions régulières avec JavaScript . Une expression régulière est une chaîne de texte spéciale pour décrire un modèle de recherche, qui est écrite sous la forme de / pattern / modifiers où "pattern" est l'expression régulière elle-même, et "modifiers" est une série de caractères indiquant diverses options.
La classe de caractères est le concept de regex le plus basique après une correspondance littérale. Cela permet à une petite séquence de caractères de correspondre à un plus grand ensemble de caractères. Par exemple, [A-Z]
pourrait représenter l'alphabet majuscule, et \d
pourrait signifier n'importe quel chiffre.
Exemple ci-dessous
contains_alphaNumeric
«Il vérifie si la chaîne contient une lettre ou un chiffre (ou) à la fois une lettre et un chiffre. Le tiret (-) est ignoré .onlyMixOfAlphaNumeric
«Il vérifie que la chaîne contient à la fois des lettres et des nombres de n'importe quel ordre de séquence.Exemple:
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) );
Production:
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 Correspondance de motifs avec des expressions régulières.
Pour tester si un caractère est un nombre, sans exagération❓, à adapter au besoin.
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)
Une façon de le vérifier consiste à parcourir la chaîne et à renvoyer true (ou false selon ce que vous voulez) lorsque vous frappez un nombre.
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;
}
}
}
Vous pouvez le faire en utilisant javascript. Pas besoin de Jquery ou Regex
function isNumeric(n) {
if(!isNaN(n))
{
return true
}
else
{
return false
}
}
function isNumeric(n) { return !isNaN(n); }
Ce code aide également à "Détecter les nombres dans une chaîne donnée" lorsque des nombres sont trouvés, il arrête son exécution.
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
fournit des nombres entiers lorsque la chaîne commence par la représentation d'un entier:
(parseInt '1a') is 1
..alors peut être:
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
Pardonnez mon CoffeeScript.