Validatoren

Eine Validierung ist eine Funktion, die den neuen Wert der Felder annimmt und dann entsprechend verarbeitet. Sie sind eine einfache Möglichkeit, ein Feld anzupassen. Mit ihnen können Sie Funktionen auslösen, wenn sich der Wert eines Felds ändert, die Eingabe ändern oder die zulässigen Werte einschränken.

Hier einige Beispiele:

• Textfelder auf Buchstaben beschränken
• Textfeld muss nicht leer sein.
• Datum, das in der Zukunft liegen muss
• Form eines Blocks basierend auf einem Drop-down-Menü ändern

Hinweis: Validatoren ändern den Wert eines Felds, nicht seinen Text.

Arten von Validatoren

Validatoren werden zu unterschiedlichen Zeiten ausgeführt, je nach Art der Validierung.

Klassenvalidierungen sind Teil der Klassendefinition eines Feldtyps und werden normalerweise verwendet, um den für das Feld zulässigen Typ des Werts einzuschränken (z.B. akzeptieren Zahlenfelder nur numerische Zeichen). Klassenvalidierungen werden für alle Werte ausgeführt, die an das Feld übergeben werden (einschließlich des Werts, der an den Konstruktor übergeben wird).

Weitere Informationen zur Klassenvalidierung finden Sie unter "Benutzerdefiniertes Feld erstellen" im Abschnitt Klassenvalidierung implementieren.

Lokale Validatoren werden beim Erstellen eines Felds definiert. Lokale Validierungen werden für alle Werte ausgeführt, die an das Feld übergeben werden, mit Ausnahme des an den Konstruktor übergebenen Werts. Das bedeutet, dass sie auf folgenden Plattformen ausgeführt werden:

• In XML enthaltene Werte
• An setValue übergebene Werte.
• An setFieldValue übergebene Werte.
• Vom Nutzer geänderte Werte

Klassenvalidierungen werden vor lokalen Validatoren ausgeführt, da sie wie Gatekeeper agieren. Sie prüfen, ob es sich bei dem Wert um den richtigen Typ handelt, bevor er übergeben wird.

Weitere Informationen zur Reihenfolge der Wertvalidierung und zu Werten im Allgemeinen finden Sie unter Werte.

Lokalen Validator registrieren

Lokale Validatoren können auf zwei Arten registriert werden:

• Wird direkt im Konstruktor eines Felds hinzugefügt.

Hinweis :Die Signatur des Feldkonstruktors kann je nach Feldtyp unterschiedlich sein.

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));
  }
};

• Mit 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);
  }
};

Jede der oben genannten Methoden kann in eine Erweiterung eingebunden werden, um das JSON-Format zu unterstützen.

Der Wert des Felds kann je nach Art des zu validierenden Feldes sehr unterschiedlich sein (z. B. wird in einem Zahlenfeld eine Zahl und in einem Texteingabefeld ein String gespeichert). Lesen Sie daher am besten die Dokumentation für Ihr spezifisches Feld, bevor Sie eine Validierung erstellen.

Hinweis: Validierungen sind nur für bearbeitbare Felder zulässig. Sehen Sie sich daher die Dokumentation des jeweiligen Felds an.

Rückgabewerte

Der Rückgabewert der Validierung bestimmt, was das Feld als Nächstes ausführt. Es gibt drei Möglichkeiten:

Geänderter Rückgabewert

Ein geänderter oder anderer Wert, der dann zum neuen Wert des Felds wird. Dies wird häufig verwendet, um einen Wert zu bereinigen, z. B. indem am Ende Leerzeichen entfernt werden.

Beispiel für einen Änderungs-Validator:

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

Null-Rückgabewert

Null, was bedeutet, dass der angegebene Wert ungültig ist. In den meisten Fällen wird der Eingabewert ignoriert. Das genaue Verhalten wird durch die Funktion doValueInvalid_ des Felds angegeben.

Beispiel für einen Nulling-Validator:

// 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;
};

Nicht definierter Rückgabewert

Nicht definiert (oder keine Rückgabeanweisung) oder Eingabewert, d. h. der Eingabewert sollte zum neuen Wert des Felds werden. Diese Validierungstypen fungieren im Allgemeinen als Änderungs-Listener.

Beispiel für eine Listener-Validierung:

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

Wie gesagt, der Anzeige-text entspricht nicht unbedingt dem Wert des Felds.

Wert dieses

this bezieht sich innerhalb eines Validators auf das Feld, nicht auf den Block. Wenn Sie auf den Block in einer Validierung zugreifen müssen, verwenden Sie die Funktion getSourceBlock. Sie können auch die Funktion bind verwenden, um den Kontext festzulegen, in dem die Validierung aufgerufen wird.

Beispielcode mit 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);
  }
};

Beispielcode mit 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);
  }
};