Las verificaciones de conexión restringen qué conexiones (y, por lo tanto, los bloques) se pueden conectar entre sí.
Las verificaciones de conexión son útiles para los tipos de modelado. Por ejemplo, el siguiente tres bloques no tienen negocios conectados porque representan un código que devuelve diferentes tipos:
Las verificaciones de conexión se pueden usar para evitar que estos bloques se conecten. Esta Proporciona a los usuarios comentarios instantáneos y evita errores simples.
Cómo funcionan
Cada conexión se puede asociar con una “verificación de conexión” que es un valor anulable un array de cadenas.
Dos conexiones pueden conectarse si:
- Son tipos compatibles (p.ej., una salida que se conecta a una entrada).
- Tienen al menos una cadena en su verificación de conexión en común.
Por ejemplo, las siguientes dos verificaciones podrían conectarse, ya que comparten el
String 'apple':
['apple', 'ball', 'cat']
['apple', 'bear', 'caterpillar']
Sin embargo, no se pudieron conectar estas dos verificaciones, ya que no comparten ninguna cadena:
['apple', 'ball', 'cat']
['ape', 'bear', 'caterpillar']
Hay otro caso especial. Si alguno de los arrays es null, entonces los dos
conexiones también pueden conectarse. Esto te permite definir las conexiones que pueden conectarse
a nada.
null
['ape', 'bear', 'caterpillar]
Establecer verificaciones
De forma predeterminada, todas las conexiones tienen una comprobación de conexión null, lo que significa que pueden
conectarse a nada. Las verificaciones de conexión se deben asignar de forma manual.
La forma de asignar las verificaciones de conexión a las conexiones es diferente según lo siguiente: ya sea que uses definiciones de bloques JSON o definiciones de bloques de JavaScript.
JSON
Para las conexiones de nivel superior, asignas la verificación directamente a la propiedad que
define la conexión. El valor que asignas puede ser null, una cadena (que
se convierte en la única entrada en la verificación de conexión) o en un array de cadenas.
{
'type': 'custom_block',
'output': null,
'nextStatement': 'a connection check entry',
'previousStatement': ['four', 'connection', 'check', 'entries']
}
Para las entradas, puedes asignar la verificación a una propiedad check de la entrada
definición. Si la propiedad check no existe, se considera la verificación
null El valor que asignas puede ser una cadena o un array de cadenas.
{
'type': 'custom_block',
'message0': '%1 %2',
'args0': [
{
'type': 'input_value',
'check': 'a connection check entry'
},
{
'type': 'input_statement',
'check': ['four', 'connection', 'check', 'entries']
}
]
}
JavaScript
Para conexiones de nivel superior, puedes pasar la verificación directamente al método que
define la conexión. Si no pasas un valor, se considerará la verificación
null El valor que pasas puede ser una cadena (que se convierte en la única entrada de la
verificación de conexión) o un array de cadenas.
Blockly.Blocks['custom_block'] = {
init: function() {
this.setOutput(true); // null check
this.setNextStatement(true, 'a connection check entry');
this.setPreviousStatement(true, ['four', 'connection', 'check', 'entries']);
}
}
Para las entradas, puedes pasar la verificación al método setCheck, después de
definió la entrada. Si no se llama al método setCheck, se realiza la verificación
considerado null. El valor que pasas puede ser una cadena o un array de cadenas.
Blockly.Blocks['custom_block'] = {
init: function() {
this.appendValueInput('NAME')
.setCheck('a connection check entry');
this.appendStatementInput('NAME')
.setCheck(['four', 'connection', 'check', 'entries']);
}
}
Cadenas de verificación integradas
Los bloques integrados tienen verificaciones de conexión con los valores 'Array',
'Boolean', 'Colour', 'Number' y 'String'. Si quieres que tus bloques
interoperar con los bloques integrados, puedes usar estos valores para
compatibles.
Ejemplos de valores
Cuando defines verificaciones de conexión para entradas y salidas, deberíamos pensar en las verificaciones como tipos.
Entradas las verificaciones deben incluir todos los “tipos” que aceptan y genera verificaciones incluir exactamente lo que "devuelven".
Cómo aceptar un solo tipo
En el caso más básico en el que quieres crear un bloque que "acepte" o “devoluciones” un tipo, debes incluirlo en la verificación de conexión de la conexión.
Aceptar varios tipos
Para crear un bloque que "acepte" varios tipos, debes incluir todas tipo aceptado en la verificación de conexión de la entrada.
Por convención, si un resultado a veces se puede aceptar en varias situaciones (p.ej., si permites que a veces se usen números como cadenas), el resultado debería ser sean más restrictivas, y las entradas deben ser más permisivas. Esta convención y se asegura de que los resultados no se conecten en lugares incompatibles.
Aceptar cualquier tipo
Para crear un bloque que "acepte" de cualquier tipo, debes establecer la configuración
verificación de conexión a null.
Muestra subtipos
Crear un bloque que “devuelva” un subtipo, debes incluir el tipo y el supertipo en la verificación de conexión del resultado.
En el caso de los subtipos, está bien tener varias comprobaciones en una verificación de salida porque el bloque siempre "devuelve" ambos tipos.
Muestra tipos con parámetros
Crear un bloque que “devuelva” un tipo parametrizado, debes incluir la versión con parámetros y la versión sin parámetros en la verificación de conexión.
Según qué tan estricto quieras que sea el idioma de bloqueo, también puedes incluir las varianzas del tipo.
Al igual que con los subtipos, es correcto tener varias verificaciones en una verificación de salida. en este caso, porque el bloque siempre “devuelve” ambos tipos.
Ejemplos de pila o sentencia
Existen algunas formas comunes en que los desarrolladores definen las verificaciones para las verificaciones anteriores y siguientes. conexiones de red. Por lo general, se considera que restringen el orden de los bloques.
Las siguientes conexiones deben incluir qué bloques deben seguir al actual las conexiones anteriores incluyen qué "es" el bloque actual.
Mantener los bloques en orden
Para crear un conjunto de bloques que se conecten en un orden definido, debes incluir qué bloques deben seguir al actual en la próxima verificación de conexión qué "es" el bloque actual en la verificación de conexión anterior.
Permitir muchos bloques en el medio
Para crear un conjunto de bloques ordenados que permitan muchos bloques en el medio, debes incluir al menos una entrada de la entrada de conexión anterior del bloque del medio la próxima comprobación de conexión del bloque del medio. Esto permite seguir el bloque por sí solo.
No permitir bloques en el medio
Para crear un conjunto de bloques ordenados en los que los bloques del medio sean opcionales, necesitas incluir al menos una entrada de la conexión anterior del bloque del medio y la comprobación de conexión anterior del último bloque en la siguiente verificación de conexión. Esto permite que el primer bloque sea seguido por un o un último bloque.
Pilas
Para crear un bloque que solo pueda seguirse por bloques de un grupo o bloques de otra (y no de ambas), debes hacer dos cosas:
Debes incluir al menos una entrada de ambos grupos de conexión en la próxima verificación de conexión del primer bloque.
Debes definir las contraseñas de los grupos siguientes verificaciones de conexión para incluir solo valores que se encuentren en sus verificaciones de conexión anteriores (para que solo puedan seguirse por bloques del mismo grupo).
Limitaciones
Este sistema es bastante sólido y puede resolver muchos casos de uso, pero tiene algunos las limitaciones de seguridad.
Restringe el contexto general
Este sistema por sí solo no admite la restricción del “contexto mayor” en
a la que una conexión puede conectarse. Por ejemplo, no puedes decir que un
El bloque break solo puede existir dentro de un bloque loop. La conexión
solo considera que se conectan las dos conexiones inmediatas.
Puedes admitir esto usando el sistema de eventos para escuchar bloquea eventos de movimiento y verifica si el bloque está ubicado 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
Este sistema por sí solo no admite la definición de tipos genéricos. Por ejemplo: no puedes crear una “Identidad” “devuelve” sea cual sea su entrada.
Puedes admitir esto en cierta medida si cambias la verificación de conexión en la salida de un bloque de código para que coincida con su entrada. Puedes hacerlo usando el sistema de eventos escuchar para bloquear eventos de movimiento.
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, esto no funciona correctamente. No hay una buena solución para este caso.
Verificadores de conexión
Si este sistema no funciona en tu caso de uso, puedes cambiar la forma las verificaciones de conexión se comparan creando verificador de conexión personalizado.
Por ejemplo, si quisieras crear un sistema más avanzado que controle algunos de limitaciones de esta, puedes crear una verificador de conexiones.