Jak najlepiej ograniczyć wprowadzanie „liczb” tylko dla pól tekstowych?

Szukam czegoś, co pozwala na kropki dziesiętne.

Widzę wiele przykładów. Ale jeszcze nie zdecydowałem, którego użyć.

Aktualizacja od Praveen Jeganathan

Nigdy więcej wtyczek, jQuery zaimplementowało swoją własną jQuery.isNumeric()dodaną w wersji 1.7. Zobacz: https://stackoverflow.com/a/20186188/66767

Aktualizacja

Istnieje na to nowe i bardzo proste rozwiązanie:

Pozwala na użycie dowolnego rodzaju filtra wejściowego na tekście <input>, w tym różnych filtrów numerycznych. To będzie poprawnie obsługiwać Kopiuj + Wklej, Przeciągnij + Upuść, skróty klawiaturowe, operacje menu kontekstowego, klawisze bez możliwości pisania i wszystkie układy klawiatury.

Zobacz tę odpowiedź lub spróbuj sam na JSFiddle .

wtyczka jquery.numeric

Z powodzeniem zaimplementowałem wiele formularzy za pomocą wtyczki jquery.numeric .

$(document).ready(function(){
    $(".numeric").numeric();
});

Ponadto działa to również w obszarach tekstowych!

Pamiętaj jednak, że Ctrl + A, Kopiuj + Wklej (poprzez menu kontekstowe) oraz Przeciągnij + Upuść nie będą działać zgodnie z oczekiwaniami.

HTML 5

Dzięki szerszej obsłudze standardu HTML 5 możemy użyć patternatrybutu i numbertypu inputelementów, aby ograniczyć wprowadzanie tylko liczb. W niektórych przeglądarkach (zwłaszcza Google Chrome) działa również w celu ograniczenia wklejania treści nienumerycznych. Więcej informacji na temat numberi innych nowszych typów danych wejściowych można znaleźć tutaj .

Jeśli chcesz ograniczyć wprowadzanie danych (w przeciwieństwie do sprawdzania poprawności), możesz pracować z kluczowymi zdarzeniami. coś takiego:

<input type="text" class="numbersOnly" value="" />

I:

jQuery('.numbersOnly').keyup(function () { 
    this.value = this.value.replace(/[^0-9\.]/g,'');
});

To natychmiast informuje użytkownika, że ​​nie może wprowadzić znaków alfanumerycznych itp., A nie później w fazie sprawdzania poprawności.

Nadal będziesz chciał sprawdzić poprawność, ponieważ dane wejściowe można wypełnić, wycinając i wklejając za pomocą myszy lub ewentualnie autouzupełniacza formularzy, który może nie wyzwalać kluczowych zdarzeń.

Myślałem, że najlepszą odpowiedzią była powyższa odpowiedź.

jQuery('.numbersOnly').keyup(function () {  
    this.value = this.value.replace(/[^0-9\.]/g,''); 
});

ale zgadzam się, że to trochę bolesne, że klawisze strzałek i przycisk usuwania przyciągają kursor do końca łańcucha (iz tego powodu został odesłany do mnie podczas testowania)

Dodałem w prostej zmianie

$('.numbersOnly').keyup(function () {
    if (this.value != this.value.replace(/[^0-9\.]/g, '')) {
       this.value = this.value.replace(/[^0-9\.]/g, '');
    }
});

w ten sposób, jeśli zostanie naciśnięty dowolny przycisk, który nie spowoduje zmiany tekstu, zignoruj ​​go. Dzięki temu możesz uderzać strzałkami i usuwać bez przeskakiwania do końca, ale usuwa wszystkie nieliczbowe teksty.

Wtyczka jquery.numeric zawiera kilka błędów, o których powiadomiłem autora. Umożliwia wiele kropek dziesiętnych w Safari i Operze, a w Operze nie można wpisywać spacji, klawiszy strzałek ani kilku innych znaków kontrolnych. Potrzebowałem dodatniej liczby całkowitej, więc ostatecznie napisałem własną.

$(".numeric").keypress(function(event) {
  // Backspace, tab, enter, end, home, left, right
  // We don't support the del key in Opera because del == . == 46.
  var controlKeys = [8, 9, 13, 35, 36, 37, 39];
  // IE doesn't support indexOf
  var isControlKey = controlKeys.join(",").match(new RegExp(event.which));
  // Some browsers just don't raise events for control keys. Easy.
  // e.g. Safari backspace.
  if (!event.which || // Control keys in most browsers. e.g. Firefox tab is 0
      (49 <= event.which && event.which <= 57) || // Always 1 through 9
      (48 == event.which && $(this).attr("value")) || // No 0 first digit
      isControlKey) { // Opera assigns values for control keys.
    return;
  } else {
    event.preventDefault();
  }
});

Nigdy więcej wtyczek, jQuery zaimplementowało własną wersję jQuery.isNumeric () dodaną w wersji 1.7.

jQuery.isNumeric( value )

Określa, czy jego argument jest liczbą.

Wyniki próbek

$.isNumeric( "-10" );     // true
$.isNumeric( 16 );        // true
$.isNumeric( 0xFF );      // true
$.isNumeric( "0xFF" );    // true
$.isNumeric( "8e5" );     // true (exponential notation string)
$.isNumeric( 3.1415 );    // true
$.isNumeric( +10 );       // true
$.isNumeric( 0144 );      // true (octal integer literal)
$.isNumeric( "" );        // false
$.isNumeric({});          // false (empty object)
$.isNumeric( NaN );       // false
$.isNumeric( null );      // false
$.isNumeric( true );      // false
$.isNumeric( Infinity );  // false
$.isNumeric( undefined ); // false

Oto przykład, jak powiązać metodę isNumeric () z detektorem zdarzeń

$(document).on('keyup', '.numeric-only', function(event) {
   var v = this.value;
   if($.isNumeric(v) === false) {
        //chop off the last char entered
        this.value = this.value.slice(0,-1);
   }
});

Wspomniana wtyczka numeryczna () nie działa w Operze (nie można cofać, usuwać ani nawet używać klawiszy Wstecz lub Dalej).

Poniższy kod zarówno w JQuery, jak i JavaScript będzie działał idealnie (i to tylko dwie linie).

JQuery:

$(document).ready(function() {
    $('.key-numeric').keypress(function(e) {
            var verified = (e.which == 8 || e.which == undefined || e.which == 0) ? null : String.fromCharCode(e.which).match(/[^0-9]/);
            if (verified) {e.preventDefault();}
    });
});

JavaScript:

function isNumeric(e)
{
    var keynum = (!window.event) ? e.which : e.keyCode;
    return !((keynum == 8 || keynum == undefined || e.which == 0) ? null : String.fromCharCode(keynum).match(/[^0-9]/));
}

Oczywiście dotyczy to wyłącznie wprowadzania liczbowego (plus klawisze Backspace, Delete, Forward / Back), ale można je łatwo zmienić tak, aby zawierały punkty i znaki minus.

Możesz użyć wtyczki Validation z jej metodą number () .

$("#myform").validate({
  rules: {
    field: {
      required: true,
      number: true
    }
  }
});

Nie musisz używać długiego kodu do ograniczenia wprowadzania liczb, po prostu wypróbuj ten kod.

Akceptuje również prawidłowe int i float obie wartości.

Podejście JavaScript

onload =function(){ 
  var ele = document.querySelectorAll('.number-only')[0];
  ele.onkeypress = function(e) {
     if(isNaN(this.value+""+String.fromCharCode(e.charCode)))
        return false;
  }
  ele.onpaste = function(e){
     e.preventDefault();
  }
}

<p> Input box that accepts only valid int and float values.</p>
<input class="number-only" type=text />

Podejście jQuery

$(function(){

  $('.number-only').keypress(function(e) {
	if(isNaN(this.value+""+String.fromCharCode(e.charCode))) return false;
  })
  .on("cut copy paste",function(e){
	e.preventDefault();
  });

});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<p> Input box that accepts only valid int and float values.</p>
<input class="number-only" type=text />

AKTUALIZACJA

Powyższe odpowiedzi dotyczą najczęstszego przypadku użycia - sprawdzanie poprawności danych wejściowych jako liczby.

Ale poniżej znajduje się fragment kodu dla specjalnych przypadków użycia

• Zezwalanie na liczby ujemne
• Pokazuje nieprawidłowe naciśnięcie klawisza przed jego usunięciem.

$(function(){
      
  $('.number-only').keyup(function(e) {
        if(this.value!='-')
          while(isNaN(this.value))
            this.value = this.value.split('').reverse().join('').replace(/[\D]/i,'')
                                   .split('').reverse().join('');
    })
    .on("cut copy paste",function(e){
    	e.preventDefault();
    });

});

<script src="https://ajax.googleapis.com/ajax/libs/jquery/2.1.1/jquery.min.js"></script>
<p> Input box that accepts only valid int and float values.</p>
<input class="number-only" type=text />

Poniżej znajduje się to, czego używam do dosłownie blokowania naciśnięć klawiszy. Pozwala to tylko na liczby 0–9 i przecinek dziesiętny. Łatwy do wdrożenia, nie ma dużo kodu i działa jak urok:

<script>
function isNumberKey(evt) {
    var charCode = (evt.which) ? evt.which : event.keyCode;
    if (charCode != 46 && charCode > 31 && (charCode < 48 || charCode > 57)) {
        return false;
    } else {
        return true;
    }      
}
</script>

<input value="" onkeypress="return isNumberKey(event)">

Jako niewielką poprawę tej sugestii możesz użyć wtyczki Validation z jej metodami number () , digits i range . Na przykład następujące zapewnia, że ​​otrzymasz dodatnią liczbę całkowitą od 0 do 50:

$("#myform").validate({
  rules: {
    field: {
      required: true,
      number: true,
      digits: true,
      range : [0, 50]
    }
  }
});

Nie widać magicznego wyglądu i zniknięcia alfabetu po naciśnięciu klawisza. Działa to również w przypadku wklejania myszy.

$('#txtInt').bind('input propertychange', function () {
    $(this).val($(this).val().replace(/[^0-9]/g, ''));
});

Najpierw próbowałem rozwiązać ten problem za pomocą jQuery, ale nie cieszyłem się, że niepożądane znaki (niebędące cyframi) faktycznie pojawiały się w polu wejściowym tuż przed ich usunięciem przy kluczowaniu.

Poszukując innych rozwiązań znalazłem to:

Liczby całkowite (nieujemne)

<script>
  function numbersOnly(oToCheckField, oKeyEvent) {
    return oKeyEvent.charCode === 0 ||
        /\d/.test(String.fromCharCode(oKeyEvent.charCode));
  }
</script>

<form name="myForm">
<p>Enter numbers only: <input type="text" name="myInput" 
    onkeypress="return numbersOnly(this, event);" 
    onpaste="return false;" /></p>
</form>

Źródło: https://developer.mozilla.org/en-US/docs/Web/API/GlobalEventHandlers.onkeypress#Example Przykład na żywo: http://jsfiddle.net/u8sZq/

Kropki dziesiętne (nieujemne)

Aby zezwolić na pojedynczy przecinek dziesiętny, możesz zrobić coś takiego:

<script>
  function numbersOnly(oToCheckField, oKeyEvent) {        
    var s = String.fromCharCode(oKeyEvent.charCode);
    var containsDecimalPoint = /\./.test(oToCheckField.value);
    return oKeyEvent.charCode === 0 || /\d/.test(s) || 
        /\./.test(s) && !containsDecimalPoint;
  }
</script>

Źródło: Właśnie to napisałem. Wydaje się, że działa. Przykład na żywo: http://jsfiddle.net/tjBsF/

Inne dostosowania

• Aby umożliwić wpisywanie większej liczby symboli, wystarczy dodać je do wyrażenia regularnego, które działa jako podstawowy filtr kodu char.
• Aby wdrożyć proste ograniczenia kontekstowe, spójrz na bieżącą zawartość (stan) pola wejściowego (oToCheckField.value)

Niektóre rzeczy, które możesz zainteresować:

• Dozwolony jest tylko jeden przecinek dziesiętny
• Zezwalaj na znak minus tylko wtedy, gdy znajduje się na początku łańcucha. Pozwoliłoby to na liczby ujemne.

Niedociągnięcia

• Pozycja karetki nie jest dostępna wewnątrz funkcji. To znacznie zmniejszyło ograniczenia kontekstowe, które można wprowadzić (np. Brak dwóch równych kolejnych symboli). Nie jestem pewien, jaki jest najlepszy sposób na to.

Wiem, że tytuł prosi o rozwiązania jQuery, ale mam nadzieję, że ktoś i tak okaże się przydatny.

Dzięki za post Dave Aaron Smith

Zredagowałem twoją odpowiedź, aby zaakceptować kropkę dziesiętną i liczbę z sekcji liczb. Ta praca jest dla mnie idealna.

$(".numeric").keypress(function(event) {
  // Backspace, tab, enter, end, home, left, right,decimal(.)in number part, decimal(.) in alphabet
  // We don't support the del key in Opera because del == . == 46.
  var controlKeys = [8, 9, 13, 35, 36, 37, 39,110,190];
  // IE doesn't support indexOf
  var isControlKey = controlKeys.join(",").match(new RegExp(event.which));
  // Some browsers just don't raise events for control keys. Easy.
  // e.g. Safari backspace.
  if (!event.which || // Control keys in most browsers. e.g. Firefox tab is 0
      (49 <= event.which && event.which <= 57) || // Always 1 through 9
      (96 <= event.which && event.which <= 106) || // Always 1 through 9 from number section 
      (48 == event.which && $(this).attr("value")) || // No 0 first digit
      (96 == event.which && $(this).attr("value")) || // No 0 first digit from number section
      isControlKey) { // Opera assigns values for control keys.
    return;
  } else {
    event.preventDefault();
  }
});

   window.jQuery.fn.ForceNumericOnly =
       function () {

           return this.each(function () {
               $(this).keydown(function (event) {
                   // Allow: backspace, delete, tab, escape, and enter
                   if (event.keyCode == 46 || event.keyCode == 8 || event.keyCode == 9 || event.keyCode == 27 || event.keyCode == 13 ||
                       // Allow: Ctrl+A
                       (event.keyCode == 65 && event.ctrlKey === true) ||
                       // Allow: home, end, left, right
                       (event.keyCode >= 35 && event.keyCode <= 39)) {
                       // let it happen, don't do anything
                       return;
                   } else {
                       // Ensure that it is a number and stop the keypress
                       if (event.shiftKey || (event.keyCode < 48 || event.keyCode > 57) && (event.keyCode < 96 || event.keyCode > 105)) {
                           event.preventDefault();
                       }
                   }
               });
           });
       };

I zastosuj to do wszystkich wymaganych danych wejściowych:

$('selector').ForceNumericOnly();

HTML5 obsługuje liczbę typów danych wejściowych z obsługą globalnej przeglądarki 88% + zgodnie z CanIUse z października 2015 r.

<input type="number" step="0.01" min="0" name="askedPrice" id="askedPrice" />

Nie jest to rozwiązanie związane z JQuery, ale zaletą jest to, że w telefonach komórkowych klawiatura Android zostanie zoptymalizowana do wprowadzania liczb.

Alternatywnie można użyć tekstu typu wejściowego z nowym parametrem „wzorzec”. Więcej szczegółów w specyfikacji HTML5.

Myślę, że jest to lepsze niż rozwiązanie jquery, ponieważ w tym pytaniu dostarczone rozwiązanie jquery nie obsługuje separatora tysięcy. Jeśli możesz użyć HTML5.

JSFiddle: https://jsfiddle.net/p1ue8qxj/

Ta funkcja robi to samo, wykorzystuje niektóre z powyższych pomysłów.

$field.keyup(function(){
    var val = $j(this).val();
    if(isNaN(val)){
         val = val.replace(/[^0-9\.]/g,'');
         if(val.split('.').length>2) val =val.replace(/\.+$/,"");
    }
    $j(this).val(val); 
});

• pokaż wizualną informację zwrotną (przed zniknięciem pojawia się niepoprawna litera)
• pozwala na dziesiętne
• łapie wiele „.”
• nie ma problemów z lewym / prawym del itd.

/ * to moja wersja przeglądarki dla wielu przeglądarek Jak zezwalać tylko na wartości liczbowe (0-9) w polu wejściowym HTML za pomocą jQuery?
* /

$("#inputPrice").keydown(function(e){
    var keyPressed;
    if (!e) var e = window.event;
    if (e.keyCode) keyPressed = e.keyCode;
    else if (e.which) keyPressed = e.which;
    var hasDecimalPoint = (($(this).val().split('.').length-1)>0);
    if ( keyPressed == 46 || keyPressed == 8 ||((keyPressed == 190||keyPressed == 110)&&(!hasDecimalPoint && !e.shiftKey)) || keyPressed == 9 || keyPressed == 27 || keyPressed == 13 ||
             // Allow: Ctrl+A
            (keyPressed == 65 && e.ctrlKey === true) ||
             // Allow: home, end, left, right
            (keyPressed >= 35 && keyPressed <= 39)) {
                 // let it happen, don't do anything
                 return;
        }
        else {
            // Ensure that it is a number and stop the keypress
            if (e.shiftKey || (keyPressed < 48 || keyPressed > 57) && (keyPressed < 96 || keyPressed > 105 )) {
                e.preventDefault();
            }
        }

  });

Wystarczy uruchomić zawartość za pomocą parseFloat (). Wróci NaNpo niepoprawnym wejściu.

Możesz użyć autoNumeric z decorplanit.com . Mają ładne wsparcie dla liczb, a także waluty, zaokrąglania itp.

Użyłem w środowisku IE6, z kilkoma poprawkami css, i to był rozsądny sukces.

Na przykład numericInputmożna zdefiniować klasę css , która mogłaby zostać użyta do dekoracji pól za pomocą liczbowych masek wprowadzania.

zaadaptowane ze strony autoNumeric:

$('input.numericInput').autoNumeric({aSep: '.', aDec: ','}); // very flexible!

Myślę, że to dobry sposób na rozwiązanie tego problemu i jest niezwykle prosty:

$(function() {
    var pastValue, pastSelectionStart, pastSelectionEnd;

    $("input").on("keydown", function() {
        pastValue          = this.value;
        pastSelectionStart = this.selectionStart;
        pastSelectionEnd   = this.selectionEnd;
    }).on("input propertychange", function() {
        var regex = /^[0-9]+\.?[0-9]*$/;

        if (this.value.length > 0 && !regex.test(this.value)) {
            this.value          = pastValue;
            this.selectionStart = pastSelectionStart;
            this.selectionEnd   = pastSelectionEnd;
        }
    });
});

Przykład: JSFiddle

Omówione scenariusze

Większość podobnych zaleceń zawodzi co najmniej jeden z nich lub wymaga dużo kodu, aby uwzględnić wszystkie te scenariusze.

1. Umożliwia tylko 1 przecinek dziesiętny.
2. Zezwala home, endi arrowklucze.
3. Pozwala deletei backspacemoże być używany przy dowolnym indeksie.
4. Umożliwia edycję pod dowolnym indeksem (o ile dane wejściowe są zgodne z wyrażeniem regularnym).
5. Pozwala ctrl + v i shift + wstawić dla poprawnego wprowadzania (to samo z kliknięciem prawym przyciskiem myszy + wklej).
6. Nie migocze wartości tekstowej, ponieważ keyup zdarzenie nie jest używane.
7. Przywraca wybór po nieprawidłowym wprowadzeniu.

Scenariusze nie powiodły się

• Rozpoczynanie od 0.5i usuwanie tylko zera nie będzie działać. Można to naprawić, zmieniając wyrażenie regularne na, /^[0-9]*\.?[0-9]*$/a następnie dodając zdarzenie rozmycia, aby dodać, 0gdy pole tekstowe zaczyna się od kropki dziesiętnej (w razie potrzeby). Zobacz ten zaawansowany scenariusz, aby uzyskać lepszy pomysł na rozwiązanie tego problemu.

Podłącz

Stworzyłem tę prostą wtyczkę jquery, aby ułatwić to:

$("input").limitRegex(/^[0-9]+\.?[0-9]*$/);

Najlepszym sposobem jest sprawdzenie wpływu pola tekstowego, gdy traci ono ostrość.

Możesz sprawdzić, czy zawartość jest „liczbą”, używając wyrażenia regularnego.

Lub możesz użyć wtyczki Validation, która w zasadzie robi to automatycznie.

Sprawdź ten kod znalezienia do korzystania z bazy danych:

function numonly(root){
    >>var reet = root.value;
    var arr1 = reet.length;
    var ruut = reet.charAt(arr1-1);
    >>>if (reet.length > 0){
        var regex = /[0-9]|\./;
        if (!ruut.match(regex)){
            var reet = reet.slice(0, -1);
            $(root).val(reet);
        >>>>}
    }
}
//Then use the even handler onkeyup='numonly(this)'

To jest właśnie fragment kodu, który właśnie wykonałem (używając części kodu autorstwa Peter Mortensen / Keith Bentrup) w celu sprawdzenia całkowitej liczby procentowej w polu tekstowym (wymagane jest jQuery):

/* This validates that the value of the text box corresponds
 * to a percentage expressed as an integer between 1 and 100,
 * otherwise adjust the text box value for this condition is met. */
$("[id*='percent_textfield']").keyup(function(e){
    if (!isNaN(parseInt(this.value,10))) {
        this.value = parseInt(this.value);
    } else {
        this.value = 0;
    }
    this.value = this.value.replace(/[^0-9]/g, '');
    if (parseInt(this.value,10) > 100) {
        this.value = 100;
        return;
    }
});

Ten kod:

• Umożliwia korzystanie z głównych klawiszy numerycznych i klawiatury numerycznej.
• Sprawdza poprawność, aby wykluczyć znaki Shift-numeryczne (np. #, $,% Itp.)
• Zamienia wartości NaN na 0
• Zastępuje 100 wartości wyższych niż 100

Mam nadzieję, że to pomaga potrzebującym.

Znalazłem świetne rozwiązanie tutaj http://ajax911.com/numbers-numeric-field-jquery/

Właśnie zmieniłem „keyup” na „keydown” zgodnie z moimi wymaganiami

Jeśli używasz HTML5, nie musisz dokładać żadnych starań, aby przeprowadzić weryfikację. Po prostu użyj -

<input type="number" step="any" />

Atrybut kroku pozwala na poprawność kropki dziesiętnej.

Inny sposób na zachowanie pozycji karetki na wejściu:

$(document).ready(function() {
  $('.numbersOnly').on('input', function() {
    var position = this.selectionStart - 1;

    fixed = this.value.replace(/[^0-9\.]/g, '');  //remove all but number and .
    if(fixed.charAt(0) === '.')                  //can't start with .
      fixed = fixed.slice(1);

    var pos = fixed.indexOf(".") + 1;
    if(pos >= 0)
      fixed = fixed.substr(0,pos) + fixed.slice(pos).replace('.', '');  //avoid more than one .

    if (this.value !== fixed) {
      this.value = fixed;
      this.selectionStart = position;
      this.selectionEnd = position;
    }
  });
});

Zalety:

1. Użytkownik może używać klawiszy strzałek, Backspace, Delete, ...
2. Działa, gdy chcesz wkleić liczby

Plunker: Demo działa

Właśnie znalazłem jeszcze lepszą wtyczkę. Daje ci znacznie większą kontrolę. Powiedz, że masz DOB pole którym potrzebujesz, aby było liczbowe, ale akceptuje także znaki „/” lub „-”.

Działa świetnie!

Sprawdź to na http://itgroup.com.ph/alphanumeric/ .

    $(".numeric").keypress(function(event) {
  // Backspace, tab, enter, end, home, left, right
  // We don't support the del key in Opera because del == . == 46.
  var controlKeys = [8, 9, 13, 35, 36, 37, 39];
  // IE doesn't support indexOf
  var isControlKey = controlKeys.join(",").match(new RegExp(event.which));
  // Some browsers just don't raise events for control keys. Easy.
  // e.g. Safari backspace.
  if (!event.which || // Control keys in most browsers. e.g. Firefox tab is 0
      (49 <= event.which && event.which <= 57) || // Always 1 through 9
      (48 == event.which && $(this).attr("value")) || // No 0 first digit
      isControlKey) { // Opera assigns values for control keys.
    return;
  } else {
    event.preventDefault();
  }
});

Ten kod działał na mnie całkiem dobrze, po prostu musiałem dodać 46 w tablicy controlKeys, aby użyć kropki, choć nie uważam, że to najlepszy sposób, aby to zrobić;)

Użyłem tego, z dobrymi wynikami ..

ini=$("#id").val();
a=0;
$("#id").keyup(function(e){
    var charcode = (e.which) ? e.which : e.keyCode;
    // for decimal point
    if(!(charcode===190 || charcode===110))
    {           // for numeric keys andcontrol keys
        if (!((charcode>=33 && charcode<=57) || 
        // for numpad numeric keys
        (charcode>=96 && charcode<=105) 
        // for backspace
        || charcode==8)) 
        {
            alert("Sorry! Only numeric values allowed.");
            $("#id").val(ini);
        }
        // to include decimal point if first one has been deleted.
        if(charcode===8)
        {
            ini=ini.split("").reverse();
            if(ini[0]==".")
            a=0;                 
        }
    }
    else
    {
        if(a==1)
        {
            alert("Sorry! Second decimal point not allowed.");
            $("#id").val(ini);
        }
        a=1;
    }
    ini=$("#id").val();
});


find keycodes at http://www.cambiaresearch.com/articles/15/javascript-char-codes-key-codes

Jest to bardzo proste, że mamy już wbudowaną funkcję javascript „isNaN”.

$("#numeric").keydown(function(e){
  if (isNaN(String.fromCharCode(e.which))){ 
    return false; 
  }
});