Niepowodzenie w Verse | Unreal Editor dla Fortnite Dokumentacja

Niepowodzenie to przepływ sterowania w Verse.

W przeciwieństwie do innych języków programowania wykorzystujących wartości logiczne true i false do zmiany kierunku programu, Verse wykorzystuje wyrażenia, które mogą zakończyć się powodzeniem lub niepowodzeniem. Wyrażenia te są nazywane wyrażeniami zawodnymi i można je wykonywać tylko w kontekście niepowodzenia.

Użycie wyrażenia niepowodzenie dla przepływu sterowania pozwala uniknąć wykonywania podwójnej pracy i drobnych błędów.

Na przykład w innych językach programowania konieczne jest sprawdzenie, czy indeks dla tablicy jest prawidłowy przed uzyskaniem dostępu do elementu tablicy pod tym indeksem, co jest częstą przyczyną błędów w innych językach.

W celu uniknięcia tego typu sytuacji w Verse weryfikacja i dostęp są połączone.

Na przykład:

    if (Element := MyArray[Index]):
        Log(Element)

Wyrażenie z możliwością niepowodzenia

Wyrażenie zawodne to wyrażenie, które może zakończyć się powodzeniem i wygenerować wartość lub niepowodzeniem i nie zwrócić żadnej wartości. Przykłady wyrażeń zawodnych obejmują indeksowanie do tablicy, ponieważ nieprawidłowy indeks zakończy się niepowodzeniem, oraz używanie operatorów, takich jak porównywanie dwóch wartości.

Kod, który piszesz, domyślnie nie ma możliwości niepowodzenia. Na przykład, aby napisać funkcję, która może zakończyć się niepowodzeniem, musisz dodać efekt specyfikatora <decides> do definicji funkcji. Obecnie konieczne jest również dodanie <transacts> podczas używania <decides>.

Aby uzyskać pełną listę wyrażeń, w przypadku których istnieje możliwość niepowodzenia, zapoznaj się z listą Wyrażeń w Verse.

Kontekst niepowodzenia

Kontekst niepowodzenia jest kontekstem, w którym dopuszczalne jest wykonywanie wyrażeń zawodnych. Kontekst określa, co się stanie, jeśli wyrażenie zakończy się niepowodzeniem. Każde niepowodzenie w kontekście niepowodzenia spowoduje niepowodzenie całego kontekstu.

Kontekst niepowodzenia dopuszcza zastosowanie wyrażeń zawodnych, takich jak argumenty funkcji lub wyrażenia w wyrażeniu block, w charakterze wyrażeń zagnieżdżonych.

Przydatnym aspektem kontekstów niepowodzeń w Verse jest fakt, że są one formą spekulatywnego wykonywania, co oznacza, że można wypróbować akcje bez ich zatwierdzania. Gdy wyrażenie zakończy się powodzeniem, efekty wyrażenia zostaną zatwierdzone, na przykład poprzez zmianę wartości zmiennej. Jeśli wyrażenie zakończy się niepowodzeniem, jego efekty zostaną wycofane, tak jakby wyrażenie nigdy nie miało miejsca.

Dzięki temu można wykonać szereg akcji kumulujących zmiany, jednak niepowodzenie tych akcji na dowolnym etapie spowoduje ich cofnięcie.

Aby to zadziałało, wszystkie funkcje wywoływane w kontekście niepowodzenia muszą zawierać specyfikator efektu <transacts>, a kompilator będzie wskazywał błędy, jeśli tak nie będzie.

Funkcje zdefiniowane przez użytkownika domyślnie nie mają efektu transacts. Do ich definicji należy dodać jawny specyfikator <transacts>. Niektóre funkcje natywne również nie mają efektu transacts i nie mogą być wywoływane w przypadku niepowodzenia.

Przykładem funkcji natywnej bez transacts może być audio_component z metodą BeginSound(). Jeśli dźwięk się rozpoczął, to nawet gdy się zatrzymał, można go było zauważyć.

Poniższa lista obejmuje wszystkie konteksty niepowodzenia dostępne w Verse:

Warunek w wyrażeniach if.
```
if (test-arg-block) { … }
```
if (test-arg-block) { … }
Wyrażenia iteracyjne i wyrażenia filtrujące w wyrażeniach for. Pamiętaj, że for to wyrażenie specjalne, ponieważ tworzy kontekst niepowodzenia dla każdej iteracji. Jeśli iteracje są zagnieżdżone, wówczas konteksty niepowodzenia również będą zagnieżdżone. Gdy wyrażenie zakończy się niepowodzeniem, skrajnie wewnętrzny kontekst błędu zostaje przerwany, a otaczająca iteracja (jeśli istnieje) jest kontynuowana od następnej iteracji.
```
for (Item : Collection, test-arg-block) { … }
```
for (Item : Collection, test-arg-block) { … }
Ciało funkcji lub metody zawierającej specyfikator efektu <decides>.
```
IsEqual()&ltdecides><transacts> : void = { … }
```
IsEqual()&ltdecides><transacts> : void = { … }
Operand dla operatora not.
```
not expression
```
not expression
Lewy operand dla operatora or.
```
expression1 or expression2
```
expression1 or expression2
Inicjacja zmiennej typu option.
```
option{expression}
```
option{expression}