मैं किसी इनपुट को केवल संख्या स्वीकार करने के लिए कैसे प्रतिबंधित करूं?

Question 1

मैं एक कस्टम फ़ंक्शन को ट्रिगर करने के लिए AngularJS में ngChange का उपयोग कर रहा हूं जो उपयोगकर्ता द्वारा इनपुट में जोड़े गए किसी भी पत्र को हटा देगा।

<input type="text" name="inputName" data-ng-change="numbersOnly()"/>

समस्या यह है कि मुझे उस इनपुट को लक्षित करने की आवश्यकता है जो ट्रिगर हो गया numbersOnly()ताकि मैं प्रवेश किए गए पत्रों को हटा सकूं। मैंने Google पर लंबी और कड़ी मेहनत की है और इस बारे में कुछ भी पता नहीं लगा पाया है।

मैं क्या कर सकता हूँ?

Question 2

अगर यह आपके उपयोग के मामले में काम करता है तो आसान तरीका , टाइप = "नंबर" का उपयोग करें:

<input type="number" ng-model="myText" name="inputName">

एक और आसान तरीका: एनजी-पैटर्न का उपयोग एक रेगेक्स को परिभाषित करने के लिए भी किया जा सकता है जो कि क्षेत्र में अनुमति दी गई सीमा को सीमित करेगा। रूपों के बारे में "रसोई की किताब" पृष्ठ भी देखें ।

Hackish? रास्ता , $ अपने नियंत्रक में एनजी-मॉडल देखें:

<input type="text"  ng-model="myText" name="inputName">

नियंत्रक:

$scope.$watch('myText', function() {
   // put numbersOnly() logic here, e.g.:
   if ($scope.myText  ... regex to look for ... ) {
      // strip out the non-numbers
   }
})

सबसे अच्छा तरीका है , एक निर्देश में $ parser का उपयोग करें। मैं @ pkozlowski.opensource द्वारा पहले से उपलब्ध कराए गए अच्छे उत्तर को दोहराने नहीं जा रहा हूं, इसलिए यहां लिंक है: https://stackoverflow.com/a/14425022/215945

उपरोक्त सभी समाधानों में एनजी-मॉडल का उपयोग करना शामिल है, जो thisअनावश्यक खोज करता है ।

एनजी-परिवर्तन का उपयोग करने से समस्याएं पैदा होंगी। देखें AngularJS - $ गुंजाइश का रीसेट ।value टेम्पलेट में मूल्य नहीं बदलता है (यादृच्छिक व्यवहार)

Question 3

ng-patternपाठ फ़ील्ड पर उपयोग करना :

<input type="text"  ng-model="myText" name="inputName" ng-pattern="onlyNumbers">

फिर इसे अपने कंट्रोलर पर शामिल करें

$scope.onlyNumbers = /^\d+$/;

Question 4

प्रस्तावित समाधानों में से किसी ने भी मेरे लिए ठीक काम नहीं किया, और कुछ घंटों के बाद मुझे अंततः रास्ता मिल गया।

यह कोणीय निर्देश है:

angular.module('app').directive('restrictTo', function() {
    return {
        restrict: 'A',
        link: function (scope, element, attrs) {
            var re = RegExp(attrs.restrictTo);
            var exclude = /Backspace|Enter|Tab|Delete|Del|ArrowUp|Up|ArrowDown|Down|ArrowLeft|Left|ArrowRight|Right/;

            element[0].addEventListener('keydown', function(event) {
                if (!exclude.test(event.key) && !re.test(event.key)) {
                    event.preventDefault();
                }
            });
        }
    }
});

और इनपुट जैसा दिखेगा:

<input type="number" min="0" name="inputName" ng-model="myModel" restrict-to="[0-9]">

नियमित अभिव्यक्ति दबाए गए कुंजी का मूल्यांकन करती है, न कि मूल्य की ।

यह इनपुट के साथ भी पूरी तरह से काम करता है type="number"क्योंकि इसके मूल्य को बदलने से रोकता है, इसलिए कुंजी को कभी भी प्रदर्शित नहीं किया जाता है और यह मॉडल के साथ गड़बड़ नहीं करता है।

Question 5

यहाँ मेरा $parserसमाधान है कि @Mark Rajcok सबसे अच्छी विधि के रूप में सिफारिश करता है। यह अनिवार्य रूप से @ pkozlowski.opensource का उत्कृष्ट टेक्स्ट उत्तर के लिए $ पार्सर है, लेकिन केवल अंकगणित की अनुमति देने के लिए फिर से लिखा गया है। सारा श्रेय उसे जाता है, यह सिर्फ आपको उस उत्तर को पढ़ने के 5 मिनट बचाने के लिए है और फिर अपने खुद के बारे में लिखना है:

app.directive('numericOnly', function(){
    return {
        require: 'ngModel',
        link: function(scope, element, attrs, modelCtrl) {

            modelCtrl.$parsers.push(function (inputValue) {
                var transformedInput = inputValue ? inputValue.replace(/[^\d.-]/g,'') : null;

                if (transformedInput!=inputValue) {
                    modelCtrl.$setViewValue(transformedInput);
                    modelCtrl.$render();
                }

                return transformedInput;
            });
        }
    };
});

और आप इसे इस तरह उपयोग करेंगे:

<input type="text" name="number" ng-model="num_things" numeric-only>

दिलचस्प है, रिक्त स्थान कभी भी पार्सर तक नहीं पहुंचते हैं जब तक कि एक अल्फ़ान्यूमेरिक से घिरा नहीं होता है, इसलिए आपको .trim()आवश्यकतानुसार होना चाहिए। इसके अलावा, यह पार्सर काम नहीं करता है <input type="number">। किसी कारण से, गैर numerics यह कभी नहीं पार्सर जहां से उन्हें हटाया जा चाहते हैं उनके हैं, लेकिन वे कर इनपुट नियंत्रण ही में आने से पहले।

Question 6

ऐसा करने के कुछ तरीके हैं।

आप उपयोग कर सकते हैं type="number":

<input type="number" />

वैकल्पिक रूप से - मैंने इसके लिए एक पुन: प्रयोज्य निर्देश बनाया जो एक नियमित अभिव्यक्ति का उपयोग करता है।

एचटीएमएल

<div ng-app="myawesomeapp">
    test: <input restrict-input="^[0-9-]*$" maxlength="20" type="text" class="test" />
</div>

जावास्क्रिप्ट

;(function(){
    var app = angular.module('myawesomeapp',[])
    .directive('restrictInput', [function(){

        return {
            restrict: 'A',
            link: function (scope, element, attrs) {
                var ele = element[0];
                var regex = RegExp(attrs.restrictInput);
                var value = ele.value;

                ele.addEventListener('keyup',function(e){
                    if (regex.test(ele.value)){
                        value = ele.value;
                    }else{
                        ele.value = value;
                    }
                });
            }
        };
    }]);    
}());

Question 7

यहाँ केवल नंबर दर्ज करने की अनुमति देने के लिए एक बहुत अच्छा समाधान है input:

<input type="text" ng-model="myText" name="inputName" onkeypress='return event.charCode >= 48 && event.charCode <= 57'/>

Question 8

उपरोक्त सभी समाधान काफी बड़े हैं, मैं इस पर अपने 2 सेंट देना चाहता था।

मैं केवल जाँच कर रहा हूँ कि इनपुट किया गया मान एक संख्या है या नहीं, और जाँच रहा है कि क्या यह रिक्त नहीं है, बस।

यहाँ HTML है:

<input type="text" ng-keypress="CheckNumber()"/>

यहाँ जेएस है:

$scope.CheckKey = function () {
    if (isNaN(event.key) || event.key === ' ' || event.key === '') {
        event.returnValue = '';
    }
};

यह काफी सरल है।

मुझे लगता है कि यह ज्ञात है, पेस्ट थू पर इस अभ्यस्त काम को हासिल नहीं है।

पेस्ट के लिए, मुझे लगता है कि आपको ऑन-क्रॉक इवेंट का उपयोग करने और पूरे स्ट्रिंग को पार्स करने की आवश्यकता होगी, जो एक और जानवर है। यह टाइपिंग के लिए विशिष्ट है।

चिपकाएँ के लिए अद्यतन : बस इस जेएस समारोह जोड़ें:

$scope.CheckPaste = function () {
    var paste = event.clipboardData.getData('text');

    if (isNaN(paste)) {
        event.preventDefault();
        return false;
    }
};

और HTML इनपुट ट्रिगर जोड़ें:

<input type="text" ng-paste="CheckPaste()"/>

मुझे आशा है कि यह ओ / में मदद करता है

Question 9

यहाँ एक प्लंकर किसी भी स्थिति को संभालता है जो प्रस्ताव से ऊपर नहीं है।
$ फॉर्मेटर्स और $ पार्सर्स पाइपलाइन का उपयोग करके और टाइप = "नंबर" से बचना

और यहाँ समस्याओं / समाधानों की व्याख्या है (प्लंकर में भी उपलब्ध):

/*
 *
 * Limit input text for floating numbers.
 * It does not display characters and can limit the Float value to X numbers of integers and X numbers of decimals.
 * min and max attributes can be added. They can be Integers as well as Floating values.
 *
 * value needed    |    directive
 * ------------------------------------
 * 55              |    max-integer="2"
 * 55.55           |    max-integer="4" decimal="2" (decimals are substracted from total length. Same logic as database NUMBER type)
 *
 *
 * Input type="number" (HTML5)
 *
 * Browser compatibility for input type="number" :
 * Chrome : - if first letter is a String : allows everything
 *          - if first letter is a Integer : allows [0-9] and "." and "e" (exponential)
 * Firefox : allows everything
 * Internet Explorer : allows everything
 *
 * Why you should not use input type="number" :
 * When using input type="number" the $parser pipeline of ngModel controller won't be able to access NaN values.
 * For example : viewValue = '1e'  -> $parsers parameter value = "".
 * This is because undefined values are not allowes by default (which can be changed, but better not do it)
 * This makes it impossible to modify the view and model value; to get the view value, pop last character, apply to the view and return to the model.
 *
 * About the ngModel controller pipelines :
 * view value -> $parsers -> model value
 * model value -> $formatters -> view value
 *
 * About the $parsers pipeline :
 * It is an array of functions executed in ascending order.
 * When used with input type="number" :
 * This array has 2 default functions, one of them transforms the datatype of the value from String to Number.
 * To be able to change the value easier (substring), it is better to have access to a String rather than a Number.
 * To access a String, the custom function added to the $parsers pipeline should be unshifted rather than pushed.
 * Unshift gives the closest access to the view.
 *
 * About the $formatters pipeline :
 * It is executed in descending order
 * When used with input type="number"
 * Default function transforms the value datatype from Number to String.
 * To access a String, push to this pipeline. (push brings the function closest to the view value)
 *
 * The flow :
 * When changing ngModel where the directive stands : (In this case only the view has to be changed. $parsers returns the changed model)
 *     -When the value do not has to be modified :
 *     $parsers -> $render();
 *     -When the value has to be modified :
 *     $parsers(view value) --(does view needs to be changed?) -> $render();
 *       |                                  |
 *       |                     $setViewValue(changedViewValue)
 *       |                                  |
 *       --<-------<---------<--------<------
 *
 * When changing ngModel where the directive does not stand :
 *     - When the value does not has to be modified :
 *       -$formatters(model value)-->-- view value
 *     -When the value has to be changed
 *       -$formatters(model vale)-->--(does the value has to be modified) -- (when loop $parsers loop is finished, return modified value)-->view value
 *                                              |
 *                                  $setViewValue(notChangedValue) giving back the non changed value allows the $parsers handle the 'bad' value
 *                                               |                  and avoids it to think the value did not changed
 *                Changed the model <----(the above $parsers loop occurs)
 *
 */

Question 10

   <input type="text" name="profileChildCount" id="profileChildCount" ng-model="profile.ChildCount" numeric-only maxlength="1" />

आप केवल संख्यात्मक विशेषता का उपयोग कर सकते हैं।

Question 11

दशमलव

directive('decimal', function() {
                return {
                    require: 'ngModel',
                    restrict: 'A',
                    link: function(scope, element, attr, ctrl) {
                        function inputValue(val) {
                            if (val) {
                                var digits = val.replace(/[^0-9.]/g, '');

                                if (digits.split('.').length > 2) {
                                    digits = digits.substring(0, digits.length - 1);
                                }

                                if (digits !== val) {
                                    ctrl.$setViewValue(digits);
                                    ctrl.$render();
                                }
                                return parseFloat(digits);
                            }
                            return "";
                        }
                        ctrl.$parsers.push(inputValue);
                    }
                };
            });

अंक

directive('entero', function() {
            return {
                require: 'ngModel',
                restrict: 'A',
                link: function(scope, element, attr, ctrl) {
                    function inputValue(val) {
                        if (val) {
                            var value = val + ''; //convert to string
                            var digits = value.replace(/[^0-9]/g, '');

                            if (digits !== value) {
                                ctrl.$setViewValue(digits);
                                ctrl.$render();
                            }
                            return parseInt(digits);
                        }
                        return "";
                    }
                    ctrl.$parsers.push(inputValue);
                }
            };
        });

मान्य संख्याओं के लिए कोणीय निर्देश

Question 12

मुझे पता है कि यह पुराना है, लेकिन मैंने इस उद्देश्य के लिए एक निर्देश बनाया है कि कोई भी एक आसान समाधान की तलाश में है। उपयोग करने के लिए बहुत सरल है।

आप इसे यहां देख सकते हैं ।

Question 13

आप इनपुट की शुरुआत में 0 को भी हटाना चाह सकते हैं ... मैं ऊपर दिए गए Mordred उत्तर में एक if ब्लॉक जोड़ता हूं क्योंकि मैं अभी तक एक टिप्पणी नहीं कर सकता ...

  app.directive('numericOnly', function() {
    return {
      require: 'ngModel',
      link: function(scope, element, attrs, modelCtrl) {

          modelCtrl.$parsers.push(function (inputValue) {
              var transformedInput = inputValue ? inputValue.replace(/[^\d.-]/g,'') : null;

              if (transformedInput!=inputValue) {
                  modelCtrl.$setViewValue(transformedInput);
                  modelCtrl.$render();
              }
              //clear beginning 0
              if(transformedInput == 0){
                modelCtrl.$setViewValue(null);
                modelCtrl.$render();
              }
              return transformedInput;
          });
      }
    };
  })

Question 14

इसे इस्तेमाल करे,

<input ng-keypress="validation($event)">

 function validation(event) {
    var theEvent = event || window.event;
    var key = theEvent.keyCode || theEvent.which;
    key = String.fromCharCode(key);
    var regex = /[0-9]|\./;
    if (!regex.test(key)) {
        theEvent.returnValue = false;
        if (theEvent.preventDefault) theEvent.preventDefault();
    }

}

Question 15

समाधान: मैं एप्लिकेशन में सभी इनपुट, संख्या, पाठ या किसी भी के लिए एक निर्देश बनाता हूं, ताकि आप एक मूल्य इनपुट कर सकें और घटना को बदल सकें। कोणीय 6 के लिए बनाओ

 import { Directive, ElementRef, HostListener, Input } from '@angular/core';

 @Directive({
// tslint:disable-next-line:directive-selector
selector: 'input[inputType]'
})
  export class InputTypeDirective {
 constructor(private _el: ElementRef) {}

 @Input() inputType: string;
 // tipos: number, letter, cuit, tel

@HostListener('input', ['$event']) onInputChange(event) {
if (!event.data) {
  return;
}

switch (this.inputType) {
  case 'number': {
    const initalValue = this._el.nativeElement.value;
    this._el.nativeElement.value = initalValue.replace(/[^0-9]*/g, '');
    if (initalValue !== this._el.nativeElement.value) {
      event.stopPropagation();
    }
     break;
          }
       case 'text': {
        const result = event.data.match(/[^a-zA-Z Ññ]*/g);
        if (result[0] !== '') {
           const initalValue = this._el.nativeElement.value;
           this._el.nativeElement.value = initalValue.replace(
          /[^a-zA-Z Ññ]*/g,
           ''
         );
           event.stopPropagation();
        }
        break;
    }
        case 'tel':
          case 'cuit': {
         const initalValue = this._el.nativeElement.value;
      this._el.nativeElement.value = initalValue.replace(/[^0-9-]*/g, '');
       if (initalValue !== this._el.nativeElement.value) {
         event.stopPropagation();
       }
     }
   }
  }
   }

एचटीएमएल

     <input matInput inputType="number" [formControlName]="field.name" [maxlength]="field.length" [placeholder]="field.label | translate"  type="text" class="filter-input">

Question 16

मैंने इनपुट स्वीकार करने और मक्खी पर प्रारूप बदलने के लिए उपरोक्त कोड के एक संशोधित निर्देश का निर्माण किया ...

.directive('numericOnly', function($filter) {
  return {
      require: 'ngModel',
      link: function(scope, element, attrs, modelCtrl) {

           element.bind('keyup', function (inputValue, e) {
             var strinput = modelCtrl.$$rawModelValue;
             //filter user input
             var transformedInput = strinput ? strinput.replace(/[^,\d.-]/g,'') : null;
             //remove trailing 0
             if(transformedInput.charAt(0) <= '0'){
               transformedInput = null;
               modelCtrl.$setViewValue(transformedInput);
               modelCtrl.$render();
             }else{
               var decimalSplit = transformedInput.split(".")
               var intPart = decimalSplit[0];
               var decPart = decimalSplit[1];
               //remove previously formated number
               intPart = intPart.replace(/,/g, "");
               //split whole number into array of 3 digits
               if(intPart.length > 3){
                 var intDiv = Math.floor(intPart.length / 3);
                 var strfraction = [];
                 var i = intDiv,
                     j = 3;

                 while(intDiv > 0){
                   strfraction[intDiv] = intPart.slice(intPart.length-j,intPart.length - (j - 3));
                   j=j+3;
                   intDiv--;
                 }
                 var k = j-3;
                 if((intPart.length-k) > 0){
                   strfraction[0] = intPart.slice(0,intPart.length-k);
                 }
               }
               //join arrays
               if(strfraction == undefined){ return;}
                 var currencyformat = strfraction.join(',');
                 //check for leading comma
                 if(currencyformat.charAt(0)==','){
                   currencyformat = currencyformat.slice(1);
                 }

                 if(decPart ==  undefined){
                   modelCtrl.$setViewValue(currencyformat);
                   modelCtrl.$render();
                   return;
                 }else{
                   currencyformat = currencyformat + "." + decPart.slice(0,2);
                   modelCtrl.$setViewValue(currencyformat);
                   modelCtrl.$render();
                 }
             }
            });
      }
  };

})

Question 17

<input type="text" ng-model="employee.age" valid-input input-pattern="[^0-9]+" placeholder="Enter an age" />

<script>
var app = angular.module('app', []);

app.controller('dataCtrl', function($scope) {
});

app.directive('validInput', function() {
  return {
    require: '?ngModel',
    scope: {
      "inputPattern": '@'
    },
    link: function(scope, element, attrs, ngModelCtrl) {

      var regexp = null;

      if (scope.inputPattern !== undefined) {
        regexp = new RegExp(scope.inputPattern, "g");
      }

      if(!ngModelCtrl) {
        return;
      }

      ngModelCtrl.$parsers.push(function(val) {
        if (regexp) {
          var clean = val.replace(regexp, '');
          if (val !== clean) {
            ngModelCtrl.$setViewValue(clean);
            ngModelCtrl.$render();
          }
          return clean;
        }
        else {
          return val;
        }

      });

      element.bind('keypress', function(event) {
        if(event.keyCode === 32) {
          event.preventDefault();
        }
      });
    }
}}); </script>

Question 18

मूल HTML

<input type="number" />

मूल बूटस्ट्रैप

<input class="form-control" type="number" value="42" id="my-id">