Outils de validation

Un programme de validation est une fonction qui saisit une nouvelle valeur dans les champs Elles permettent de personnaliser facilement un champ. Elles permettent de déclencher lorsque la valeur d'un champ change, modifie l'entrée ou limite les valeurs sont acceptables.

Voici quelques exemples courants :

• Restreindre un champ de texte de sorte qu'il n'accepte que les lettres.
• Exiger qu'un champ de texte ne soit pas vide.
• Exiger que la date se situe dans le futur.
• Modifier la forme d'un volume à partir d'un menu déroulant.

Remarque :Les validateurs modifient l'adresse e-mail valeur et non son texte.

Types d'outils de validation

Les programmes de validation s'exécutent à des moments différents selon le type de programme de validation sont les mêmes.

Les outils de validation de classe font partie de la définition de classe d'un type de champ et sont généralement utilisé pour limiter le type de valeur autorisé par le champ (par exemple, nombre les champs n'acceptent que des caractères numériques). Les validateurs de classe sont exécutés sur toutes les valeurs. transmis au champ (y compris la valeur transmise au constructeur).

Pour en savoir plus sur les validateurs de classe, consultez les Implémenter un outil de validation de classe de la section Création d'un champ personnalisé.

Les outils de validation locaux sont définis au moment de la création d'un champ. Campagne locale les programmes de validation s'exécutent sur toutes les valeurs transmises au champ, à l'exception de la valeur transmise au constructeur. Cela signifie qu'elles s'exécutent sur:

• Valeurs contenues dans le fichier XML.
• Valeurs transmises à setValue.
• Valeurs transmises à setFieldValue.
• Valeurs modifiées par l'utilisateur.

Les programmes de validation de classe sont exécutés avant les validateurs locaux, car ils agissent comme les contrôleurs d’accès. Ils s'assurent que le type de la valeur est correct avant de transmettre l'activer.

Pour en savoir plus sur la séquence de validation des valeurs et sur les valeurs général, voir "Valeurs".

Enregistrer un validateur local

Vous pouvez enregistrer les validateurs locaux de deux manières:

• Ajouté directement dans le constructeur d'un champ.

Remarque: La signature du champ peut varier en fonction du type de champ.

Blockly.Blocks['validator_example'] = {
  init: function() {
    // Remove all 'a' characters from the text input's value.
    var validator = function(newValue) {
      return newValue.replace(/\a/g, '');
    };

    this.appendDummyInput()
        .appendField(new Blockly.FieldTextInput('default', validator));
  }
};

• Avec setValidator.

Blockly.Blocks['validator_example'] = {
  init: function() {
    // Remove all 'a' characters from the text input's value.
    var validator = function(newValue) {
      return newValue.replace(/\a/g, '');
    };

    var field = new Blockly.FieldTextInput('default');
    field.setValidator(validator);

    this.appendDummyInput().appendField(field);
  }
};

L'une ou l'autre des méthodes ci-dessus peut être encapsulée extension, pour être compatible avec le format JSON.

La valeur du champ peut être très différente en fonction du type de champ validé (par exemple, un champ numérique stocke un nombre, tandis qu'un champ de saisie de texte) stockera une chaîne). Nous vous conseillons donc de lire la documentation concernant votre avant de créer un programme de validation.

Remarque :Seuls les champs modifiables sont compatibles avec les validateurs. Veillez donc à vérifier les champs spécifiques dans la documentation du champ.

Valeurs renvoyées

La valeur renvoyée par le programme de validation détermine l'action suivante du champ. Il y trois possibilités s'offrent à vous:

Valeur renvoyée modifiée

Une valeur modifiée ou différente, qui devient alors la nouvelle valeur du champ. Cette opération est souvent utilisée pour nettoyer une valeur, par exemple en supprimant la fin d'espace.

Exemple d'outil de validation de modifications:

// Remove all 'a' characters from the text input's value.
var validator = function(newValue) {
  return newValue.replace(/\a/g, '');
};

Valeur renvoyée nulle

Null, ce qui signifie que la valeur donnée n'est pas valide. Dans la plupart des cas, le champ ignore la valeur d'entrée. Le comportement exact est spécifié par la méthode doValueInvalid_ fonction.

Exemple d'outil de validation de la valeur nulle:

// Any value containing a 'b' character is invalid.  Other values are valid.
var validator = function(newValue) {
  if (newValue.indexOf('b') != -1) {
    return null;
  }
  return newValue;
};

Valeur renvoyée non définie

Non définie (ou aucune instruction return) ou la valeur d'entrée, ce qui signifie que la valeur d'entrée doit devenir la nouvelle valeur du champ. Ces types d'outils de validation servent généralement d'écouteurs du changement.

Exemple de programme de validation des écouteurs:

// Log the new value to console.
var validator = function(newValue) {
  console.log(newValue);
};

Notez une fois de plus que le texte affiché ne reflète pas nécessairement valeur.

Valeur

Dans un outil de validation, this fait référence au champ, et non au bloc. Si vous avez besoin de accéder au bloc dans un programme de validation à l'aide de la fonction getSourceBlock. Vous pouvez utilisez également les Fonction bind pour définir le contexte dans lequel le programme de validation est appelé.

Exemple de code avec getSourceBlock:

Blockly.Blocks['colour_match'] = {
  init: function() {
    this.appendDummyInput()
        .appendField(new Blockly.FieldColour(
            null, this.validate
        ), 'COLOUR');
    this.setColour(this.getFieldValue('COLOUR'));
  },

  validate: function(colourHex) {
    this.getSourceBlock().setColour(colourHex);
  }
};

Exemple de code avec bind:

Blockly.Blocks['colour_match'] = {
  init: function() {
    this.appendDummyInput()
      .appendField(new Blockly.FieldColour(
          null, this.validate.bind(this)
      ), 'COLOUR');
    this.validate(this.getFieldValue('COLOUR'));
  },

  validate: function(colourHex) {
    this.setColour(colourHex);
  }
};