Validadores

Un validador es una función que toma un valor nuevo en los campos y, luego, actúa sobre que la modifica. Son una forma sencilla de personalizar un campo. Te permiten activar la funcionalidad cuando cambia el valor de un campo, modifica la entrada o limita qué valores son aceptables.

A continuación, hay algunos ejemplos comunes:

  • Restringir un campo de texto para que solo acepte letras
  • Requiere que un campo de texto no esté vacío.
  • Solicitar que una fecha sea posterior a la actual.
  • Modificación de la forma de un bloque a partir de un menú desplegable.

Tipos de validadores

Los validadores se ejecutan en distintos momentos, dependiendo del tipo de validador en la nube.

Los validadores de clase son parte de la definición de clase de un tipo de campo generalmente se usa para restringir el tipo de valor que permite el campo (p.ej., número los campos solo aceptan caracteres numéricos). Los validadores de clase se ejecutan en todos los valores pasado al campo (incluido el valor que se pasó al constructor).

Para obtener más información sobre los validadores de clase, consulta el Cómo implementar un validador de clases en Creación de un campo personalizado.

Los validadores locales se definen en el momento de la construcción de un campo. Locales los validadores se ejecutan en todos los valores que se pasan al campo, excepto en el que se pasa .. Esto significa que se ejecutan en

  • Valores contenidos en XML.
  • Valores pasados a setValue.
  • Valores pasados a setFieldValue.
  • Valores modificados por el usuario.

Los validadores de clase se ejecutan antes que los locales porque funcionan como recepcionistas. Se asegura de que el valor sea del tipo correcto antes de pasar y volver a activarla.

Para obtener más información sobre la secuencia de validación de valores y los valores en general, consulta Valores.

Registra un validador local

Los validadores locales se pueden registrar de dos maneras:

  • Se agrega directamente al constructor de un campo.
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));
  }
};

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

Cualquiera de los métodos anteriores se puede unir en una extensión, para admitir el formato JSON.

El valor del campo puede ser muy diferente según el tipo de campo que validado (p.ej., un campo numérico almacenará un número, mientras que un campo de entrada de texto almacenará una cadena), así que es mejor leer la documentación para tu antes de crear un validador.

Valores que se devuelven

El valor que se muestra del validador determina lo que el campo hace a continuación. Hay hay tres posibilidades:

Valor de retorno modificado

Un valor modificado o diferente, que luego se convierte en el valor nuevo del campo. A menudo, se usa para limpiar un valor, por ejemplo, quitando espacio en blanco.

Ejemplo de un validador de modificación:

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

Campo de entrada de texto con un validador de modificación

Valor de retorno nulo

Nulo, lo que significa que el valor dado no es válido. En la mayoría de los casos, el campo ignorar el valor de entrada. El comportamiento exacto se especifica mediante doValueInvalid_ función.

Ejemplo de un validador de anulación:

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

Campo de entrada de texto con un validador de anulación

Valor de retorno no definido

Indefinido (o sin sentencia return) o el valor de entrada, lo que significa que el el valor de entrada debe convertirse en el nuevo valor del campo. Estos tipos de validadores generalmente actúan como objetos de escucha de cambios.

Ejemplo de un validador de objetos de escucha:

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

Una vez más, ten en cuenta que el texto visible no refleja necesariamente la propiedad del campo valor.

Valor

Dentro de un validador, this hace referencia al campo, no al bloque. Si necesitas Para acceder al bloque dentro de un validador, usa la función getSourceBlock. Puedes también puedes usar función bind para configurar el contexto en el que se llama al validador.

Código de muestra con 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);
  }
};

Código de muestra con vinculación:

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