Validadores

Um validador é uma função que recebe um novo valor nos campos e age reimplantá-lo. Eles são uma maneira simples de personalizar um campo. Eles permitem acionar funcionalidade quando o valor de um campo é alterado, modificar a entrada ou limitar quais valores são aceitáveis.

Alguns exemplos comuns:

  • Restringir um campo de texto para aceitar apenas letras.
  • Exigindo que um campo de texto não fique vazio.
  • Exigir uma data no futuro.
  • Modificar a forma de um bloco com base em um menu suspenso.
.

Tipos de validadores

Os validadores são executados em momentos diferentes, dependendo do tipo de validador os dados.

Os validadores de classe fazem parte da definição de classe de um tipo de campo e são geralmente usado para restringir o tipo de valor permitido pelo campo (por exemplo, número os campos aceitam apenas caracteres numéricos). Os validadores de classe são executados em todos os valores passados para o campo (incluindo o valor passado para o construtor).

Para mais informações sobre validadores de classes, consulte a Como implementar um validador de classes em Criação de um campo personalizado.

Os validadores locais são definidos no momento da criação de um campo. Local são executados em todos os valores passados para o campo, exceto no valor passado para o construtor. Isso significa que eles são executados em:

  • Valores contidos em XML.
  • Valores passados para setValue.
  • Valores passados para setFieldValue.
  • Valores alterados pelo usuário.

Os validadores de classe são executados antes dos validadores locais porque agem como recepcionistas. Ele confirma que o valor é do tipo correto antes de passar e começar a trabalhar.

Para mais informações sobre a sequência de validação de valores e os valores em consulte Valores.

Como registrar um validador local

Os validadores locais podem ser registrados de duas maneiras:

  • Adicionada diretamente ao construtor de um 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);
  }
};

Qualquer um dos métodos acima pode ser inserido em um extensão, para oferecer suporte ao formato JSON.

O valor do campo pode ser muito diferente dependendo do tipo de campo a validado (por exemplo, um campo numérico armazena um número, por exemplo, um campo de entrada de texto armazenará uma string) por isso, é melhor ler a documentação do seu nome antes de criar um validador.

Valores de retorno

O valor de retorno do validador determina o que o campo faz em seguida. há três possibilidades:

Valor de retorno modificado

Um valor modificado ou diferente, que se torna o novo valor do campo. Isso é frequentemente usado para limpar um valor, como a remoção de valores espaço em branco.

Exemplo de um validador de modificação:

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

Campo de entrada de texto com um validador de modificação

Valor de retorno nulo

Nulo, o que significa que o valor fornecido é inválido. Na maioria dos casos, o campo ignorar o valor de entrada. O comportamento exato é especificado pela doValueInvalid_ função.

Exemplo de um validador de anulação:

// 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 com um validador de nulidade

Valor de retorno indefinido

Não definido (ou nenhuma instrução de retorno) ou o valor de entrada, o que significa que o o valor de entrada deve se tornar o novo valor do campo. Esses tipos de validadores geralmente atuam como listeners de mudanças.

Exemplo de um validador de listener:

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

Mais uma vez, o text de exibição não reflete necessariamente a valor.

Valor deste

Dentro de um validador, this refere-se ao campo, não ao bloco. Se você precisar Para acessar o bloco dentro de um validador, use a função getSourceBlock. Você pode use também o Função bind para definir o contexto em que o validador é chamado.

Exemplo de código usando 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);
  }
};

Exemplo de código com 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);
  }
};