: (data) => List.from(data).map((json) => User.fromJson(json)).toList(),
User: (data) => User.fromJson(data),
// ...
};
```
In der modelDecoders-Datei müssen wir den `Type` als Schlüssel angeben und die Umwandlung im Wert behandeln, wie im obigen Beispiel.
Das Argument `data` enthält den Payload der API-Anfrage.
## Typisierte Decoders
Voraussetzung
Nylo 7.5.0+
nylo_support 7.37.0+
`decoders([...])` erstellt Ihre `modelDecoders`-Map aus einer Liste. `Decode(User.fromJson)` dekodiert einen `User` und auch eine `List`, ohne einen eigenen Eintrag:
```dart
final Map modelDecoders = decoders([
Decode(User.fromJson),
Decode(Order.fromJson, from: 'data'),
]);
```
Verwenden Sie `from`, um das Model aus einem umschlossenen Body zu lesen, etwa `{"data": {...}}`. Ein Schlüssel mit Punkt wie `'data.user'` liest tiefer, und bei einer Liste wird die Liste selbst aus `from` gelesen.
`Decode` erwartet ein `fromJson`, das `dynamic` oder `Map` akzeptiert. Geben Sie bei einer Closure den Typ ihres Parameters an:
```dart
Decode((dynamic json) => User.fromJson(json)),
```
Closure-Decoders in einer `{...}`-Map, etwa `User: (data) => User.fromJson(data)`, funktionieren weiterhin. Beide sind ein `NyDecoder`, die Klasse, von der `Decode` und `OneOf` erben. Ein eigener `NyDecoder` implementiert `decode(json, response, decoders)` und sieht die gesamte `NyResponse`, sodass er den Statuscode oder die Header lesen kann.
## OneOf
Voraussetzung
Nylo 7.5.0+
nylo_support 7.37.0+
`OneOf` dekodiert eine Antwort, die mehr als eine Form annehmen kann. Registrieren Sie es unter dem gemeinsamen Elterntyp und wählen Sie die Form über ein Feld im Body, über den Statuscode oder mit eigenen Bedingungen:
```dart
final Map modelDecoders = decoders([
OneOf.byKey('status', {
'success': LoginSuccess.fromJson,
'two_factor': TwoFactorRequired.fromJson,
}, otherwise: (json) => LoginFailed(ApiError.fromJson(json))),
]);
```
Ein `OneOf` dekodiert auch 4xx- und 5xx-Bodys sowie eine `List` Element für Element. Eine Form, die es nicht erkennt, lässt die Antwortdaten null.
| Konstruktor | Wählt die Form über |
|-------------|---------------------|
| `OneOf.byKey(key, types, otherwise:)` | Den Wert von `key` im Body. Ein Schlüssel mit Punkt wie `'data.type'` liest ein verschachteltes Feld |
| `OneOf.byStatus(types, otherwise:)` | Den Statuscode. Ein Schlüssel ist ein Code wie `404` oder ein Muster wie `'4xx'` oder `'40x'` |
| `OneOf.byJson(types, otherwise:)` | Ihre eigenen Bedingungen, die jeweils den Body und die Antwort erhalten. Die erste, die true zurückgibt, gewinnt |
| `OneOf(resolve)` | Eine Funktion, die den Body und die Antwort erhält und den Wert oder null zurückgibt |
Nach Statuscode:
```dart
OneOf.byStatus({
200: OrderPlaced.fromJson,
404: OrderNotFound.fromJson,
'4xx': (json) => OrderRejected(ApiError.fromJson(json)),
}),
```
Ein exakter Code gewinnt, danach das Muster mit den wenigsten `x`.
Mit eigenen Bedingungen:
```dart
OneOf.byJson({
(json, response) => response.statusCode == 200 && json['status'] == 'ok': SignUpComplete.fromJson,
(json, response) => response.statusCode == 200 && json['status'] == 'verify': VerifyEmail.fromJson,
}),
```
Mit einer Funktion:
```dart
OneOf((json, response) => switch ((response.statusCode, json)) {
(200, {'status': 'placed'}) => OrderPlaced.fromJson(json),
(200, _) => OrderPending.fromJson(json),
_ => null,
}),
```
Lesen Sie die Form aus einer Antwort mit `dataAs()` und `dataIs()`; siehe [NyResponse](/docs/7.x/networking#ny-response).
Metro erstellt den Elterntyp, seine Untertypen und den `OneOf.byKey`-Eintrag für Sie:
```bash
metro make:model login_result --one-of="success,two_factor"
```
Siehe [Ein OneOf-Model erstellen](/docs/7.x/metro#make-a-one-of-model).
## API-Decoders
API-Decoders werden beim Aufruf der `api`-Hilfsmethode verwendet.
```dart
loadUser() async {
User user = await api((request) => request.fetchUser());
}
```
Der `api`-Helfer ordnet den richtigen API-Service mithilfe von Generics zu, sodass Sie den folgenden Helfer aufrufen können, um auf Ihren Service zuzugreifen.
```dart
await api((request) => request.callMyMethod());
```
Bevor Sie den `api`-Helfer verwenden, müssen Sie zunächst Ihren API-Service in lib/config/decoders.dart > apiDecoders hinzufügen.
```dart
final Map apiDecoders = {
ApiService: ApiService(),
// ...
};
```