Verificaciones de conexión

Las verificaciones de conexión restringen qué conexiones (y, por lo tanto, qué bloques) pueden conectarse entre sí.

Las verificaciones de conexión son útiles para los tipos de modelado. Por ejemplo, los siguientes tres bloques no tienen por qué estar conectados, ya que representan código que muestra diferentes tipos:

Las verificaciones de conexión se pueden usar para evitar que estos bloques se conecten. Esto les brinda a los usuarios comentarios instantáneos y evita muchos errores simples.

Cómo funcionan

Cada conexión se puede asociar con una "verificación de conexión", que es un array de cadenas nullable.

Dos conexiones pueden conectarse en los siguientes casos:

1. Son tipos compatibles (p.ej., una salida que se conecta a una entrada).
2. Tienen al menos una cadena en común en la verificación de conexión.

Por ejemplo, las conexiones con las siguientes dos verificaciones podrían conectarse, ya que comparten la cadena 'apple':

['apple', 'ball', 'cat']
['apple', 'bear', 'caterpillar']

Sin embargo, las conexiones con estas dos verificaciones no se pudieron establecer, ya que no comparten ninguna cadena:

['apple', 'ball', 'cat']
['ape', 'bear', 'caterpillar']

Hay otro caso especial. Si cualquiera de los arrays es null, las dos conexiones también se pueden conectar. Esto te permite definir conexiones que se pueden conectar a cualquier cosa.

null
['ape', 'bear', 'caterpillar]

Importante: Las cadenas que se usan en las verificaciones de conexión no tienen un significado inherente. Por ejemplo, usar la cadena 'Number' no garantiza que una conexión represente un número. En cambio, solo se usan para hacer coincidir otras cadenas.

Importante: Los tipos de bloqueo, como 'math_number', y las verificaciones de conexión son conjuntos de cadenas completamente independientes. Incluir un tipo de bloque en una verificación de conexión no hace que los bloques de ese tipo puedan conectarse.

Ejemplos

Para obtener una lista de ejemplos sobre cómo usar las verificaciones de conexión, consulta la guía de verificación de conexiones.

Cómo establecer verificaciones

De forma predeterminada, todas las conexiones tienen una verificación de conexión null, lo que significa que se pueden conectar a cualquier cosa. Las verificaciones de conexión deben asignarse de forma manual.

La forma de asignar verificaciones de conexión a las conexiones es diferente según si usas definiciones de bloques JSON o definiciones de bloques de JavaScript.

JSON

En el caso de las conexiones de nivel superior, asignas la verificación directamente a la propiedad que define la conexión. El valor que asignes puede ser null, una cadena (que se convierte en la única entrada en la verificación de conexión) o un array de cadenas.

{
  'type': 'custom_value_block',

  'output': 'a connection check entry',
},
{
  'type': 'custom_statement_block',

  'nextStatement': null, // null check
  'previousStatement': ['four', 'connection', 'check', 'entries']
}

En el caso de las entradas, puedes asignar la verificación a una propiedad check de la definición de entrada. Si la propiedad check no existe, la verificación se considera null. El valor que asignes puede ser una cadena o un array de cadenas.

{
  'type': 'custom_block',
  'message0': '%1 %2',

  'args0': [
    {
      'type': 'input_value',
      'check': 'a connection check entry' // Accepts custom_value_block
    },
    {
      'type': 'input_statement',
      'check': ['two', 'entries'] // Accepts custom_statement_block
    }
  ]
}

JavaScript

En el caso de las conexiones de nivel superior, puedes pasar la verificación directamente al método que define la conexión. Si no pasas un valor, la verificación se considera null. El valor que pases puede ser una cadena (que se convierte en la única entrada en la verificación de conexión) o un array de cadenas.

Blockly.Blocks['custom_value_block'] = {
  init: function() {
    this.setOutput(true, 'a connection check entry');
  }
};
Blockly.Blocks['custom_statement_block'] = {
  init: function() {
    this.setNextStatement(true); // null check
    this.setPreviousStatement(true, ['four', 'connection', 'check', 'entries']);
  }
};

En el caso de las entradas, puedes pasar la verificación al método setCheck después de definir la entrada. Si no se llama al método setCheck, la verificación se considera null. El valor que pases puede ser una cadena o un array de cadenas.

Blockly.Blocks['custom_block'] = {
  init: function() {
    this.appendValueInput('NAME')
        .setCheck('a connection check entry'); // Accepts custom_value_block
    this.appendStatementInput('NAME')
        .setCheck(['two', 'entries']); // Accepts custom_statement_block
  }
};

Cadenas de verificación integradas

Los bloques integrados tienen verificaciones de conexión con los valores 'Array', 'Boolean', 'Colour', 'Number' y 'String'. Si deseas que tus bloques operen de manera interoperable con los bloques integrados, puedes usar estos valores para que sean compatibles.

Limitaciones

Este sistema es bastante sólido y puede resolver muchos casos de uso, pero tiene algunas limitaciones.

Cómo restringir el contexto más amplio

Por sí solo, este sistema no admite la restricción del "contexto superior" en el que se puede conectar una conexión. Por ejemplo, no puedes decir que un bloque break solo puede existir dentro de un bloque loop. El sistema de verificación de conexiones solo considera las dos conexiones inmediatas que se conectan.

Puedes admitir esto con el sistema de eventos para escuchar eventos de movimiento de bloques y verificar si el bloque está posicionado de forma incorrecta.

Blockly.Blocks['custom_block'] = {
  init: function() { }

  onchange: function(e) {
    if (this.workspace.isDragging()) return;
    if (e.type !== Blockly.Events.BlockMove) return;
    if (!this.getSurroundLoop()) this.outputConnection.disconnect();
  }

  loopTypes: new Set(); // Your valid *block types* (not connection checks).

  getSurroundLoop: function () {
    let block = this.getSurroundParent();
    do {
      if (loopTypes.has(block.type)) return block;
      block = block.getSurroundParent();
    } while (block);
    return null;
  },
}

Tipos genéricos

Por sí solo, este sistema no admite la definición de tipos genéricos. Por ejemplo, no puedes crear un bloque "Identity" que "devuelva" cualquier entrada.

Puedes apoyar esto en cierta medida cambiando de forma activa la verificación de conexión en el resultado del bloque para que coincida con su entrada. Lo que puedes hacer con el sistema de eventos para escuchar los eventos de movimiento de bloqueo.

Blockly.Blocks['custom_block'] = {
  init: function() { }

  onchange: function(e) {
    if (e.type !== Blockly.Events.BlockMove) return;
    this.setOutput(
        true, this.getInputTargetBlock()?.outputConnection.getCheck());
  }
}

Sin embargo, si el bloque conectado también es genérico, no funcionará correctamente. No hay una solución adecuada para este caso.

Verificador de conexiones

Si este sistema no funciona para tu caso de uso, también puedes cambiar la forma en que se comparan las verificaciones de conexión creando un verificador de conexión personalizado.

Por ejemplo, si deseas crear un sistema más avanzado que controle algunas de las limitaciones de este, puedes crear un comprobador de conexiones personalizado.