Sprawdzanie połączenia

Sprawdzanie połączeń ogranicza możliwość połączenia (a tym samym blokad) i otwierać przed sobą nawzajem.

Sprawdzanie połączeń przydaje się do modelowania typów. Na przykład: z dwoma blokami nie ma żadnej połączonej firmy, ponieważ reprezentują kod, który zwraca różne typy:

Za pomocą sprawdzania połączeń można uniemożliwić tym osobom nawiązanie połączenia. Ten zapewnia użytkownikom natychmiastowy dostęp do informacji zwrotnych i zapobiega wielu prostym pomyłkom.

Jak działają

Każde połączenie można powiązać ze „sprawdzaniem połączeń” który jest dopuszczalny do wartości null tablica ciągów tekstowych.

2 połączenia mogą się połączyć, jeśli:

1. Są to zgodne typy (np. dane wyjściowe łączące się z dane wejściowe).
2. Mają co najmniej 1 wspólny ciąg znaków w ramach sprawdzania połączenia.

Na przykład te 2 kontrole mogą się ze sobą połączyć, ponieważ mają wspólny Ciąg tekstowy 'apple':

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

Jednak te 2 kontrole nie mogą się połączyć, ponieważ nie mają wspólnych ciągów:

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

Jest jeszcze jeden specjalny przypadek. Jeśli jedna z tablic to null, to obie połączenia. Umożliwia to definiowanie połączeń, do czegokolwiek.

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

Ważne: typy blokad i sprawdzania połączenia to nie to samo. Są to w całości osobne zestawy ciągów tekstowych. Uwzględnienie typu bloku w sprawdzaniu połączenia nie umożliwiał łączenia bloków tego typu.

Skonfiguruj kontrolę

Domyślnie wszystkie połączenia mają kontrolę stanu null, co oznacza, że mogą z czymś, co chcesz. Weryfikacje połączeń trzeba przypisać ręcznie.

Sposób przypisywania sprawdzania połączeń do połączeń zależy od niezależnie od tego, czy używasz definicji blokad JSON czy JavaScriptu.

JSON

W przypadku połączeń najwyższego poziomu przypisujesz kontrolę bezpośrednio do usługi, która który definiuje połączenie. Przypisaną wartością może być null, ciąg znaków (który staje się jedynym wpisem w sprawdzaniu połączenia) lub tablicą ciągów znaków.

{
  'type': 'custom_block',

  'output': null,
  'nextStatement': 'a connection check entry',
  'previousStatement': ['four', 'connection', 'check', 'entries']
}

W przypadku danych wejściowych możesz przypisać kontrolę do właściwości check danych wejściowych. definicji. Jeśli właściwość check nie istnieje, weryfikacja jest brana pod uwagę null Przypisaną wartość może być ciągiem znaków lub tablicą ciągów znaków.

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

  'args0': [
    {
      'type': 'input_value',
      'check': 'a connection check entry'
    },
    {
      'type': 'input_statement',
      'check': ['four', 'connection', 'check', 'entries']
    }
  ]
}

JavaScript

W przypadku połączeń najwyższego poziomu możesz przekazać kontrolę bezpośrednio do metody, która który definiuje połączenie. Jeśli nie podasz żadnej wartości, weryfikacja zostanie uwzględniona null Przekazywana wartość może być ciągiem znaków (który jest jedynym wpisem w sprawdzenie połączenia) lub tablicę ciągów znaków.

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

W przypadku danych wejściowych możesz przekazać kontrolę do metody setCheck, gdy już zdefiniował dane wejściowe. Jeśli metoda setCheck nie jest wywoływana, kontrola jest uznano za null. Przekazywana wartość może być ciągiem znaków lub tablicą ciągów znaków.

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

Wbudowane ciągi kontrolne

Wbudowane bloki mają kontrole połączenia z wartościami 'Array', 'Boolean', 'Colour', 'Number' i 'String'. Jeśli chcesz, aby blokady współdziałają z wbudowanymi blokami, możesz użyć tych wartości, aby są zgodne.

Przykłady wartości

Gdy definiujesz sprawdzanie połączenia dla danych wejściowych i wyjściowych, zwykle musisz należy traktować weryfikację jako typ.

Wejścia sprawdzanie powinno obejmować każdy „typ” akceptowalne i wygenerowane sprawdzić powinny zawierać dokładnie to, co zwraca.

Akceptuj jeden typ

W najbardziej podstawowym przypadku, gdy chcesz utworzyć blok, który „akceptuje” lub „zwroty” jeden, musisz go uwzględnić przy sprawdzaniu połączenia.

Akceptuj wiele typów

Aby utworzyć blok, który „akceptuje” wielu typów, musisz uwzględnić każdy akceptowanego typu podczas sprawdzania połączenia z danymi wejściowymi.

Zgodnie z konwencją, jeśli dane wyjściowe mogą czasem zostać zaakceptowane w wielu sytuacjach (np. jeśli zezwolisz, by liczby były czasami używane jako ciągi znaków), dane wyjściowe powinny być bardziej restrykcyjne, a dane wejściowe powinny być mniej restrykcyjne. Ta konwencja zapewnia, że dane wyjściowe nie łączą się tam, gdzie nie są obsługiwane.

Akceptuj dowolny typ

Aby utworzyć blok, który „akceptuje” dowolnego typu, musisz ustawić sprawdzenie połączenia z urządzeniem null.

Zwróć podtypy

Aby utworzyć blok, który „powraca” jako podtypu, musisz uwzględnić zarówno typ, oraz supertyp w sprawdzaniu połączenia danych wyjściowych.

W przypadku podtypów można sprawdzać dane wyjściowe wielokrotnie, bo blok zawsze „powraca” obu typów.

Zwróć typy z parametrami

Aby utworzyć blok, który „powraca” typu z parametrami, musisz uwzględnić zarówno wersję z parametrami i wersję bez parametrów w pliku wyjściowym sprawdzanie połączenia.

W zależności od tego, jak rygorystyczny ma być język blokowania, możesz też uwzględniać wariancje typu.

Podobnie jak w przypadku podtypów, możesz mieć kilka kontroli w celu sprawdzenia danych wyjściowych w tym przypadku, ponieważ blok zawsze „zwraca” obu typów.

Przykłady stosu lub instrukcji

Deweloperzy mogą definiować testy dotyczące poprzedniego i następnego na kilka sposobów. połączeń. Zwykle traktuje to jako ograniczenie kolejności bloków.

Następne połączenia powinny określać, które bloki powinny następować po bieżącym, poprzednie połączenia zawierają aktualny blok.

Ważne: typy blokad i sprawdzania połączenia to nie to samo. Kiedy to brzmi: „które bloki powinny następować po bieżącym”, oznacza to, że sprawdzanie połączenia powinny zawierać odpowiednie ciągi tekstowe, a nie typy blokad.

Utrzymuj bloki w porządku

Aby utworzyć zbiór bloków, które łączą się w określonej kolejności, musisz uwzględnić które bloki powinny następować po bieżącym przy następnym sprawdzeniu połączenia, czym jest bieżący blok? podczas poprzedniego sprawdzania połączenia.

Zezwalaj na wiele środkowych bloków

Aby utworzyć zestaw ułożonych bloków, które mogą zawierać wiele środkowych brył, musisz uwzględnij co najmniej jeden wpis z poprzedniego sprawdzania połączenia w środkowym bloku podczas następnego sprawdzania połączenia środkowego bloku. Umożliwia to śledzenie bloku z samego siebie.

Nie zezwalaj na środkowe bloki

Aby utworzyć zestaw uporządkowanych brył, w których środkowe bryły są opcjonalne, potrzebujesz uwzględnij co najmniej jeden wpis z poprzedniego połączenia zarówno środkowego bloku oraz sprawdzenie poprzedniego połączenia ostatniego bloku w następnym sprawdzanie połączenia. Dzięki temu za pierwszym blokiem może następować element środkowy lub ostatnią blokadę.

Jedna albo stos

Aby utworzyć blok, po którym następują tylko bloki z jednej grupy, lub bloki z innego (a nie z obu), musisz zrobić 2 rzeczy:

1. Musisz uwzględnić co najmniej 1 wpis z obu grup poprzednich sprawdza połączenia przy następnym sprawdzeniu połączenia w pierwszym bloku.

2. Musisz zdefiniować dla grup sprawdź połączenie, aby uwzględnić tylko wartości. które były wcześniej sprawdzane (dzięki czemu można je śledzić tylko blokami tej samej grupy).

Ograniczenia

Jest to system dość solidny i może poradzić sobie z wieloma zastosowaniami, ale i ograniczeniach.

Ograniczanie szerszego kontekstu

System ten sam nie obsługuje ograniczania „większego kontekstu” cale które można połączyć z siecią. Na przykład nie można powiedzieć, że Blok break może istnieć wyłącznie wewnątrz bloku loop. Połączenie sprawdza tylko dwa bezpośrednie połączenia.

Aby to obsługiwać, możesz nasłuchiwać zdarzeń z systemu zdarzeń zablokuj zdarzenia przesuwania i sprawdź, czy bryła jest prawidłowo umieszczona.

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

Typy ogólne

System nie obsługuje definiowania typów ogólnych. Przykład: nie można utworzyć „tożsamości” „powraca” bez względu na dane wejściowe.

Możesz trochę temu pomóc, aktywnie zmieniając sprawdzanie połączenia na tak, aby pasowały do jego danych wejściowych. Co można zrobić, korzystając z systemu zdarzeń, nasłuchuj zdarzeń blokowania ruchu.

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

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

Jeśli jednak połączony blok jest również ogólny, nie będzie działać prawidłowo. Nie ma dobrego sposobu na to rozwiązanie.

Narzędzia do sprawdzania połączeń

Jeśli system nie sprawdza się w Twoim przypadku, możesz też zmienić sposób testy połączeń są porównywane przez utworzenie niestandardowego narzędzia do sprawdzania połączeń.

Jeśli na przykład chcesz utworzyć bardziej zaawansowany system, który obsługuje niektóre jego ograniczenia, możesz utworzyć Narzędzie do sprawdzania połączeń.