Comment faire pour autoriser uniquement numériques (0-9) en HTML inputbox à l'aide de jQuery?

^{Remarque: C'est une mise à jour de réponse. Les commentaires ci-dessous font référence à une ancienne version qui foiré autour avec les codes de touches.}

jQuery

La inputFilter plugin ci-dessous vous permet d'utiliser tout sorte de filtre d'entrée sur un texte <input>, y compris les divers filtres numériques. Cela permettra de gérer correctement:

• Copier+Coller
• Glisser+Chute
• tous les raccourcis clavier
• le cadre des opérations de menu
• tous les non-typable clés (par exemple, le curseur et les touches de navigation)
• la position du curseur
• toutes les dispositions de clavier (c'est à dire toutes les langues et les plates-formes)
• tous les navigateurs depuis IE 9

Essayer vous-même sur JSFiddle.

//Restricts input for each element in the set of matched elements to the given inputFilter.
(function($) {
  $.fn.inputFilter = function(inputFilter) {
    return this.on("input keydown keyup mousedown mouseup select contextmenu drop", function() {
      if (inputFilter(this.value)) {
        this.oldValue = this.value;
        this.oldSelectionStart = this.selectionStart;
        this.oldSelectionEnd = this.selectionEnd;
      } else if (this.hasOwnProperty("oldValue")) {
        this.value = this.oldValue;
        this.setSelectionRange(this.oldSelectionStart, this.oldSelectionEnd);
      }
    });
  };
}(jQuery));

$(document).ready(function() {
  //Restrict input to digits by using a regular expression filter.
  $("#myTextBox").inputFilter(function(value) {
    return /^\d*$/.test(value);
  });
});

Certains filtres d'entrée, vous pouvez utiliser:

• Entier (valeurs positives seulement):
  
  /^\d*$/.test(value)
• Entier valeurs (positives et jusqu'à une certaine limite):
  
  /^\d*$/.test(value) && (value === "" || parseInt(value) <= 500)
• Entier valeurs (positives et négatives):
  
  /^-?\d*$/.test(value)
• Virgule flottante valeurs (permettant à la fois . et , comme séparateur décimal):
  
  /^-?\d*[.,]?\d*$/.test(value)
• Monnaie valeurs (c'est à dire à plus de deux décimales):
  
  /^-?\d*[.,]?\d{0,2}$/.test(value)
• A-Z seulement (c'est à dire de base des lettres latines):
  
  /^[a-z]*$/i.test(value)
• Lettres latines seulement (c'est à dire l'anglais et la plupart des langues Européennes, voir https://unicode-table.com pour plus de détails sur les plages de caractères Unicode):
  
  /^[a-z\u00c0-\u024f]*$/i.test(value)
• Hexadécimal valeurs:
  
  /^[0-9a-f]*$/i.test(value)

Note que vous avez toujours doit faire côté serveur de validation!

Pur JavaScript (sans jQuery)

jQuery n'est pas réellement nécessaire pour cela, vous pouvez faire la même chose avec JavaScript ainsi. Voir cette réponse ou essayez-le vous-même sur JSFiddle.

HTML 5

HTML 5 a une solution native avec <input type="number"> (voir la spécification), mais notez que la prise en charge du navigateur varie:

• La plupart des navigateurs ne validez la saisie lors de la soumission du formulaire, et non pas lors de la saisie.
• La plupart des navigateurs mobiles ne prennent pas en charge la step, min et max attributs.
• Chrome (version 71.0.3578.98) permet toujours à l'utilisateur d'entrer les caractères e et E dans le domaine. Voir aussi cette question.
• Firefox (version 64.0) et Edge (EdgeHTML version 17.17134) encore permettre à l'utilisateur d'entrer tout texte dans le champ.

Essayer vous-même sur w3schools.com.

En ligne:

HTML:

<input name="number" onkeyup="if (/\D/g.test(this.value)) this.value = this.value.replace(/\D/g,'')">

Discrète style (avec jQuery):

JS:

$('input[name="number"]').keyup(function(e)
                                {
  if (/\D/g.test(this.value))
  {
    //Filter non-digits from input value.
    this.value = this.value.replace(/\D/g, '');
  }
});

HTML:

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<input name="number">

Vous pouvez utiliser sur l'entrée de l'événement comme ceci:

$(document).on("input", ".numeric", function() {
    this.value = this.value.replace(/\D/g,'');
});

Mais, qu'est-ce code privilège?

• Il fonctionne sur les navigateurs mobiles(keydown et de mot de code avoir de problème).
• Il fonctionne en AJAX le contenu généré par trop, parce que Nous sommes à l'aide de "sur".
• De meilleures performances que keydown, par exemple sur la pâte événement.

Utiliser la fonction JavaScript isNaN,

if (isNaN($('#inputid').val()))

if (isNaN(document.getElementById ("inputid').val()))

if (isNaN(document.getElementById('inputid').value))

Mise à jour:
Et voici un bel article qui parle de ça, mais à l'aide de jQuery: La restriction de l'Entrée dans les zones de texte HTML à des Valeurs Numériques

- Je l'utiliser dans notre commune fichier js. Je viens d'ajouter la classe à n'importe quelle entrée qui a besoin de ce comportement.

$(".numericOnly").keypress(function (e) {
    if (String.fromCharCode(e.keyCode).match(/[^0-9]/g)) return false;
});

Pourquoi faire si compliqué? Vous n'avez même pas besoin de jQuery car il y a un HTML5 modèle attribut:

<input type="text" pattern="[0-9]*">

Le truc cool, c'est qu'il apporte un clavier numérique sur les appareils mobiles, ce qui est nettement mieux que d'utiliser jQuery.

Le modèle de l'attribut HTML5 spécifie une expression régulière que la valeur de l'élément est vérifié contre.

  <input  type="text" pattern="[0-9]{1,3}" value="" />

Remarque: Le modèle de l'attribut fonctionne de la manière suivante types: texte, recherche, url, tel, email, mot de passe.

• [0-9] peut être remplacé par toute expression régulière condition.

• {1,3}, il représente un minimum de 1 et un maximum de 3 chiffres peuvent être saisis.

Quelque chose assez simple en utilisant l' jQuery.valider

$(document).ready(function() {
    $("#formID").validate({
        rules: {
            field_name: {
                numericOnly:true
            }
        }
    });
});

$.validator.addMethod('numericOnly', function (value) {
       return /^[0-9]+$/.test(value);
}, 'Please only enter numeric values (0-9)');

Je suis venu à une très bonne solution et simple qui n'empêche pas l'utilisateur de sélectionner du texte ou de le copier-coller d'autres solutions. jQuery style 🙂

$("input.inputPhone").keyup(function() {
    var jThis=$(this);
    var notNumber=new RegExp("[^0-9]","g");
    var val=jThis.val();

    //Math before replacing to prevent losing keyboard selection 
    if(val.match(notNumber))
    { jThis.val(val.replace(notNumber,"")); }
}).keyup(); //Trigger on page load to sanitize values set by server

Je pense que ça va aider tout le monde

  $('input.valid-number').bind('keypress', function(e) { 
return ( e.which!=8 && e.which!=0 && (e.which<48 || e.which>57)) ? false : true ;
  })

Ici est une solution rapide, j'ai créé il y a quelques temps. vous pouvez en lire plus à ce sujet dans mon article:

http://ajax911.com/numbers-numeric-field-jquery/

$("#textfield").bind("keyup paste", function(){
    setTimeout(jQuery.proxy(function() {
        this.val(this.val().replace(/[^0-9]/g, ''));
    }, $(this)), 0);
});

Cela semble incassable.

//Prevent NULL input and replace text.
$(document).on('change', 'input[type="number"]', function (event) {
this.value = this.value.replace(/[^0-9\.]+/g, '');
if (this.value < 1) this.value = 0;
});
//Block non-numeric chars.
$(document).on('keypress', 'input[type="number"]', function (event) {
return (((event.which > 47) && (event.which < 58)) || (event.which == 13));
});

Je tiens également à répondre 🙂

    $('.justNum').keydown(function(event){
var kc, num, rt = false;
kc = event.keyCode;
if(kc == 8 || ((kc > 47 && kc < 58) || (kc > 95 && kc < 106))) rt = true;
return rt;
})
.bind('blur', function(){
num = parseInt($(this).val());
num = isNaN(num) ? '' : num;
if(num && num < 0) num = num*-1;
$(this).val(num);
});

Que c'est...juste des numéros. 🙂 Presque il peut travailler seulement avec le "flou", mais...

Manière Simple de vérifier que d'entrer la valeur est numérique est:

var checknumber = $('#textbox_id').val();
if(jQuery.isNumeric(checknumber) == false){
alert('Please enter numeric value');
$('#special_price').focus();
return;
}

Vous pouvez essayer le HTML5 nombre d'entrée:

<input type="number" placeholder="enter the number" min="0" max="9">

Cette balise input élément devrait avoir qu'une valeur entre 0 à 9
comme min attribut est défini sur 0 et max attribut est fixé à 9.

pour plus d'informations sur la visite http://www.w3schools.com/html/html_form_input_types.asp

Il y a une incroyable problème de compatibilité avec l'aide des touches de détecter le caractère pressé... voir quirksmode pour en savoir plus à ce sujet.

Je conseille keyup pour créer un filtre parce que vous avez l' $(element).val() la méthode à utiliser pour évaluer l'effectif de caractères universels.

Ensuite, vous pouvez filtrer les NON des caractères à l'aide d'une expression régulière comme:

replace(/[^0-9]/g,");

Ce prend soin de toutes les questions, comme maj et coller des problèmes car il y a toujours un keyup et donc la valeur sera toujours évalué (sauf si javascript est désactivé).

Donc... en JQuery... Ici, c'est un peu inachevé plugin que je suis en train d'écrire, il est appelé masquesaisie (inputmask) et permettra de soutenir plus de masques lorsque vous avez terminé. Pour l'instant, on a les chiffres masque de travail.

Ici, il va...

/**
* @author Tom Van Schoor
* @company Tutuka Software
*/
(function($) {
/**
* @param {Object}
* $$options options to override settings
*/
jQuery.fn.inputmask = function($$options) {
var $settings = $.extend( {}, $.fn.inputmask.defaults, $$options);
return this.each(function() {
//$this is an instance of the element you call the plug-in on
var $this = $(this);
/*
* This plug-in does not depend on the metadata plug-in, but if this
* plug-in detects the existence of the metadata plug-in it will
* override options with the metadata provided by that plug-in. Look at
* the metadata plug-in for more information.
*/
//o will contain your defaults, overruled by $$options,
//overruled by the meta-data
var o = $.metadata ? $.extend( {}, $settings, $this.metadata()) : $settings;
/*
* if digits is in the array 'validators' provided by the options,
* stack this event handler
*/
if($.inArray('digits', o.validators) != -1) {
$this.keyup(function(e) {
$this.val(stripAlphaChars($this.val()));
});
}
/*
* There is no such things as public methods in jQuery plug-ins since
* there is no console to perform commands from a client side point of
* view. Typically only private methods will be fired by registered
* events as on-click, on-drag, etc... Those registered events could be
* seen as public methods.
*/
//private method
var stripAlphaChars = function(string) {
var str = new String(string); 
str = str.replace(/[^0-9]/g, ''); 
return str;
}
});
};
//static public functions
//jQuery.fn.inputmask.doSomething = function(attr) {
//};
//static public members
//jQuery.fn.inputmask.someStaticPublicMember;
//some default settings that can be overridden by either $$options or
//metadata
//If you need callback functions for the plug-in, this is where they get
//set
jQuery.fn.inputmask.defaults = {
validators : []
};
})(jQuery);

Pour l'utiliser, il suffit de ne:

$('#someElementId').inputmask({
validators: ['digits','someOtherNotYetImplementedValidator']
});

Le "someOtherNotYetImplementedValidator" est juste là pour montrer comment cela peut être élargi pour plus de futurs masques/validateurs. Vous pouvez ajouter ou à laisser, cela n'est pas rien casser 😉

Appologies pour le supplément de l'encombrement de commentaires, je suis en utilisant un modèle que j'ai créé pour les gars ici à l'œuvre.

Espère que cette aide,
Cheers

C'est pourquoi j'ai écrit récemment pour accomplir cette tâche. Je sais que cela a déjà été répondu, mais je vais la laisser pour plus tard utilise.

Cette méthode permet uniquement de 0 à 9 du clavier ou du pavé numérique, correction arrière, onglet, les flèches gauche et droite (forme normale des opérations)

$(".numbersonly-format").keydown(function (event) {
//Prevent shift key since its not needed
if (event.shiftKey == true) {
event.preventDefault();
}
//Allow Only: keyboard 0-9, numpad 0-9, backspace, tab, left arrow, right arrow, delete
if ((event.keyCode >= 48 && event.keyCode <= 57) || (event.keyCode >= 96 && event.keyCode <= 105) || event.keyCode == 8 || event.keyCode == 9 || event.keyCode == 37 || event.keyCode == 39 || event.keyCode == 46) {
//Allow normal operation
} else {
//Prevent the rest
event.preventDefault();
}
});

Si vous avez à résoudre des signes diacritiques et des caractères spéciaux, essayez d'utiliser ceci:

$(this).on( 'keypress', function( e )
{
//Ensure that it is a number and stop the keypress
if (e.shiftKey || (e.keyCode < 48 || e.keyCode > 57)) {
e.preventDefault();
}
});  

Mise à jour de la solution pour une meilleure expérience utilisateur, qui traite de la copier+coller question et remplace le mot de code obsolète attribut:

HTML

<input type="tel">

jQuery

$('[type=tel]').on('change', function(e) {
$(e.target).val($(e.target).val().replace(/[^\d]/g, ''))
})
$('[type=tel]').on('keypress', function(e) {
keys = ['0','1','2','3','4','5','6','7','8','9']
return keys.indexOf(event.key) > -1
})

Détails:

Tout d'abord, types d'entrée:

number montre les flèches haut/bas rétrécissement de l'entrée effective de l'espace, je les trouve moches et ne sont utiles que si le nombre représente une quantité, à une (des choses comme les téléphones, les codes, Id... n'en avez pas besoin)
tel offre les mêmes navigateur validations de nombre sans flèches

À l'aide de [nombre /tél] permet également de montrer clavier numérique sur les appareils mobiles.

Pour le JS de validation j'ai fini par avoir besoin de 2 fonctions, une pour l'utilisateur normal d'entrée (pression de touche) et l'autre pour un copier+coller fix (changement), d'autres combinaisons, il me donnerait une terrible expérience de l'utilisateur.

- Je utiliser le plus fiable KeyboardEvent.clé au lieu de la maintenant obsolète KeyboardEvent.charCode

Et en fonction de votre navigateur, vous pouvez envisager d'utiliser Tableau.le prototype.comprend() au lieu de la mal nommée Tableau.le prototype.indexOf() (pour de vrai /faux résultats)

Il est peut-être exagéré pour ce que vous cherchez, mais je suggère un plugin jQuery appelé autoNumeric() - c'est génial!

Vous pouvez limiter aux seuls chiffres, la précision décimale, valeurs max /min et plus.

http://www.decorplanit.com/plugin/

Beaucoup de gens sont à l'aide de keycode propriété qui n'est pas facile à retenir. Si vous ne disposez pas d'un jeu de paramètres régionaux questions, alors vous pouvez simplement utiliser clé qui est en fait l'entrée de l'utilisateur types.

Voir ce Violon

JS:

$("#txt").on("keypress",function(e){
console.log("Entered Key is " + e.key);
switch (e.key)
{
case "1":
case "2":
case "3":
case "4":
case "5":
case "6":
case "7":
case "8":
case "9":
case "0":
case "Backspace":
return true;
break;
case ".":
if ($(this).val().indexOf(".") == -1) //Checking if it already contains decimal. You can Remove this condition if you do not want to include decimals in your input box.
{
return true;
}
else
{
return false;
}
break;
default:
return false;
}
});

HTML:

<script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.1/jquery.min.js"></script>
Enter Value
<input id="txt" type="text" />

question est alors de voir la suite de code simple.

Veuillez noter que cet exemple contient également de validation pour les décimales entrée.

Que par cette question, il n'est pas nécessaire, de sorte que vous pouvez simplement supprimer le cas "." pour supprimer l'entrée de décimales.

Vous pouvez utiliser la validation HTML5 sur votre texte entrées par l'ajout d'un motif. Pas besoin de valider manuellement avec la regex ou les codes de touches.

<input type="text" pattern="[0-9.]+" />
$("input[type=text][pattern]").on("input", function () {
if (!this.checkValidity())
this.value = this.value.slice(0, -1);
});

---

Possible, mais pas aussi simple pour les entrées [type=numéro]...

Le problème avec [type="nombre"] est que nous ne pouvons pas supprimer le caractère non valide à la fin. Les Agents d'Utilisateur retourne une chaîne vide à chaque fois que l'entrée est invalide.

Du W3C HTML5 spec:

Si la valeur de l'élément n'est pas valide d'un nombre à virgule flottante, puis
définir une chaîne de caractères vide à la place.

https://dev.w3.org/html5/spec-LC/number-state.html#number-state

Cela signifie que nous avons besoin d'un moyen de stocker de l'entrée précédente de la valeur à la main.

Donc, pour nombre d'entrées, la solution devrait ressembler à ceci:

$("input[type=number], input[type=text][pattern]").on("input", function () {
if (!this.checkValidity())
this.value = $(this).data("current-valid") || "";
else
$(this).data("current-valid", this.value);
});

---

Malheureusement, cela ne fonctionne pas sur IE et EDGE. Nous avons besoin de recourir au modèle de la solution ci-dessus pour ces navigateurs. Cependant, vous pouvez toujours utiliser ce numéro entrées avec cette simple polyfill.

$("input[type=number]").attr("type", "text").attr("pattern", "[0-9.]+");

ajouter le code ci-dessous dans le document.prêt

    $('.class of text box').keyup(function () 
{
this.value = this.value.replace(/[^0-9]/g, '');
});  

Je suis en utilisant ce formulaire. Semble correct pour me permettre de touches accueil, fin, maj et ctrl, avec l'inconvénient de l'utilisateur peut imprimer des caractères spéciaux:

$("#busca_cep").keydown(function(event) {
if ( event.keyCode == 46 || event.keyCode == 8 || event.keyCode == 13 || event.keyCode == 16 || event.keyCode == 36 || event.keyCode == 35) {
if (event.keyCode == 13) {
localiza_cep(this.value);
}
} else {
if ((event.keyCode < 48 || event.keyCode > 57) && (event.keyCode < 96 || event.keyCode > 105 )) {
event.preventDefault(); 
}   
}
});

jQuery("#no_of").keypress(function(event){
//Allow only backspace and delete
if (event.keyCode != 46 && event.keyCode != 8) {
if (!parseInt(String.fromCharCode(event.which))) {
event.preventDefault();
}
}
});
jQuery("#no_of").keyup(function(e){
var temp_s= jQuery("#no_of").val();
var multiply_val= temp_s*10;
jQuery("#ex-r").html(multiply_val);
});

$(document).ready(function()
{
$("#textBoxId").bind("change",checkInput);
});
function checkInput()
{
//check if $('#textBoxId').val() is under your constraints
//then change its value, removing the last character
//since this event will be called each time you
//type a character
}

Remaniée de la accepté de répondre afin que les commentaires ne doivent plus utilisé parce que je déteste les commentaires. Aussi c'est plus facile à tester avec le jasmin.

    allowBackspaceDeleteTabEscapeEnterPress: function(event){
return ($.inArray(event.keyCode, [46, 8, 9, 27, 13, 190]) >= 0);
},
allowContorlAPress: function(event){
return (event.keyCode == 65 && event.ctrlKey === true)
},
allowHomeEndLeftRightPress: function(event){
return (event.keyCode >= 35 && event.keyCode <= 39)
},
theKeyPressedIsEditRelated: function (event) {
return (this.allowBackspaceDeleteTabEscapeEnterPress(event)
|| this.allowContorlAPress(event)
|| this.allowHomeEndLeftRightPress(event));
},
isNotFromTheNumKeyPad: function (event) {
return (event.keyCode < 96 || event.keyCode > 105);
},
isNotFromTopRowNumberKeys: function (event) {
return (event.keyCode < 48 || event.keyCode > 57);
},
theKeyIsNonNumeric: function (event) {
return (event.shiftKey
|| (this.isNotFromTopRowNumberKeys(event)
&& this.isNotFromTheNumKeyPad(event)));
},
bindInputValidator: function(){
$('.myinputclassselector').keydown(function (event) {
if(this.validateKeyPressEvent(event)) return false;
});
},
validateKeyPressEvent: function(event){
if(this.theKeyPressedIsEditRelated(event)){
return;
} else {
if (this.theKeyIsNonNumeric(event)) {
event.preventDefault();
}
}
}

J'ai combiné les réponses de l'un et de venir avec le code suivant:

jQuery('#input_id', function(e){
//Allow: backspace, delete, tab, escape, enter
if (jQuery.inArray(e.keyCode, [46, 8, 9, 27, 13, 110]) !== -1 ||
//Allow: Ctrl+A
(e.keyCode === 65 && e.ctrlKey === true) ||
//Allow: Ctrl+C
(e.keyCode === 67 && e.ctrlKey === true) ||
//Allow: Ctrl+X
(e.keyCode === 88 && e.ctrlKey === true) ||
//Disallow several dots (allow 190 only if no dots found)
(e.keyCode === 190 && jQuery(this).val().indexOf('.') == -1) ||
//Bug in some Android devices where it is always 229
(e.keyCode === 229) ||
//Allow: home, end, left, right
(e.keyCode >= 35 && e.keyCode <= 40)) {
//let it happen, don't do anything
return;
}
//Ensure that it is a number and stop the keypress
if ((e.shiftKey || (e.keyCode < 48 || e.keyCode > 57)) && (e.keyCode < 96 || e.keyCode > 105)) {
e.preventDefault();
}
});

En outre, la forme devrait avoir autocomplete="off". Sans cette option, vous pourriez avoir des problèmes avec l'auto-complétion des algorithmes sur des appareils mobiles.

Essayer celui-ci

$('.plan_eff').keyup(function () {     
this.value = this.value.replace(/[^1-9\.]/g,'');
});

Aucune réponse n'a fonctionné dans mon cas, j'ai donc fait un peu de changement dans la accepté de répondre à la faire fonctionner pour Dynamiquement ajouté des éléments.

Profiter :

var inputFilter = function (elem, cb) {
/*
*    /^-?\d*$/              restricts input to integer numbers
*    /^\d*$/                restricts input to unsigned integer numbers
*    /^[0-9a-f]*$/i          restricts input to hexadecimal numbers
*    /^-?\d*[.,]?\d*$/      restricts input to floating point numbers (allowing both . and , as decimal separator)
*    /^-?\d*[.,]?\d{0,2}$/  restricts input to currency values (i.e. at most two decimal places)
*/
bdy.on('input keydown keyup mousedown mouseup select contextmenu drop', elem, function () {
if (cb(this.value)) {
this.oldValue = this.value;
this.oldSelectionStart = this.selectionStart;
this.oldSelectionEnd = this.selectionEnd;
} else if (this.hasOwnProperty('oldValue')) {
this.value = this.oldValue;
this.setSelectionRange(this.oldSelectionStart, this.oldSelectionEnd);
}
});
};

Utilisation :

inputFilter('#onlyDigitsInput', function (val) {
return /^\d*$/.test(val);
});

function validate_profile(frmid) {
var form = $('#' + frmid);
var error = $('.alert-danger', form);
var success = $('.alert-success', form);
form.validate({
errorElement: 'span', //default input error message container
errorClass: 'help-block', //default input error message class
focusInvalid: true, //do not focus the last invalid input
ignore: "",
rules: {
contact_no: {
required: true,
minlength: 10,
maxlength: 10,
number: true
}, email_id: {
required: true,
email: true
}
},
invalidHandler: function (event, validator) { //display error alert on form submit   
success.hide();
error.show();
Metronic.scrollTo(error, -7000);
},
highlight: function (element) { //hightlight error inputs
$(element)
.closest('.form-group').addClass('has-error'); //un set error class to the control group
$(element)
.closest('.form-group').removeClass('has-success'); //set success class to the control group
},
unhighlight: function (element) { //revert the change done by hightlight
$(element)
.closest('.form-group').removeClass('has-error'); //un set error class to the control group
$(element)
.closest('.form-group').addClass('has-success'); //set success class to the control group
error.hide();
},
success: function (label) {
label.closest('.form-group').removeClass('has-error');
label.closest('.form-group').addClass('has-success');
},
submitHandler: function (form) {
success.show();
error.hide();
form.submit();
}
});
}

function Numbers(e)
{
if($.browser.msie)
{
if(e.keyCode > 47 && e.keyCode < 58)
return true;
else
return false;
}
else
{
if((e.charCode > 47 && e.charCode < 58) || (e.charCode == 0))
return true;
else
return false;
}
}

J'espère que cela fonctionnera sur tous les navigateurs.