No tienes acceso a esta clase

隆Contin煤a aprendiendo! 脷nete y comienza a potenciar tu carrera

Playground: Captura el error de una petici贸n

17/26

Aportes 110

Preguntas 15

Ordenar por:

驴Quieres ver m谩s aportes, preguntas y respuestas de la comunidad?

La idea de estas pruebas es muy buena, lo que deber铆a de mejorar son las instrucciones y no usar cosas que no se han indicado en el curso como el

throw new Error('API Not Found');

No se si aporte algo, pero el ejercicio trata de que dentro de la funci贸n runCode hagan el llamado a la api que no se encuentra y capturen el error. por defecto se ejecuta await runCode(), as铆 que hagan todo dentro de este.

Recordar tambi茅n que pueden utilizar fetch sin el import debido a que estamos en el browser y que los errores se pueden controlar con try/catch.

No he podido solucionar estos retos, es increible como al ver la solucion de repente todo es tan f谩cil.
Ni modo a seguir practicando y a leer m谩s c贸digo.
Si pueden recomendarme proyectos para practicar les voy a agradecer mucho.

鈥 estos retos, no te dejan en claro lo que tienes que hacer

Creo que el feature esta malo, ya llevo haciendo varias pruebas que estan correctas pero me dice que esta malo. y ni siquiera la solucion me la acepta
![](

export async function runCode() {
  const url = 'https://domain-api-com';
  try {
    return await fetch(url);
  } catch {
    throw new Error('API Not Found');
  }
}

Entend铆 la orden que ten铆a que ejecutar, pero a煤n no nos hab铆an dado la herramienta para devolver el error.
El ejercicio estuvo muy bueno estuve rato tratando de resolverlo con los console.
Al final vi la soluci贸n porque no lo pude resolver, igual creo que es culpa m铆a ten铆a que haber googleado, ya nos ense帽aron que tambi茅n es parte de programar.

throw new Error('API Not Found');

Creo que fue una 鈥淐ascara de banana鈥 馃槀馃槀馃槀

Mi solucion:

export async function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    const data = await fetch(url);
    const json = await data.json();
    return json;

  } catch (err) {
    throw new Error('API Not Found')
  }
}

Como vamos no se como realizarlo

Falto una mejor explicacion en la Guia del ejercicio.
donde mencione que no sirve el console.log()
sino un nuevo comando throw new Error()

Por aqui dejo mi respuesta

export async function runCode() {
  try {
    const ir = await fetch(url);
    console.log(ir);
  } catch (error) {
    console.error(error);
  }
  const url = 'https://domain-api-com';
}

no la pude hacer,!!! I`ll be bakc!!

Por q no comparar con then y con async await


const url = 'https://domain-api-com'; 
function fetchData(url){
    return fetch(url)
}

fetchData(url).then( response =>{console.log(response)})
.catch( err => console.log(err.msg ) )




async function runCode() {
    // Tu c贸digo aqu铆 馃憟
    const url = 'https://domain-api-com';
    try{
        const ok = await fetch(url);
        console.log(ok);
    }catch(error){
        console.error(error.msg);
    }
      
  }
  
  runCode()

les comparto mi Soluci贸n

export async function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  const response = await fetch(url);
  try {
    console.log(response.json())
  } catch {
    console.log('API No Found');
  }

}

Houston, we have a problem!
.
Podemos observar que los tests no pasan incluso con la soluci贸n dada por el Playground. Equipo Platzi, para que lo chequen

Les comparto mi solucion :) ```js export async function runCode() { const url = 'https://domain-api-com'; try { return await fetch(url); } catch (err) { console.log(err) throw new Error('API Not Found'); } } ```
const url = 'https://domain-api-com';

export function runCode(urlApi) {
  try {
    const products = fetchData(`${urlApi}/products`)
    console.log(products)
  }
  catch {
    throw new Error('API Not Found');
  };
}; 

Ayuda team Platzi, el playground no se esta ejecutando.

No creo que este bien la idea del problema, ya que es lo mismo si lo dejo asi:

export async function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  throw new Error('API Not Found');
}

creo que hubiera sido mejor usar la api fake para tener 2 resultados, uno que existe y otro que no

sigue con errores en los test pero confien en su codigo

Ahora si, mi solucion! checala solo si ya resolviste el tuyo o como minimo, trataste 馃槃
+
+
+
+
+
+
+
+
+
+
+

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  //llamamos a la api
  const getData = async (urlApi) => {
    try {
      const response = await fetch(urlApi);
      const data = response.json()

      console.log(data)
    } catch {
      throw new Error('API Not Found')
    }

  }
  return getData(url)
}

Como siempre lo hice mal XD hahaha, me lleva la que no me trajo :p 鈥 espero entender mejor estos enunciados en el futuro para cuando quiera presentarme a alg煤n lado o estar茅 valiendo. Aunque le voy entendiendo la din谩mica a estos ejercicios 馃槃 En este no tenia idea que exist铆a throw para los errores y aun me cuesta entender en general lo asincrono 馃槙

Me consto pero lo logre, sin dudas que tengo que seguir practicando estos temas. Les dejo mi solucion.
*
*
*
*
*
*
*
*
*

export function runCode() {
  const url = 'https://domain-api-com';
  const fn = async (urlApi) => {
    try {
      return await fetch(urlApi);
    } catch (error) {
      console.error('API No Found');
    }
  }
  return fn(url);
}
![](https://static.platzi.com/media/user_upload/image-a7af17d6-8d48-42b1-8f68-c6f070d7c541.jpg) les dejo mi aporte
```js export async function runCode() { const url = 'https://domain-api-com'; try { return await fetch(url) } catch { throw new Error('API Not Found') } } ```
```js export async function runCode() { // Tu c贸digo aqu铆 馃憟 const url = 'https://domain-api-com'; try { const response = await fetch(url) } catch { throw new Error("API Not Found") } } ```export async function runCode() { // Tu c贸digo aqu铆 馃憟 const url = 'https://domain-api-com'; try { const response = await fetch(url) } catch { throw new Error("API Not Found") } }
Mi souci贸n: `export function runCode() { const url = 'https://domain-api-com'; try { const urlApi = fetch(url); const data = urlApi.json(); console.log(data); } catch (error) { throw new Error('API Not Found'); console.error(error); }}`
Mi soluci贸n: export function runCode() { const url = 'https://domain-api-com'; try { const urlApi = fetch(url); const data = urlApi.json(); console.log(data); } catch (error) { throw new Error('API Not Found'); console.error(error); }}

reto

Les comparto mi suluci贸n, la verdad es que di demasiadas vueltas- `<`export async function runCode() {聽 聽 const url = 'https://domain-api-com';聽 聽 聽 try {聽 聽 聽 聽 return await fetch(url);聽 聽 聽 }聽 聽 聽 catch (error) {聽 聽 聽 聽 console.log(error)聽 聽 聽 聽 throw new Error('API Not Found');聽 聽 聽 聽 }聽 }`>`
Este fue mi c贸digo y al principio me marc贸 error, despu茅s, en lugar de transcribir el "throw new Error('API Not Found'), lo copie y pegu茅 en mi c贸digo y funcion贸 bien: ```js export function runCode() { // Tu c贸digo aqu铆 馃憟 const url = 'https://domain-api-com'; try { throw new Error('API Not Found'); } catch (error) { throw new Error('API Not Found'); } } ```
super, ya voy entendiendo la mecanina del async await, asi podre entender un codigo que vi en un repositorio y no he podido personalizar al no entender el asincronismo

Esta fue mi soluci贸n 馃憞:

export function runCode() {
  const url = 'https://domain-api-com';

  try {
    const response = fetch(url);
    const data = response.json();
    return data;
  } catch {
    throw new Error('API Not Found');
  }
}

A mi no me sirvi贸 lo intenete de todas las formas este test tiene un error

`export async function runCode() {` `聽 const url = 'https://domain-api-com';` `聽 try {` `聽 聽 const response = await fetch(url);` `聽 聽 const data = await response.json();` `聽 聽 return data;聽 ` ` } catch (e) {` `聽 聽 throw new Error('API Not Found');聽 ` ` }` `}`

Soluci贸n:

export function runCode() {
// Tu c贸digo aqu铆 馃憟
const url = 鈥https://domain-api-com鈥;

if (url) {
throw new Error(鈥楢PI Not Found鈥);
} else {
// Resto del c贸digo
}
}

try {
runCode();
} catch (error) {
console.error(鈥淓rror:鈥, error.mesagge);

}

Esta es la soluci贸n con la que di. saludos export async function runCode() { try { const url = 'https://domain-api-com'; const products = await fetchData(`${url}/products`); const product = await fetchData(`${url}/products/1`); const category = await fetchData(`${url}/categories/1`); console.log(products); console.log(product); console.log(category); } catch (error) { throw new Error('API Not Found'); } } Este c贸digo primero intenta conectarse a la API en la URL `https://domain-api-com`. Si la conexi贸n es exitosa, el c贸digo recupera los productos, el producto y la categor铆a de la API y los registra en la consola. Sin embargo, si la conexi贸n falla, el c贸digo captura el error y lanza un nuevo error con el mensaje `API Not Found`.
Posible respuesta `export async function runCode() {` ` try {` ` const url = 'https://domain-api-com'; // Reemplaza esta URL con la URL real de la API` ` const response = await fetch(url); // Realiza la solicitud a la API (usando fetch en este ejemplo)` ` if (!response.ok) {` ` throw new Error('API Not Found'); // Lanza un error si la respuesta de la API no es exitosa` ` }` ` // Si la respuesta es exitosa, contin煤a con el c贸digo aqu铆` ` // Por ejemplo, puedes parsear la respuesta JSON si la API devuelve datos JSON` ` // const data = await response.json();` ` // Realiza otras operaciones con los datos obtenidos de la API si es necesario` ` } catch (error) {` ` throw new Error('API Not Found');` ` }` `}`
Aqu铆 dejo mi respuesta ![](https://static.platzi.com/media/user_upload/image-0869a4e1-4bc1-4c57-9a58-71f93707c46f.jpg)

El desaf铆o es un tanto ambiguo puesto que se帽ala que la soluci贸n de nuestro c贸digo debe de ir dentro del bloque de la funci贸n runCode() pasando desapercibido async en la declaraci贸n de la funci贸n. Adem谩s que el uso de fetch no esta explicito para usarlo como soluci贸n ya que durante el curso paso por una instalaci贸n y configuraci贸n

Aqui mi solucion:

export async function runCode() {
  const url = 'https://domain-api-com';
  try {
    return await fetch(url);
  } catch (error) {
    throw new Error('API Not Found');
  }
}

Creo que hay algo mal con la ejecuci贸n de los Playgrounds ya que, la primera vez que corr铆 el c贸digo me solt贸 un error y la segunda ocasi贸n me lo acept贸 y no cambie nada en mi c贸digo

Les dejo mi soluci贸n.

*篓

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    const response = fetch(url);
    const data = response.json();
    return data;
  } catch (error) {
    throw new Error('API Not Found');
  }
}

El ejercicio presenta error, se queda tildado y no pasa el test

SOLUCI脫N
*
*
*
*
*
*
*
*
*


export async function runCode() {

  const url = 'https://domain-api-com';

  try {

    await fetch(url);

  } catch {

    throw new Error('API Not Found');

  }

};

馃敟 Parece chiste pero es an茅cdota

Aparte de solucionar el problema propuesto, tengo que ser adivino para entender como ejecutar el c贸digo en este editor. 馃槬

Mi soluci贸n

import fetch from "node-fetch";
// const API = 'https://api.escuelajs.co/api/v1'
const API = 'https://domain-api-com';

const x = async () => {
	try {
		//const response = await fetch(`${API}/products`);
		const response = await fetch(API);
		const data = await response.json();
		console.log(data[0]);
	} catch (e) {
		console.error(e);
	}
}

x();

Lo que piden鈥

export async function runCode() {
  const url = 'https://domain-api-com';
  try {
    return await fetch(url);
  } catch {
    throw new Error('API Not Found'); 馃敟馃馃槩
  }
}

Excelente la idea de estos sandbox, aunque creo que la implementaci贸n tiene que seguir iterando. Ahora, para los que hacen el reto en sus IDE, si all谩 les sale bien y ac谩 no, no se frustren, lo importante es que ya lo tienen bien all谩 y no se estanquen, sigan con el curso.

Yo me complique varios minutos, como 20, esperando lograr que en la vista, al dar clic en Run Code, me diera el output esperado. Luego me di cuenta que con solo poner el siguiente codigo y ejecutar las pruebas, ya pasaba de forma exitosa.

En este ejercicio la pesta帽a de vista me tenia perdido. No se dejen guiar por esa pesta帽a鈥 este ejercicio si estaba confuso.

export async function runCode() {
    throw new Error('API Not Found');  
}

Este playground tiene algunas fallas todavia. Por ejemplo en el mensaje del error pedia que mostrara

throw new Error('API Not Found') //como ven el 'API' est谩 en mayusculas, si no lo ponen as铆 les saldr谩 error.

yo lo estaba poniendo en minuscula y por eso no me funcionaba.
Ademas, la funcion sabemos que es async, entonces hay que agregarle el async despues del export.

export async function runCode() { //agregamos el async 
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
   return await fetch(url) //como es una funcion async debemos usar 'await' y retornar lo que venga.
  } catch {
    throw new Error('API Not Found') //'throw' ya retorna un valor, que en este caso es el error, por ende no usamos la palabra return
  }
}
export function runCode() {
  const url = 'https://domain-api-com';

  try {
    const response = fetch(url);
    const data = response.json();
    return data;

  }
  catch {
    throw new Error('API Not Found');
  }
}

He aqu铆 mi respuesta
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export async function runCode() {
  const url = 'https://domain-api-com';

  try {
    const response = await fetch(url);
    const data = response.json();
    return data;

  } catch {
    throw new Error('API Not Found');
  }
  
}

Ni yo se porque funciono, pero por si a alguien le sirve:

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  try {
    const url = fetch('https://domain-api-com');
    return url.json()
  } catch {
    throw new Error ("API Not Found")
}
  
  
}

No s茅 si est茅 en lo correcto pero mi soluci贸n fue as铆鈥 no con el input que se define en la gu铆a.

Hola, estuve un buen tiempo tratando de ver como podr铆a solucionar este playground, y as铆 fue como pude hacerlo:

export async function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    await fetch(url);
  } catch (error) {
    throw new Error('API Not Found');
  }
}

Esta fue mi soluci贸n al reto 馃挌 (nota para Platzi, me costo mucho que la pagina aceptara mi respuesta se tardaba mas de 10 minutos en responder y la opci贸n de vista no serv铆a incluso al recargar la p谩gina varias veces)



Ac谩 pueden probar el c贸digo:

// Soluci贸n al reto PlayGrounds
export async function runCode() {
  const url = 'https://domain-api-com';
  try {
    const response = await fetch(url)
    return response;
  } catch {
    throw new Error('API Not Found');
  }
}

Mi soluci贸n

Mi soluci贸n:

export async function runCode() {
  try {
    const url = 'https://domain-api-com'
    const response = await fetch(url).json()
    return response
  } catch (err) {
    throw new Error("API Not Found")
  }
}

馃崈En primer lugar, vamos a necesitar hacer una petici贸n a la API que no existe. Para esto, vamos a utilizar la funci贸n fetch y la url de la API.

Dentro de la funci贸n fetch, vamos a utilizar un try/catch para capturar cualquier error que pueda ocurrir. En caso de que ocurra un error, vamos a lanzar una excepci贸n con el mensaje 鈥淎PI Not Found鈥.

Finalmente, vamos a envolver todo el c贸digo dentro de la funci贸n runCode y usar async/await para esperar la ejecuci贸n de la funci贸n fetch.

C贸digo:

async function runCode() {
  try {
    const response = await fetch('https://api.notfound.co');
    const data = await response.json();
    return data;
  } catch (error) {
    throw new Error('API Not Found');
  }
}

Explicacion como la url no funciona va a dar error y try/catch es concepto para manejar errores algo similar a las promesas, sin usar esto el codigo se detendria si hay un fallo, cuando hay un fallo se ejecuta el catch, resolviendo el playground

export function runCode() {
    try {
      const url = 'https://domain-api-com';
      const datos = (fetch(url)).json();
    } catch {
      throw new Error('API Not Found');
    }
  }
const anotherFn = async (urlApi) => {
  try {
    const data = await fetchData(urlApi)
    console.log(data)
  } catch (error) {
    throw new Error('API Not Found');
  }
}

const fetchData = async (urlApi) => {
  const response = await fetch(urlApi)
  return await response.json();
}

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';

  return anotherFn(url);
}

creo que este ejercicio deber铆a tener una mejor explicaci贸n
hasta ahora todos han sido muy claros pero este no
solo con lanzar la el error dentro de la funci贸n basta para pasarlo por lo que ya sea que llames a la url fake o no no importa, tambi茅n el usar el try catch no tiene mucho sentido ya que si la respuesta requiere que lances el error, al ver que en las instrucciones me dicen que cache el error es muy contra intuitivo tener que lanzarlo ahi mismo, mi primera idea fue regresar el error dentro del catch, pero lanzarlo dentro del try para que pueda ser controlado

en resumen muy mal explicado este ejercicio

La letra de la parte de la guia deber铆a ser un poco mas grande es muy peque帽a y cansa mucha la vista 馃槮

dejo mi soluci贸n por aqu铆
.
.
.
.
.
.
.
.
.
.
.
.
.
.

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  async function conectar(url) {
    try {
      await fetch(url);
    } catch (error) {
      throw new Error('API Not Found');
    }
  }
  return conectar(url)
}

Comparto mi soluci贸n:

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    fetch(url).json();
  }
  catch(error) { 
    throw new Error('API Not Found')
  }
}

Se demor贸 m谩s de 5 min en correr =(

Gente! ES2019 introdujo el 鈥淥ptional Catch Binding鈥, significa que los parentesis con el error luego de la sentencia catch ya no son necesarios, es por eso que en la prueba se usa el 鈥渢hrow new Error(鈥淎PI Not Found鈥)鈥

catch {
    throw new Error("API Not Found")
  }

No se si me la compliqu茅 demasiado pero lo hice as铆:

export async function runCode() {
  const url = 'https://domain-api-com';
  try {
    const response = await fetch(url);
    const data = response.json();
    return data;
  } catch {
    throw new Error("API Not Found")
  }
}

buen d铆a dejo mi soluci贸n!!!

const url = 'https://domain-api-com';

async function fetchdata(urlApi) {
  const response = await fetch(urlApi);
  const data = await response.json();
  return data;
}

export async function runCode() {
  // Tu c贸digo aqu铆 馃憟
    try {
    const prueba = await fetchdata(`${url}`);
    console.log(prueba);
  } catch (error) {
    throw new Error('API Not Found');
  }
}

Me parece, muy buen aporte lo de los tests, mas alla de las correcciones que pueda tener ,he ir mejorando en el enunciado para mayor claridad鈥 ; en varias plataformas en que realizas test , o para postulaciones a trabajos a mi criterio veo estas mismas " faltas de claridad" en la explicaci贸n del test ( tal vez hasta pueden ser a prop贸sito para verificar que entiendes los conceptos? ) , por eso veo importante el aporte del profe Nico y Oscar al agregar esto ya que te ponen contacto casos reales resolver. Recuerdo en la facultad que para ciertas materias por mas que hubieses 鈥渆studiado鈥 los temas, si no hab铆as practicado con ex谩menes anteriores era dif铆cil de aprobar鈥 ; gracias por este aporte!

Mi solucion al reto:

export async function runCode() {
  try {
    const response = await fetch('https://domain-api-com');
    const data = await response.json();
    return data;
  } catch (error) {
    throw new Error('API Not Found');
  }
}

tiene error el test

me dice que error de sintaxis en el await

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    await fetch(url);
  } catch (e) {
    throw new Error('API Not Found');
  }
}

Hola, les dejo mi soluci贸n y, tambi茅n una pista. La funci贸n que se exporta (runCode()) tiene que ser async. Por otro lado, concuerdo con mis compa帽eros en que se tiene que mejorar las instrucciones, me cost贸 mucho la verdad inferir la soluci贸n :
.
.
.
.
.

export async function runCode() {
  const url = 'https://domain-api-com';
  try {
    const response = await fetch(url);
    const data = await response.json();
    return data
  } catch (error) {
    throw new Error('API Not Found');
  }  
}

version modernizada

export const runCode = async () => {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    const response = await fetch(url);
    const data = await response.json;
  } catch (err) {
    throw new Error('API Not Found');
  }
}

export async function runCode() {
// Tu c贸digo aqu铆 馃憟
const url = 鈥https://domain-api-com鈥;

try {
const response = await fetch(url);
const data = await response.json();
return data;
}
catch {
throw new Error(鈥楢PI Not Found鈥);
}
}

import fetch from 'node-fetch';

const API = "https://api.escuelajs.co/api/v1"

const fetchData =  async (urlApi)=>{
    try { 
        const data= await fetch(urlApi)
        const dataUsable = await data.json()
        return dataUsable
        
    } catch (error) {
        console.log( "que estupido fu铆 " + error)
        
    }
   
// LOS AWAIT SOLO SE PUEDEN USAR DENTRO DE UNA FUNI脫N ASINCRONA
}

console.log( await fetchData(`${API}/products`))

// O COMO LLAMADO A UNA FUNCI麓N ASINCRONA
export async function runCode() {
  try {
    const response = await fetch("https://domain-api-com");
  } catch (error) {
    throw new Error('API Not Found');
  }
}

export async function runCode() {
try {
const url = 鈥https://domain-api-com鈥;
const response = await fetch(url);
const data = await response.json();
return data;
} catch {
throw new Error(鈥楢PI Not Found鈥);
}
}

Yo lo hice de esta forma

Las instrucciones son confusas e incluyen tem谩ticas, elementos y/o sintaxis avanzadas que no se han visto en lo que va del curso. This is a very frustrating shit! ={

Consejo, modificaria las pruebas que corren para que validen que efectivamente estamos usando la funcion fetch()

yo solo escribi esto y anduvo

throw new Error(鈥楢PI Not Found鈥);

Pens茅, 驴para que voy a llamar a algo que no existe? lanzo el error y listo

export async function runCode() {
  const url = 'https://domain-api-com';
  try {
    const response = await JSON(fetch(url));
    return response;
   } catch (err) { 
    throw new Error('API Not Found');
  }

}

Mal curso, dos videos cortos de youtube me han hecho entender m谩s de que lo que llevo de curso.

export function runCode() {
  const url = 'https://domain-api-com';
  try {
    return fetch(url).json();
  } catch (err) {
    throw new Error('API Not Found');
  }
}

Tenia la idea y pues me ayudo a entender mejor. A seguir praticando no hay mas!

El primero q me sale

export async function runCode() {
  // Tu c贸digo aqu铆 馃憟

  try {

    const url = 'https://domain-api-com';

    const response = await fetch(url);
    const data = await response.json();
    return data;

  } catch {
    throw new Error('API Not Found');
  }


}

Mi soluci贸n

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    return fetch(url).catch(error => {
      throw new Error('API Not Found')
    })
  } catch (error) {
    throw new Error('API Not Found')
  }
}

Les dejo mis soluci贸nes. La primera con .then() y .catch() y la segunda con await y async tal como pide la consigna:
*
*
*
*
*
*
*
*
*
*
*
*

// Dos soluciones:
import fetch from "node-fetch";

// Con then: 
const url = 'https://domain-api-com'; 
function fetchData(url){
    return fetch(url)
}

fetchData(url)
    .then( response =>{console.log(response)})
    .catch( () => {
        throw new Error('API Not Found')
    });

// ---------------------------------------------    
// Con await y async:
import fetch from "node-fetch";

async function runCode() {
    const url = 'https://domain-api-com';
    try{
        const data = await fetch(url);
        console.log(data);
    }catch(error){
        throw new Error('API Not Found');
    }
  }

runCode()

Reto Solucionado

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';

  const fetchData = async(urlApi) => {
    try {
      const callApi = await fetch(urlApi)
    } catch {
      throw new Error('API Not Found')
    }
  }

  return fetchData(url)
}

aahhg yo iba a modificar el export function y agregarle el async, pero me como dec铆a que mi c贸digo ten铆a que ir dentro, no lo hice! que falla.

export async function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    const response = await fetch(url);
    const data = response.json()

    return data
  } catch { 
    throw new Error('API Not Found');
  }
}

mi humilde aporte desde visual

const url = 'https://domain-api-com';
const anotherFunction2 = async(urlApi) => {
    try {
        const example = await fetchData(`${urlApi}`);
        console.log(example);
    } catch(error) {
        throw new Error('API Not Found')
    }
    }

anotherFunction2(url);

throw new Error(鈥楢PI Not Found鈥)
^

Error: API Not Found

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  try {
    const data = fetch(url);
    const data2 = data.json();

  }

  catch (error) {
    throw new Error('API Not Found');
  }
  
}

SOLUCION CON FETCH Y PRACTICANDO PARA CONVERTI EL API EN UN .JSON AUNQUE ESA LINEA NO ES NECESARIA

Soluci贸n:

Me cost贸 bastante llegar a la soluci贸n, ya que para m铆 la gu铆a no esta muy bien detallada y no estaba seguro si se podia agregar el async a la funcion runCode. De todas formas fue un buen ejercicio.

Me gust贸 el ejercicio, estar铆a muy bien que dejasen declarado de alg煤na forma que 鈥渇etchData鈥 ya fu茅 declarado, del resto excelente!

Agradecido con esta metodolog铆a! pero hay que seguir mejorando el funcionamiento del playground, se tilda o no es claro si quiero correr mi c贸digo o corre solo, las instrucciones tampoco son las m谩s acertadas

Les recomiendo este video de Youtube (en ingles) para mas ejercicios, es muy buen canal!

https://www.youtube.com/watch?v=dIOhHgreIbE

Comparto mi soluci贸n:

export async function runCode() {
  const url = 'https://domain-api-com';
  try {
    const response = await fetch(url)
    console.log(response.json())
  } catch {
    throw new Error('API Not Found');
  }
}

Creo que el throw new Error(''); no lo hemos visto en clases, o yo no lo vi, y eso hace que el ejercicio sea complejo para los que recien estamos entrando en tema.

Les comparto mi soluci贸n, creo que hice dem谩s en crear otra funci贸n, pero fue lo que pens茅 mas r谩pido, antes de ver las respuestas de otros compa帽eros me di cuenta de lo que pod铆a haber hecho, pero creo que llegamos a lo mismo jejeje

export function runCode() {
  // Tu c贸digo aqu铆 馃憟
  const url = 'https://domain-api-com';
  const otherFn = async (urlApi) => {
    try {
      const response = await fetch(urlApi)
    } catch (error) {
      throw new Error('API Not Found')
    }
  }
  return otherFn(url)
}
undefined