min/max validations ne fonctionne pas si les valeurs sont modifiées plus tard

j'ai exigence d'où min valeur d'un champ dépend de l'entrée dans un autre domaine.

<input type="number" name="minval" class="form-control" ng-model="user.minval" 
      ng-required="true">

cette entrée est utilisée pour valider un autre champ

<input type="number" name="inputval" class="form-control" ng-model="user.inputval" 
     ng-required="true" min="{{user.minval}}">

mais cela ne fonctionne pas comme prévu.. si je change le "minval" plus tard, l'entrée n'obtient pas validé..

j'ai essayé le réglage de la valeur initiale pour min JS comme il était suggéré dans une solution mais c'est aussi de ne pas aider...

PLUNKER LIEN

Que voulez-vous arriver si l'original min de la valeur de la première entrée devient inférieure à la seconde valeur d'entrée?
Avec beaucoup de recherches sur google, j'ai trouvé très utile, DONC le post: stackoverflow.com/questions/15656617/...
merci beaucoup pour cette @ForgetfulFellow
je pense que je n'ai pas besoin de répondre à votre premier commentaire.. le lien est la réponse au problème que j'ai été confronté..

OriginalL'auteur harishr | 2014-07-18

  1. 8

    utilisation ng min/ng-max directives

    app.directive('ngMin', function() {
return {
restrict: 'A',
require: 'ngModel',
link: function(scope, elem, attr, ctrl) {
scope.$watch(attr.ngMin, function(){
if (ctrl.$isDirty) ctrl.$setViewValue(ctrl.$viewValue);
});
var isEmpty = function (value) {
return angular.isUndefined(value) || value === "" || value === null;
}
var minValidator = function(value) {
var min = scope.$eval(attr.ngMin) || 0;
if (!isEmpty(value) && value < min) {
ctrl.$setValidity('ngMin', false);
return undefined;
} else {
ctrl.$setValidity('ngMin', true);
return value;
}
};
ctrl.$parsers.push(minValidator);
ctrl.$formatters.push(minValidator);
}
};
});
app.directive('ngMax', function() {
return {
restrict: 'A',
require: 'ngModel',
link: function(scope, elem, attr, ctrl) {
scope.$watch(attr.ngMax, function(){
if (ctrl.$isDirty) ctrl.$setViewValue(ctrl.$viewValue);
});
var maxValidator = function(value) {
var max = scope.$eval(attr.ngMax) || Infinity;
if (!isEmpty(value) && value > max) {
ctrl.$setValidity('ngMax', false);
return undefined;
} else {
ctrl.$setValidity('ngMax', true);
return value;
}
};
ctrl.$parsers.push(maxValidator);
ctrl.$formatters.push(maxValidator);
}
};
});
    Merci à tous ceux de l'excellent travail. Juste un plus, si vous utilisez les attributs en combinaison avec ces directives, le champ est marqué comme non valide tout de suite, ce qui n'est pas très convivial. Vous pouvez résoudre ce problème en vérifiant si le champ est sale dans la montre if(ctrl.$isDirty) ... et de ne faire que de la setViewValue ensuite.
    en fait je l'avais fait dans le code, j'ai oublié de mettre à jour la réponse. merci pour l'entrée, de toute façon.
    Sérieusement?, vous souhaitez utiliser la montre pour qui?... angular-tips.com/blog/2013/08/removing-the-unneeded-watches
    hey, isEmpty() n'est pas défini
    Cette solution est d'abord apparu ici: stackoverflow.com/questions/15656617/... Notez que ng-min et ng-max sont désormais pris en charge par Angulaire sans le besoin d'écrire vos propres directives.

    OriginalL'auteur

  2. 2

    J'ai développé un couple de directives qui en fait empêcher l'utilisateur de fixer une valeur non valide au lieu de tout simplement jeter une erreur lorsqu'une valeur non valide est fourni.

    Ces directives ne nécessitent pas de ngModel (bien que je doute que vous l'utiliser sans l') et ce qui est vraiment cool, c'est que il va placer la valeur autour du min/max si les deux paramètres sont fournis!

    J'ai essayé de simplifier les directives autant que possible pour le rendre facile pour nos lecteurs.

    Ici est un JSFiddle de toute la chose: JSFiddle

    Et voici les directives:

    app.directive('ngMin', function($parse){
return {
restrict: 'A',
link: function(scope, element, attrs){
function validate(){
if(element
&& element[0]
&& element[0].localName === 'input'
&& isNumber(attrs.ngMin)
&& isNumber(element[0].value)
&& parseFloat(element[0].value) < parseFloat(attrs.ngMin)){
if(isNumber(attrs.ngMax)){
element[0].value = parseFloat(attrs.ngMax);
if(attrs.hasOwnProperty("ngModel"))
$parse(attrs.ngModel).assign(scope, parseFloat(attrs.ngMax));
}
else {
element[0].value = parseFloat(attrs.ngMin);
if(attrs.hasOwnProperty("ngModel"))
$parse(attrs.ngModel).assign(scope, parseFloat(attrs.ngMin));
}
}
}
scope.$watch(function(){
return attrs.ngMin + "-" + element[0].value;
}, function(newVal, oldVal){
if(newVal != oldVal)
validate();
});
validate();
}
};
});
app.directive('ngMax', function($parse){
return {
restrict: 'A',
link: function(scope, element, attrs){
function validate(){
if(element
&& element[0]
&& element[0].localName === 'input'
&& isNumber(attrs.ngMax)
&& isNumber(element[0].value)
&& parseFloat(element[0].value) > parseFloat(attrs.ngMax)){
if(isNumber(attrs.ngMin)){
element[0].value = parseFloat(attrs.ngMin);
if(attrs.hasOwnProperty("ngModel"))
$parse(attrs.ngModel).assign(scope, parseFloat(attrs.ngMin));
}
else {
element[0].value = parseFloat(attrs.ngMax);
if(attrs.hasOwnProperty("ngModel"))
$parse(attrs.ngModel).assign(scope, parseFloat(attrs.ngMax));
}
}
}
scope.$watch(function(){
return attrs.ngMax + "-" + element[0].value;
}, function(newVal, oldVal){
if(newVal != oldVal)
validate();
});
validate();
}
};
});

    ...aussi, vous aurez besoin de cette petite aide de la fonction ainsi:

    function isNumber(n){
return !isNaN(parseFloat(n)) && isFinite(n);
}

    D'invoquer ces directives, juste les mettre sur une zone de saisie où type="number":

    <input ng-model="myModel" ng-min="0" ng-max="1024" />

    Et qui devrait le faire!

    Lorsque vous fournir à la fois un ngMin et ngMax, ces directive placer la valeur autour, de sorte que lorsque votre valeur devient inférieure à ngMin, il sera fixé à ngMax, et vice-versa.

    Si vous ne fournissez ngMin ou ngMax, la valeur d'entrée sera simplement plafonné à ces valeurs.

    Je préfère cette méthode de prévention des mauvais valeurs plutôt que d'informer les utilisateurs qu'ils sont entrés dans une mauvaise valeur.

    OriginalL'auteur WebWanderer