Implementar un REST API con GitHub Copilot

https://jsonplaceholder.typicide.com es una pagina que ofrece varios tipos de respuestas en formato json para usar como placeholder

En VSCode para que nos de una recomendación de código con python iniciamos un comentario utilizando el signo # y al precionar enter nos da la recomendación de código para aceptar la recomendación utilizamos “Tab”.

Código python con Copilot

Esto sera maravilloso para web scrapping

Es increíble, me encanta lo que se puede hacer tan simplemente.

Código en Python:

import requests
import json

def consultar_api(url):
    response = requests.get(url)
    response.raise_for_status()  # Lanzar una excepción si hay un error en la solicitud
    result = response.json()
    return result

def procesar_datos(data):
    for row in data:
        for key, value in row.items():
            if isinstance(value, (int, float)):
                row[key] = 'ES NUMERICO'
    return data

def mostrar_tabla(data):
    html = '<table>'
    
    # Mostrar la fila de encabezado con los nombres de las columnas
    html += '<tr>'
    for column_name in data[0]:
        html += f'<th>{column_name}</th>'
    html += '</tr>'
    
    # Mostrar una fila por cada elemento del array
    for row in data:
        html += '<tr>'
        for value in row.values():
            html += f'<td>{value}</td>'
        html += '</tr>'
    
    html += '</table>'
    print(html)

# Ejemplo de uso
url = 'https://api.example.com/data'  # Reemplaza esto con la URL real de la API
try:
    data = consultar_api(url)
    data_procesada = procesar_datos(data)
    mostrar_tabla(data_procesada)  # Mostrar el resultado procesado en una tabla HTML
except requests.exceptions.RequestException as e:
    print('Error en la solicitud a la API:', e)

La IA generativa ha ayudado a democratizar la programación 🤖🦾. Muchas veces tenemos las ideas y la lógica pero no suficientes conocimientos en el lenguaje para llevarlos a cabo. Ahora plasmando las ideas en un prompt la IA nos ayuda a ser más productivos 🚀🔥✔

Es facinante, parece que lo hace por arte de magia

La version con javascript and un backend con express js:

const app = require("express")();

// Create a method to consume an online API and saves the information in an associative array
const getApiData = async (url) => {
  const response = await fetch(url);
  const data = await response.json();
  return data;
};

// Create a method that process the result of getApiData, and if detects numeric values then replace them with the string "ES NUMERICO"
const processApiData = (data) => {
  for (let i = 0; i < data.length; i++) {
    for (let key in data[i]) {
      if (typeof data[i][key] === "number") {
        data[i][key] = "ES NUMERICO";
      }
    }
  }
  return data;
};

// Create a constant function to convert an associative array to a html table
const arrayToTable = (data) => {
  let table = "<table>";
  table += "<tr>";
  for (let key in data[0]) {
    table += "<th>" + key + "</th>";
  }
  table += "</tr>";
  for (let i = 0; i < data.length; i++) {
    table += "<tr>";
    for (let key in data[i]) {
      table += "<td>" + data[i][key] + "</td>";
    }
    table += "</tr>";
  }
  table += "</table>";
  return table;
};

app.get("/", async (req, res) => {
  const data = await getApiData("https://jsonplaceholder.typicode.com/posts");
  res.send(arrayToTable(processApiData(data)));
});

// Port serving at 3000
app.listen(3000, () => {
  console.log("Server running at port 3000");
});

Pero Visual Studio siempre ha tenido el autocompletado.

Es esencial verificar cuidadosamente cada fragmento de código generado por GitHub Copilot, utilizando tanto tu conocimiento como tu experiencia." Recuerda que la validación es crucial para garantizar la calidad y la seguridad del código generado.

✅

Alguien mas tiene el prpblema que github copilot es demasiado lento ? 😅

Usé los mismos prompts en Chat GPT y estos fueron los resultados:

function consultarAPI($url) {
    // Realizar la solicitud HTTP a la API
    $ch = curl_init($url);
    curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
    $response = curl_exec($ch);
    curl_close($ch);
    
    // Decodificar la respuesta JSON en un array asociativo
    $result = json_decode($response, true);
    
    // Verificar si hubo un error en la solicitud
    if ($result === null) {
        throw new Exception('Error en la solicitud a la API: ' . curl_error($ch));
    }
    
    return $result;
}

function mostrarTabla($data) {
    echo '<table>';
    
    // Mostrar la fila de encabezado con los nombres de las columnas
    echo '<tr>';
    foreach (array_keys($data[0]) as $columnName) {
        echo '<th>' . $columnName . '</th>';
    }
    echo '</tr>';
    
    // Mostrar una fila por cada elemento del array
    foreach ($data as $row) {
        echo '<tr>';
        foreach ($row as $value) {
            echo '<td>' . $value . '</td>';
        }
        echo '</tr>';
    }
    
    echo '</table>';
}

function procesarDatos($data) {
    foreach ($data as &$row) {
        foreach ($row as &$value) {
            if (is_numeric($value)) {
                $value = 'ES NUMERICO';
            }
        }
    }
    return $data;
}

// Ejemplo de uso
$url = 'https://api.example.com/data'; // Reemplaza esto con la URL real de la API
try {
    $data = consultarAPI($url);
    $dataProcesada = procesarDatos($data);
    mostrarTabla($dataProcesada); // Mostrar el resultado procesado en una tabla HTML} catch (Exception $e) {
    echo 'Error: ' . $e->getMessage();
}

Aquí mi aporte, quise hacer un juego típico de generar un número random y hacer que el usuario lo adivine, si el número ingresado por el usuario no coincide, el programa le dice si es mayor o menor. El programa termina hasta que el usuario adivina el número random. Aquí el código generado por Github Copilot

# Crea un programa que genere un número aleatorio entre 1 y 100
# (sin mostrarlo) y después te pida que lo adivines. Si aciertas
# te felicitará y si no te dirá si el número es mayor o menor

import random

def run():
    number_found = False
    random_number = random.randint(1, 100)

    while not number_found:
        number = int(input('Intenta un número: '))

        if number == random_number:
            print('Felicidades. Encontraste el número')
            number_found = True
        elif number > random_number:
            print('El número es más pequeño')
        else:
            print('El número es más grande')


run()

Código en TypeScript:

import axios from 'axios';

async function consultarAPI(url: string) {
  const response = await axios.get(url);
  return response.data;
}

function procesarDatos(data: Record<string, any>[]) {
  return data.map(row => {
    const processedRow: Record<string, any> = {};
    for (const [key, value] of Object.entries(row)) {
      if (typeof value === 'number') {
        processedRow[key] = 'ES NUMERICO';
      } else {
        processedRow[key] = value;
      }
    }
    return processedRow;
  });
}

function mostrarTabla(data: Record<string, any>[]) {
  let html = '<table>';

  // Mostrar la fila de encabezado con los nombres de las columnas
  html += '<tr>';
  for (const columnName of Object.keys(data[0])) {
    html += `<th>${columnName}</th>`;
  }
  html += '</tr>';

  // Mostrar una fila por cada elemento del array
  for (const row of data) {
    html += '<tr>';
    for (const value of Object.values(row)) {
      html += `<td>${value}</td>`;
    }
    html += '</tr>';
  }

  html += '</table>';
  console.log(html);
}

// Ejemplo de uso
const url = 'https://api.example.com/data'; // Reemplaza esto con la URL real de la API
consultarAPI(url)
  .then((data) => {
    const dataProcesada = procesarDatos(data);
    mostrarTabla(dataProcesada); // Mostrar el resultado procesado en una tabla HTML
  })
  .catch((error) => {
    console.error('Error en la solicitud a la API:', error);
  });

Código en C#:

using System;
using System.Collections.Generic;
using System.Net;
using System.Net.Http;
using System.Text.Json;
using System.Threading.Tasks;

class Program
{
    static async Task Main(string[] args)
    {
        string url = "https://api.example.com/data"; // Reemplaza esto con la URL real de la API
        try
        {
            var data = await ConsultarAPI(url);
            var dataProcesada = ProcesarDatos(data);
            MostrarTabla(dataProcesada); // Mostrar el resultado procesado en una tabla HTML
        }
        catch (Exception ex)
        {
            Console.WriteLine($"Error en la solicitud a la API: {ex.Message}");
        }
    }

    static async Task<List<Dictionary<string, object>>> ConsultarAPI(string url)
    {
        using var client = new HttpClient();
        using var response = await client.GetAsync(url);
        response.EnsureSuccessStatusCode();
        var responseContent = await response.Content.ReadAsStringAsync();
        var data = JsonSerializer.Deserialize<List<Dictionary<string, object>>>(responseContent);
        return data;
    }

    static List<Dictionary<string, object>> ProcesarDatos(List<Dictionary<string, object>> data)
    {
        foreach (var row in data)
        {
            foreach (var key in row.Keys.ToList())
            {
                if (row[key] is int || row[key] is double)
                {
                    row[key] = "ES NUMERICO";
                }
            }
        }
        return data;
    }

    static void MostrarTabla(List<Dictionary<string, object>> data)
    {
        Console.WriteLine("<table>");

        // Mostrar la fila de encabezado con los nombres de las columnas
        Console.WriteLine("<tr>");
        foreach (var columnName in data[0].Keys)
        {
            Console.WriteLine($"<th>{columnName}</th>");
        }
        Console.WriteLine("</tr>");

        // Mostrar una fila por cada elemento del array
        foreach (var row in data)
        {
            Console.WriteLine("<tr>");
            foreach (var value in row.Values)
            {
                Console.WriteLine($"<td>{value}</td>");
            }
            Console.WriteLine("</tr>");
        }

        Console.WriteLine("</table>");
    }
}