Comment utiliser fetch en caractères d'imprimerie

Je suis en utilisant de la fenêtre.fetch à la Machine, mais je ne peut pas lancer de la réponse directement à mon type personnalisé:

Je suis piratage de mon chemin autour de cela par la coulée de la Promesse résultat à un intermédiaire "toute" la variable.

Quelle serait la bonne méthode pour faire cela?

import { Actor } from './models/actor';

fetch(`http://swapi.co/api/people/1/`)
      .then(res => res.json())
      .then(res => {
          //this is not allowed
          //let a:Actor = <Actor>res;

          //I use an intermediate variable a to get around this...
          let a:any = res; 
          let b:Actor = <Actor>a;
      })
Euh, json contient des objets simples, alors comment pourriez-vous jeter un exemple? Vous auriez besoin d'utiliser quelque chose comme Actor.from qui crée un new Actor avec les données.
Pourquoi est-il "pas autorisé"? Quelle est l'erreur que vous obtenez lorsque vous essayez?
et dont les définitions sont que vous utilisez, car fetch n'est pas en caractères d'imprimerie libs encore
Ah, je suis désolé, je viens de découvrir le message d'erreur: je dois dire que res est de type quelconque. .puis((res:toute) => { let b = <Acteur>res}). Ensuite, il est effectivement permis. @MeirionHughes je suis en utilisant le definitelyTyped whatwg-fetch.d.les fichiers ts pour faire tapuscrit reconnaître chercher.

OriginalL'auteur Kokodoko | 2016-12-12

  1. 31

    Quelques exemples à suivre, de base, grâce à l'ajout de transformations après la demande et/ou d'erreur de manipulation:

    De base:

    //Implementation code where T is the returned data shape
function api<T>(url: string): Promise<T> {
  return fetch(url)
    .then(response => {
      if (!response.ok) {
        throw new Error(response.statusText)
      }
      return response.json<T>()
    })

}

//Consumer
api<{ title: string; message: string }>('v1/posts/1')
  .then(({ title, message }) => {
    console.log(title, message)
  })
  .catch(error => {
    /* show error message */
  })

    Transformations de données:

    Souvent, vous aurez besoin de faire quelques ajustements pour les données avant de son passé pour le consommateur, par exemple, en dépliant un haut niveau de données d'attribut. C'est simple:

    function api<T>(url: string): Promise<T> {
  return fetch(url)
    .then(response => {
      if (!response.ok) {
        throw new Error(response.statusText)
      }
      return response.json<{ data: T }>()
    })
    .then(data => { /* <-- data inferred as { data: T }*/
      return data.data
    })
}

//Consumer - consumer remains the same
api<{ title: string; message: string }>('v1/posts/1')
  .then(({ title, message }) => {
    console.log(title, message)
  })
  .catch(error => {
    /* show error message */
  })

    Erreur de manipulation:

    Je dirais que vous ne devriez pas être directement erreur attraper directement au sein de ce service, à la place, tout en lui permettant de bulle, mais si vous en avez besoin, vous pouvez effectuer les opérations suivantes:

    function api<T>(url: string): Promise<T> {
  return fetch(url)
    .then(response => {
      if (!response.ok) {
        throw new Error(response.statusText)
      }
      return response.json<{ data: T }>()
    })
    .then(data => {
      return data.data
    })
    .catch((error: Error) => {
      externalErrorLogging.error(error) /* <-- made up logging service */
      throw error /* <-- rethrow the error so consumer can still catch it */
    })
}

//Consumer - consumer remains the same
api<{ title: string; message: string }>('v1/posts/1')
  .then(({ title, message }) => {
    console.log(title, message)
  })
  .catch(error => {
    /* show error message */
  })
    Merci, c'est la meilleure explication de génériques que j'ai lu jusqu'à présent. Il est encore un peu vague, pourquoi une Promesse peut être d'un type, alors que c'est en fait les données de type...
    Super! J'ai été d'explorer cette partie de TS, plus récemment, de sorte que son utile pour moi pour griffonner mes notes. La pièce qui est source de confusion? - heureux d'étendre sur elle
    Je m'attends que ce n'est pas la Promesse qui a le <T> type, mais le contenu qui est récupérée. Mais apparemment, vous pouvez dire que la Promesse de la classe? (C'est une Promesse une classe? une fonction? un objet?)
    Que faire si j'ai les erreurs dans le corps de la réponse plutôt que dans le texte d'état (et je ne peux pas le contrôle)
    Il suffit de remplacer if (!response.ok) { avec tout ce que vous avez besoin de vérifier

    OriginalL'auteur Chris

  2. 0

    Si vous jetez un oeil à @types de/node-extraction vous allez voir la définition du corps

    export class Body {
    bodyUsed: boolean;
    body: NodeJS.ReadableStream;
    json(): Promise<any>;
    json<T>(): Promise<T>;
    text(): Promise<string>;
    buffer(): Promise<Buffer>;
}

    Qui signifie que vous pourriez utiliser des génériques dans le but d'obtenir ce que vous voulez. Je n'ai pas testé ce code, mais il ressemble à quelque chose comme ceci:

    import { Actor } from './models/actor';

fetch(`http://swapi.co/api/people/1/`)
      .then(res => res.json<Actor>())
      .then(res => {
          let b:Actor = res;
      });
    En ajoutant le type générique résultats dans Expected 0 type arguments, but got 1, mais peut-être que c'est parce que je n'utilise pas node-fetch. Les types natif d'extraction sont probablement différents?
    le fichier lié n'est pas basé sur un modèle json(). si elle a existé avant, il n'est pas plus.

    OriginalL'auteur nicowernli