Comment appeler les méthodes l'une après l'autre ?

Question

Il existe une fonction qui accepte trois paramètres :

function getAddressStructure(country: number, city: number, region: number) {

}

Je dois créer une promesse qui renvoie des données pour chaque variable et qui renvoie un objet commun. {countries: [], cities: [], regions: []}

Comment le faire en utilisant une ou plusieurs promesses ?

let promise = new Promise((resolve, reject) => resolve());

Answer 1

Si vous avez trois points finaux différents qui ne sont pas dépendants les uns des autres, vous pouvez utiliser cette approche :

export async function handleResponse(response) {
  if (response.ok) return response.json();
  if (response.status === 400) {
    const error = await response.text();
    throw new Error(error);
  }
  throw new Error("Network response was not ok.");
}

export function handleError(error) {
  console.error("API failed. " + error);
  throw error;
}

export function GetCountries() {
  const url = "/countries"
  return fetch(url, {
    method: "GET",
    credentials: "include",
  }).then(handleResponse).catch(handleError);
}

export function GetCities() {
  const url = "/cities"
  return fetch(url, {
    method: "GET",
    credentials: "include",
  }).then(handleResponse).catch(handleError);
}

export function GetRegions() {
  const url = "/regions"
  return fetch(url, {
    method: "GET",
    credentials: "include",
  }).then(handleResponse).catch(handleError);
}

function getAddressStructure() {
  return Promise.all([
    GetCountries(),
    GetCities(),
    GetRegions()
  ])
    .then((response) => {
      return {
        countries: response[0],
        cities: response[1],
        regions: response[2]
      };
    })
    .catch((error) => {
      return {
        countries: response[],
        cities: response[],
        regions: response[]
      }
    });
}

// this is how you can use it:
          getAddressStructure()
            .then((response) => {
              var apiResults = { };
              apiResults = { ...response};
              return resolve(apiResults);
            })

Answer 2

Ce que vous voulez réaliser, vous pouvez utiliser la fonction callback pour obtenir ce comportement sans utiliser de promesse.

async function getAddressStructure(country(args, getCities,getregioR)
{
    var countries = await getCountries():
    var cities= await getCities ():
    var regions = await  getRegion ();

    return { countries : countries, cities: cities, regions: regions}
}

async function getCountries ();
async function getCities() {}
async function getRegion () {}