Regex pour vérifier si une chaîne ne contient que des nombres
hash = window.location.hash.substr(1);
var reg = new RegExp('^[0-9]$');
console.log(reg.test(hash));
Je reçois faux sur "123" et "123f". Je voudrais vérifier si le hachage ne contient que des chiffres. Ai-je manqué quelque chose?
var reg = /^\d+$/;
devrait le faire. L'original correspond à tout ce qui consiste en exactement un chiffre.
Comme vous l'avez dit, vous voulez que le hash ne contienne que des chiffres.
var reg = new RegExp('^[0-9]+$');
ou
var reg = new RegExp('^\\d+$');
\d et [0-9] signifient la même chose . Le + utilisé signifie que la recherche d'un ou plusieurs événements de [0-9].
Celui-ci autorisera également les nombres signés et flottants ou les chaînes vides
var reg = /^-?\d*\.?\d*$/
Si vous ne voulez pas autoriser la chaîne vide, utilisez celle-ci:
var reg = /^-?\d+\.?\d*$/
var validation = {
isEmailAddress:function(str) {
var pattern =/^\w+([\.-]?\w+)*@\w+([\.-]?\w+)*(\.\w{2,3})+$/;
return pattern.test(str); // returns a boolean
},
isNotEmpty:function (str) {
var pattern =/\S+/;
return pattern.test(str); // returns a boolean
},
isNumber:function(str) {
var pattern = /^\d+$/;
return pattern.test(str); // returns a boolean
},
isSame:function(str1,str2){
return str1 === str2;
}
};
alert(validation.isNotEmpty("dff"));
alert(validation.isNumber(44));
alert(validation.isEmailAddress("[email protected]"));
alert(validation.isSame("sf","sf"));
C'est un excès extrême pour votre objectif, mais voici ce que j'utilise:
var numberReSnippet = "(?:NaN|-?(?:(?:\\d+|\\d*\\.\\d+)(?:[E|e][+|-]?\\d+)?|Infinity))";
var matchOnlyNumberRe = new RegExp("^("+ numberReSnippet + ")$");
À ma connaissance, cela correspond à toutes les variations de nombres que Java et JavaScript vous infligeront jamais, notamment "-Infinity", "1e-24" et "NaN". Il correspond également aux nombres que vous pourriez taper, tels que "-.5".
Comme il est écrit, reSnippet est conçu pour être déposé dans d'autres expressions rationnelles afin que vous puissiez extraire (ou éviter) des nombres. Malgré toutes les parenthèses, il ne contient aucun groupe de capture. Ainsi, "matchOnlyNumberRe" correspond uniquement aux chaînes qui sont des nombres et possède un groupe de capture pour la chaîne entière.
Voici les tests Jasmine, vous pouvez donc voir ce qu’il gère et ne gère pas:
describe("Number Regex", function() {
var re = new RegExp("^("+ numberReSnippet + ")$");
it("Matches Java and JavaScript numbers", function() {
expect(re.test( "1")).toBe(true);
expect(re.test( "0.2")).toBe(true);
expect(re.test( "0.4E4")).toBe(true); // Java-style
expect(re.test( "-55")).toBe(true);
expect(re.test( "-0.6")).toBe(true);
expect(re.test( "-0.77E77")).toBe(true);
expect(re.test( "88E8")).toBe(true);
expect(re.test( "NaN")).toBe(true);
expect(re.test( "Infinity")).toBe(true);
expect(re.test( "-Infinity")).toBe(true);
expect(re.test( "1e+24")).toBe(true); // JavaScript-style
});
it("Matches fractions with a leading decimal point", function() {
expect(re.test( ".3")).toBe(true);
expect(re.test( "-.3")).toBe(true);
expect(re.test( ".3e-4")).toBe(true);
});
it("Doesn't match non-numbers", function() {
expect(re.test( ".")).toBe(false);
expect(re.test( "9.")).toBe(false);
expect(re.test( "")).toBe(false);
expect(re.test( "E")).toBe(false);
expect(re.test( "e24")).toBe(false);
expect(re.test( "1e+24.5")).toBe(false);
expect(re.test("-.Infinity")).toBe(false);
});
});
^[0-9]$
... est une expression régulière correspondant à n'importe quel chiffre, donc 1 retournera vrai mais 123 retournera faux.
Si vous ajoutez le * quantificateur,
^[0-9]*$
l'expression correspondra à des chaînes de longueur arbitraire de chiffres et 123 renverra true. (123f retournera toujours faux).
Sachez que techniquement, une chaîne vide est une chaîne de chiffres de longueur nulle. Elle renverra donc true avec ^ [0-9] * $ Si vous souhaitez n'accepter que des chaînes contenant un ou plusieurs chiffres, utilisez + au lieu de *.
^[0-9]+$
Comme de nombreux autres l’ont souligné, il existe plusieurs moyens d’y parvenir, mais j’ai estimé qu’il était approprié de souligner que le code de la question initiale ne nécessite qu’un seul caractère supplémentaire pour fonctionner comme prévu.
Cette fonction vérifie si l'entrée est numérique au sens classique du terme, car on s'attend à ce qu'une fonction de détection de nombre normale fonctionne.
C'est un test que l'on peut utiliser pour l'entrée de formulaire HTML, par exemple.
Il contourne tout le folklore JS, comme tipeof (NaN) = nombre, parseint ('1 Kg') = 1, booléens contraints à des nombres, etc.
Pour ce faire, il convertit l'argument sous forme de chaîne et vérifie cette chaîne par rapport à une expression rationnelle semblable à celle de @ nom de code, tout en permettant des entrées telles que 5. et .5
function isANumber( n ) {
var numStr = /^-?(\d+\.?\d*)$|(\d*\.?\d+)$/;
return numStr.test( n.toString() );
}
not numeric:
Logger.log( 'isANumber( "aaa" ): ' + isANumber( 'aaa' ) );
Logger.log( 'isANumber( "" ): ' + isANumber( '' ) );
Logger.log( 'isANumber( "lkjh" ): ' + isANumber( 'lkjh' ) );
Logger.log( 'isANumber( 0/0 ): ' + isANumber( 0 / 0 ) );
Logger.log( 'isANumber( 1/0 ): ' + isANumber( 1 / 0 ) );
Logger.log( 'isANumber( "1Kg" ): ' + isANumber( '1Kg' ) );
Logger.log( 'isANumber( "1 Kg" ): ' + isANumber( '1 Kg' ) );
Logger.log( 'isANumber( false ): ' + isANumber( false ) );
Logger.log( 'isANumber( true ): ' + isANumber( true ) );
numeric:
Logger.log( 'isANumber( "0" ): ' + isANumber( '0' ) );
Logger.log( 'isANumber( "12.5" ): ' + isANumber( '12.5' ) );
Logger.log( 'isANumber( ".5" ): ' + isANumber( '.5' ) );
Logger.log( 'isANumber( "5." ): ' + isANumber( '5.' ) );
Logger.log( 'isANumber( "-5" ): ' + isANumber( '-5' ) );
Logger.log( 'isANumber( "-5." ): ' + isANumber( '-5.' ) );
Logger.log( 'isANumber( "-.5" ): ' + isANumber( '-5.' ) );
Logger.log( 'isANumber( "1234567890" ): ' + isANumber( '1234567890' ));
Explication de la regex:
/^-?(\d+\.?\d*)$|(\d*\.?\d+)$/
Le "^" initial et le "$" final correspondent au début et à la fin de la chaîne, afin de s'assurer que la vérification couvre toute la chaîne. Le "-?" une partie est le signe moins avec le "?" multiplicateur qui permet zéro ou une instance de celui-ci.
Ensuite, il existe deux groupes similaires, délimités par des parenthèses. La chaîne doit correspondre à l'un de ces groupes. Le premier correspond à des chiffres comme 5. et le second .5
Le premier groupe est
\d+\.?\d*
Le "\ d +" correspond à un chiffre (\ d) une ou plusieurs fois.
Le "\.?" est le point décimal (échappé avec "\" pour le débarrasser de sa magie), zéro ou une fois.
La dernière partie "\ d *" est encore un chiffre, zéro ou plusieurs fois.
Toutes les parties sont facultatives, sauf le premier chiffre, ce groupe correspond donc à des nombres tels que 5. et non à .5 qui sont appariés par l'autre moitié.
Si vous n'avez besoin que de nombres entiers positifs et que vous n'avez pas besoin de zéros à gauche (par exemple "0001234" ou "00")
var reg = /^(?:[1-9]\d*|\d)$/;
Pourquoi ne pas utiliser quelque chose comme:
$.isNumeric($(input).val())
Est-ce que jquery est testé, et les cas les plus courants sont vérifiés
Si les chiffres ne sont pas supposés être absurdement énormes, utilisez peut-être:
new RegExp(
'^' + // No leading content.
'[-+]?' + // Optional sign.
'(?:[0-9]{0,30}\\.)?' + // Optionally 0-30 decimal digits of mantissa.
'[0-9]{1,30}' + // 1-30 decimal digits of integer or fraction.
'(?:[Ee][-+]?[1-2]?[0-9])?' + // Optional exponent 0-29 for scientific notation.
'$' // No trailing content.
)
Cela tente d'éviter certains scénarios, juste au cas où:
- Débordement des tampons auxquels la chaîne d'origine pourrait être transmise.
- La lenteur ou les anomalies causées par des nombres dénormaux comme
1E-323. - Passer
Infinitylorsqu'un nombre fini est attendu (essayez1E309ou-1E309).
Vous avez besoin du * pour qu'il indique "zéro ou plus du caractère précédent" et cela devrait le faire:
var reg = new RegExp('^\\d*$');
Lors de la saisie, si vous souhaitez filtrer les autres caractères et ne montrer que les chiffres dans le champ de saisie, vous pouvez remplacer la valeur du champ lors de la modification:
var yourInput = jQuery('#input-field');
yourInput.keyup(function() {
yourInput.val((yourInput.val().replace(/[^\d]/g,'')))
})
Vous pouvez également utiliser les méthodes suivantes mais connaître leur implémentation interne et/ou leurs valeurs de retour.
1A isNaN(+'13761123123123'); // returns true
1B isNaN(+'13761123123ABC'); // returns false
2A ~~'1.23'; // returns 1
2B ~~'1.2A'; // returns 0
Pour 1A & 1B, le type de chaîne est d'abord forcé à l'aide de l'opérateur + avant d'être passé à la fonction isNaN(). Cela fonctionne car un type de nombre qui inclut des valeurs non numériques renvoie NaN. Il y a des considérations avec les détails de l'implémentation isNaN()'s qui sont documentés ici . Une considération est si une valeur booléenne est passée comme isNaN(+false|true) sont forcés à leurs équivalents numériques et ainsi false est retourné mais on pourrait s'attendre à ce que la fonction retourne true puisque la valeur booléenne n'est pas numérique au sens de ce que nous testons.
Pour 2A & 2B, il convient de noter que pour trouver le complément du nombre, la valeur donnée en question doit se situer dans la plage des valeurs d'un entier signé de 32 bits pouvant être référencé dans le spec .
Ma préférence personnelle, bien que l’on puisse dire qu’elle est moins lisible car ils incluent l’opérateur unaire, est 1A & 1B en raison de la rapidité et de la concision.
Simple Regex javascript
var cnpj = "12.32.432/1-22".replace(/\D/gm,"");
console.log(cnpj);
*Résultat :
1232432122
Vérifications pour les numéros uniquement:
if(cnpj.length > 0){
return true;
}
Exemple simple
if("12.32.432/1-22".replace(/\D/gm,"").length > 0){
console.log("Ok.");
}
Peut-être que ça marche:
let a = "1234"
parseInt(a) == a // true
let b = "1234abc"
parseInt(b) == b // false
\d ne correspondra pas à la virgule décimale. Utilisez ce qui suit pour la décimale.
const re = /^[0-9.]+$/
'123'.match(re) // true
'123.3'.match(re) // true
'123!3'.match(re) // false
Je vois que vous avez déjà reçu beaucoup de réponses, mais si vous recherchez une expression régulière pouvant correspondre à des nombres entiers et des nombres à virgule flottante, celle-ci fonctionnera pour vous:
var reg = /^-?\d*\.?\d+$/;