El manual de Deno: una introducción concisa a Deno

Ponte en marcha rápidamente con Deno, una alternativa moderna a Node.js

Exploro nuevos proyectos cada semana y es raro que alguno llame mi atención tanto como lo hizo Deno.

¿Qué es Deno?

Si conoces Node.js, el popular ecosistema de JavaScript del lado del servidor, entonces Deno es como Node, excepto que ha sido mejorado profundamente en muchos aspectos.

Comenzamos con una lista rápida de las características que más me gustan de Deno:

• Se basa en características modernas del lenguaje JavaScript.
• Tiene una amplia biblioteca estándar.
• Tiene TypeScript en su núcleo, lo que aporta una gran ventaja en muchos sentidos diferentes, incluido un soporte de TypeScript de primera clase (no es necesario compilar TypeScript por separado, Deno lo hace automáticamente).
• Abarca módulos ES
• No tiene gestor de paquetes
• Tiene una calidad de primeraawait
• Tiene una instalación de prueba incorporada.
• Su objetivo es ser compatible con el navegador tanto como sea posible, por ejemplo, proporcionando un objeto integrado fetchy global.window

Exploraremos todas esas características en esta guía.

Después de usar Deno y aprender a apreciar sus características, Node.js parecerá algo antiguo.

Especialmente porque la API de Node.js se basa en devoluciones de llamadas, ya que se escribió mucho antes de las promesas y async/await. No hay cambios implementados para eso en Node, ya que un cambio de ese tipo sería monumental, por lo que estamos limitados a las devoluciones de llamadas oa las llamadas a la API que prometen.

Node.js es fantástico y seguirá siendo el estándar de facto en el mundo de JavaScript, pero creo que gradualmente veremos que Deno se adopta cada vez más debido a su compatibilidad de primera clase con TypeScript y su biblioteca estándar moderna.

Deno puede permitirse el lujo de tener todo escrito con tecnologías modernas, ya que no hay compatibilidad con versiones anteriores que mantener. Por supuesto, no hay garantía de que en una década ocurra lo mismo con Deno y surja una nueva tecnología, pero esa es la realidad en este momento.

¿Por qué Deno? ¿Por qué ahora?

Deno fue anunciado hace casi 2 años por el creador original de Node.js, Ryan Dahl, en JSConf EU. Mira el video de YouTube de la charla, es muy interesante y es una visita obligada si estás involucrado con Node.js y JavaScript en general.

Todo director de proyecto debe tomar decisiones. Ryan lamentó algunas de las primeras decisiones que tomó en Node. Además, la tecnología evoluciona y hoy JavaScript es un lenguaje totalmente diferente de lo que era en 2009, cuando comenzó Node. Piense en las características modernas de ES6/2016/2017, etc.

Entonces comenzó un nuevo proyecto para crear una especie de segunda ola de aplicaciones del lado del servidor impulsadas por JavaScript.

La razón por la que estoy escribiendo esta guía ahora y no en aquel entonces es porque las tecnologías necesitan mucho tiempo para madurar. Y finalmente hemos llegado a Deno 1.0 (la versión 1.0 debería lanzarse el 13 de mayo de 2020), la primera versión de Deno declarada oficialmente estable.

Puede que parezca solo un número, pero 1.0 significa que no habrá cambios importantes hasta Deno 2.0, lo cual es muy importante cuando te sumerge en una nueva tecnología: no quieres aprender algo y que luego cambie demasiado rápido.

¿Deberías aprender Deno?

Esa es una gran pregunta.

Aprender algo nuevo como Deno es un gran esfuerzo. Mi sugerencia es que si estás empezando ahora con JS del lado del servidor y aún no conoces Node, y nunca escribiste nada con TypeScript, comienzas con Node.

Nadie fue despedido nunca por elegir Node.js (parafraseando una cita común).

Pero si te encanta TypeScript, no depende de un montón de paquetes npm en tus proyectos y quieres usarlo awaiten cualquier lugar, entonces Deno podría ser lo que estás buscando.

¿Reemplazarás a Node.js?

No. Node.js es una tecnología gigante, bien establecida y con un excelente soporte que se mantendrá durante décadas.

Compatibilidad con TypeScript de primera clase

Deno está escrito en Rust y TypeScript, dos de los lenguajes que hoy en día están creciendo realmente rápido.

En particular, estar escrito en TypeScript significa que obtenemos muchos de los beneficios de TypeScript incluso si recomendamos escribir nuestro código en JavaScript simple.

Y ejecutar código TypeScript con Deno no requiere un paso de compilación: Deno lo hace automáticamente por usted.

No estás obligado a escribir en TypeScript, pero el hecho de que el núcleo de Deno esté escrito en TypeScript es enorme.

En primer lugar, un porcentaje cada vez mayor de programadores de JavaScript adoran TypeScript.

En segundo lugar, las herramientas que utilizan pueden inferir mucha información sobre el software escrito en TypeScript, como Deno.

Esto significa que mientras codificamos en VS Code, por ejemplo, que obviamente tiene una integración estrecha con TypeScript ya que ambos se desarrollan en Microsoft, podemos obtener beneficios como la verificación de tipos mientras escribimos nuestro código y funciones avanzadas de IntelliSense. En otras palabras, el editor puede ayudarnos de una manera muy útil.

Similitudes y diferencias con Node.js

Dado que Deno es básicamente un reemplazo de Node.js, es útil comparar los dos directamente.

Similitudes:

• Ambos están desarrollados sobre el motor V8 Chromium.
• Ambos son excelentes para desarrollar el lado del servidor con JavaScript.

Diferencias:

• Node está escrito en C++ y JavaScript. Deno está escrito en Rust y TypeScript.
• Node tiene un administrador de paquetes oficial llamado npm. Deno no lo tiene y, en su lugar, permite importar cualquier módulo ES desde URL.
• Node utiliza la sintaxis CommonJS para importar paquetes. Deno utiliza módulos ES, la forma oficial.
• Deno utiliza características modernas de ECMAScript en todas sus API y biblioteca estándar, mientras que Node.js utiliza una biblioteca estándar basada en devoluciones de llamadas y no tiene planes de actualizarla.
• Deno ofrece una capa de seguridad de sandbox a través de permisos. Un programa solo puede acceder a los permisos establecidos para el ejecutable como indicadores por el usuario. Un programa Node.js puede acceder a todo lo que el usuario pueda acceder.
• Deno lleva mucho tiempo considerando la posibilidad de compilar un programa en un ejecutable que se pueda ejecutar sin dependencias externas, como Go, pero todavía no es una posibilidad. Eso sería un cambio radical.

Sin gestor de paquetes

No tener un gestor de paquetes y tener que depender de URL para alojar e importar paquetes tiene sus pros y sus contras. Me gustan muchas las ventajas: es muy flexible, podemos crear paquetes sin publicarlos en un repositorio como npm.

Creo que surgirá algún tipo de administrador de paquetes, pero aún no hay nada oficial.

El sitio web de Deno proporciona alojamiento de código (y, por lo tanto, distribución a través de URL) a paquetes de terceros: https://deno.land/x/

Instalar Deno

¡Basta de hablar! Vamos a instalar Deno.

La forma más fácil es utilizar Homebrew:

brew install deno

Una vez hecho esto, tendrás acceso al denocomando. Aquí tienes la ayuda que puedes obtener usando deno --help:

flavio@mbp~ deno --helpdeno 0.42.0A secure JavaScript and TypeScript runtimeDocs: https://deno.land/std/manual.mdModules: https://deno.land/std/ https://deno.land/x/Bugs: https://github.com/denoland/deno/issuesTo start the REPL, supply no arguments: denoTo execute a script: deno run https://deno.land/std/examples/welcome.ts deno https://deno.land/std/examples/welcome.tsTo evaluate code in the shell: deno eval "console.log(30933 + 404)"Run 'deno help run' for 'run'-specific flags.USAGE: deno [OPTIONS] [SUBCOMMAND]OPTIONS: -h, --help Prints help information -L, --log-level log-level Set log level [possible values: debug, info] -q, --quiet Suppress diagnostic output By default, subcommands print human-readable diagnostic messages to stderr. If the flag is set, restrict these messages to errors. -V, --version Prints version informationSUBCOMMANDS: bundle Bundle module and dependencies into single file cache Cache the dependencies completions Generate shell completions doc Show documentation for a module eval Eval script fmt Format source files help Prints this message or the help of the given subcommand(s) info Show info about cache or info related to source file install Install script as an executable repl Read Eval Print Loop run Run a program given a filename or url to the module test Run tests types Print runtime TypeScript declarations upgrade Upgrade deno executable to newest versionENVIRONMENT VARIABLES: DENO_DIR Set deno's base directory (defaults to $HOME/.deno) DENO_INSTALL_ROOT Set deno install's output directory (defaults to $HOME/.deno/bin) NO_COLOR Set to disable color HTTP_PROXY Proxy address for HTTP requests (module downloads, fetch) HTTPS_PROXY Same but for HTTPS

Los comandos de Deno

Observe la SUBCOMMANDSsección de ayuda que enumera todos los comandos que podemos ejecutar. ¿Qué subcomandos tenemos?

• bundleAgrupar módulos y dependencias de un proyecto en un solo archivo
• cachealmacenar en caché las dependencias
• completionsgenerar terminaciones de shell
• docmostrar documentación de un módulo
• evalpara evaluar un fragmento de código, por ejemplodeno eval "console.log(1 + 2)"
• fmtun formateador de código incorporado (similar al gofmtde Go)
• helpImprime este mensaje o la ayuda del subcomando(s) indicado(s)
• infoMostrar información sobre el caché o información relacionada con el archivo de origen
• installInstalar script como ejecutable
• replLectura-evaluación-impresión-bucle (predeterminado)
• runEjecutar un programa dado un nombre de archivo o URL al módulo
• testejecutar pruebas
• typesDeclaraciones TypeScript en tiempo de ejecución de impresión
• upgradeActualizar denoa la versión más nueva

Puede ejecutar deno subcommand helppara obtener documentación adicional específica para el comando, por ejemplo deno run --help.

Como dice la ayuda, podemos usar este comando para iniciar un REPL (Read-Execute-Print-Loop) denosin ninguna otra opción.

Esto es lo mismo que correr deno repl.

Una forma más común de utilizar este comando es ejecutar una aplicación Deno contenida en un archivo TypeScript.

Puede ejecutar .tsarchivos TypeScript ( ) o .jsarchivos JavaScript ( ).

Si no está familiarizado con TypeScript, no se preocupe: Deno está escrito en TypeScript, pero puede escribir sus aplicaciones “cliente” en JavaScript.

Mi tutorial de TypeScript te ayudará a comenzar a trabajar rápidamente con TypeScript si lo deseas.

Tu primera aplicación Deno

Ejecutemos una aplicación Deno por primera vez.

Lo que me parece sorprendente es que ni siquiera tienes que escribir una sola línea: puedes ejecutar un comando desde cualquier URL.

Deno descarga el programa, lo compila y luego lo ejecuta:

Por supuesto, ejecutar código arbitrario desde Internet no es una práctica generalmente recomendable. En este caso, lo estamos ejecutando desde el sitio oficial de Deno, además de que Deno tiene un entorno limitado que evita que los programas hagan algo que no desea permitir. Más sobre esto más adelante.

Este programa es muy sencillo, solo una console.log()llamada:

console.log('Welcome to Deno ')

Si abre la URL https://deno.land/std/examples/welcome.ts con el navegador, verá esta página:

Es extraño, ¿verdad? Probablemente esperarías un archivo TypeScript, pero en lugar de eso tenemos una página web. La razón es que el servidor web del sitio web de Deno sabe que estás usando un navegador y te ofrece una página más fácil de usar.

Descargue el mismo UR usando wgetpor ejemplo, que solicita la text/plainversión del mismo en lugar de text/html:

Si desea ejecutar el programa nuevamente, ahora está almacenado en caché por Deno y no es necesario descargarlo nuevamente:

Puedes forzar una recarga de la fuente original con la --reloadbandera:

deno runTiene muchas opciones diferentes que no se enumeraron en el deno --help. En su lugar, debe ejecutar deno run --helppara revelarlas:

flavio@mbp~ deno run --helpdeno-runRun a program given a filename or url to the module.By default all programs are run in sandbox without access to disk, network orability to spawn subprocesses. deno run https://deno.land/std/examples/welcome.tsGrant all permissions: deno run -A https://deno.land/std/http/file_server.tsGrant permission to read from disk and listen to network: deno run --allow-read --allow-net https://deno.land/std/http/file_server.tsGrant permission to read whitelisted files from disk: deno run --allow-read=/etc https://deno.land/std/http/file_server.tsUSAGE: deno run [OPTIONS] SCRIPT_ARG...OPTIONS: -A, --allow-all Allow all permissions --allow-env Allow environment access --allow-hrtime Allow high resolution time measurement --allow-net=allow-net Allow network access --allow-plugin Allow loading plugins --allow-read=allow-read Allow file system read access --allow-run Allow running subprocesses --allow-write=allow-write Allow file system write access --cached-only Require that remote dependencies are already cached --cert FILE Load certificate authority from PEM encoded file -c, --config FILE Load tsconfig.json configuration file -h, --help Prints help information --importmap FILE UNSTABLE: Load import map file Docs: https://deno.land/std/manual.md#import-maps Specification: https://wicg.github.io/import-maps/ Examples: https://github.com/WICG/import-maps#the-import-map --inspect=HOST:PORT activate inspector on host:port (default: 127.0.0.1:9229) --inspect-brk=HOST:PORT activate inspector on host:port and break at start of user script --lock FILE Check the specified lock file --lock-write Write lock file. Use with --lock. -L, --log-level log-level Set log level [possible values: debug, info] --no-remote Do not resolve remote modules -q, --quiet Suppress diagnostic output By default, subcommands print human-readable diagnostic messages to stderr. If the flag is set, restrict these messages to errors. -r, --reload=CACHE_BLACKLIST Reload source code cache (recompile TypeScript) --reload Reload everything --reload=https://deno.land/std Reload only standard modules --reload=https://deno.land/std/fs/utils.ts,https://deno.land/std/fmt/colors.ts Reloads specific modules --seed NUMBER Seed Math.random() --unstable Enable unstable APIs --v8-flags=v8-flags Set V8 command line options. For help: --v8-flags=--helpARGS: SCRIPT_ARG... script args

Ejemplos de código de Deno

Además del que ejecutamos anteriormente, el sitio web de Deno proporciona otros ejemplos que puedes consultar: https://deno.land/std/examples/ .Te recomendamos Aprender a programar con ejemplos

Al momento de escribir estas líneas podemos encontrar:

• cat.tsImprima el contenido de una lista de archivos proporcionados como argumentos.
• catj.tsImprima el contenido de una lista de archivos proporcionados como argumentos.
• chat/una implementación de un chat
• colors.tsUn ejemplo de
• curl.tsUna implementación sencilla curlque imprime el contenido de la URL especificada como argumento.
• echo_server.tsun servidor eco TCP
• gist.tsun programa para publicar archivos en gist.github.com
• test.tsun conjunto de pruebas de muestra
• welcome.tsUna declaración console.log simple (el primer programa que ejecutamos arriba)
• xeval.tspermite ejecutar cualquier código TypeScript para cualquier línea de entrada estándar recibida. Antes se conoció como deno xevalpero se eliminó del comando oficial.

Tu primera aplicación Deno (de verdad)

Vamos a escribir algo de código.

La primera aplicación Deno que ejecutaste deno run https://deno.land/std/examples/welcome.tsfue una aplicación que otra persona escribió, por lo que no viste nada con respecto a cómo se ve el código Deno.

Comenzaremos con la aplicación de ejemplo predeterminada que aparece en el sitio web oficial de Deno:

import { serve } from 'https://deno.land/std/http/server.ts'const s = serve({ port: 8000 })console.log('https://localhost:8000/')for await (const req of s) { req.respond({ body: 'Hello Worldn' })}

Este código importa la servefunción del http/servermódulo. ¿Ves? No tenemos que instalarla primero y tampoco se almacena en tu máquina local como sucede con los módulos de Node. Esta es una de las razones por las que la instalación de Deno fue tan rápida.

Al importar desde https://deno.land/std/http/server.tsse importa la última versión del módulo. Puedes importar una versión específica usando @VERSION, de la siguiente manera:

import { serve } from 'https://deno.land/[email protected]/http/server.ts'

La servefunción se define así en este archivo:

/** * Create a HTTP server * * import { serve } from "https://deno.land/std/http/server.ts"; * const body = "Hello Worldn"; * const s = serve({ port: 8000 }); * for await (const req of s) { * req.respond({ body }); * } */export function serve(addr: string | HTTPOptions): Server { if (typeof addr === 'string') { const [hostname, port] = addr.split(':') addr = { hostname, port: Number(port) } } const listener = listen(addr) return new Server(listener)}

Procedemos a instanciar un servidor llamando a la serve()función pasando un objeto con la portpropiedad.

Luego ejecutamos este bucle para responder a cada solicitud que viene del servidor.

for await (const req of s) { req.respond({ body: 'Hello Worldn' })}

Tenga en cuenta que usamos la awaitpalabra clave sin tener que envolverla en una asyncfunción porque Deno implementa await de nivel superior.

Ejecutemos este programa localmente. Supongo que utiliza VS Code, pero puede utilizar cualquier editor que desee.

Recomiendo instalar la extensión Deno desde justjavac(había otra con el mismo nombre cuando la probé, pero estaba obsoleta; podría desaparecer en el futuro)

La extensión proporcionará varias utilidades y cosas interesantes a VS Code para ayudarte a escribir tus aplicaciones.

Ahora crea un app.tsarchivo en una carpeta y pega el código anterior:

Ahora ejecútalo usando deno run app.ts:

Deno descarga todas las dependencias que necesita, descargando primero la que importamos.

El archivo https://deno.land/std/http/server.ts tiene varias dependencias propias:

import { encode } from '../encoding/utf8.ts'import { BufReader, BufWriter } from '../io/bufio.ts'import { assert } from '../testing/asserts.ts'import { deferred, Deferred, MuxAsyncIterator } from '../async/mod.ts'import { bodyReader, chunkedBodyReader, emptyReader, writeResponse, readRequest,} from './_io.ts'import Listener = Deno.Listenerimport Conn = Deno.Connimport Reader = Deno.Reader

y estos se importan automáticamente.

Pero al final tenemos un problema:

¿Qué está pasando? Tenemos un problema de permiso denegado.

Hablemos del sandbox.

El sandbox de Deno

Mencioné anteriormente que Deno tiene una zona protegida que evita que los programas hagan algo que no quieres permitir.

¿Qué quiere decir esto?

Una de las cosas que Ryan menciona en la charla introductoria de Deno es que a veces quieres ejecutar un programa JavaScript fuera del navegador web, pero no le permites acceder a nada de lo que quiere en tu sistema o comunicarse con el mundo exterior a través de una red.

No hay nada que impida que una aplicación Node.js obtenga tus claves SSH o cualquier otra cosa en tu sistema y la envíe a un servidor. Por eso, normalmente solo instalamos paquetes Node de fuentes confiables, pero ¿cómo podemos saber si uno de los proyectos que usamos es atacado y, a su vez, todos los demás lo son?

Deno intenta replicar el mismo modelo de permisos que implementa el navegador. Ningún código JavaScript que se ejecute en el navegador puede hacer cosas sospechosas en su sistema a menos que usted lo permita explícitamente.

Volviendo a Deno, si un programa quiere acceder a la red como en el caso anterior, entonces necesitamos darle permiso.

Podemos hacerlo pasando una bandera cuando ejecutamos el comando, en este caso --allow-net:

deno run --allow-net app.ts

La aplicación ahora está ejecutando un servidor HTTP en el puerto 8000:

Otras banderas permiten a Deno desbloquear otras funcionalidades:

• --allow-envpermitir el acceso al entorno
• --allow-hrtimePermite la medición del tiempo con alta resolución
• --allow-net=allow-netpermitir el acceso a la red
• --allow-pluginpermitir cargar complementos
• --allow-read=allow-readpermitir acceso de lectura al sistema de archivos
• --allow-runpermitir la ejecución de subprocesos
• --allow-write=allow-writepermitir acceso de escritura al sistema de archivos
• --allow-allpermitir todos los permisos (igual que -A)

Los permisos para nety readpueden writeser granulares. Por ejemplo, puede permitir la lectura desde una carpeta específica utilizando--allow-read=/dev

Código de formato

Una de las cosas que más me gustó de Go fue el gofmtcomando que venía con el compilador de Go. Todo el código de Go se ve igual. Todos usan gofmt.

Los programadores de JavaScript están acostumbrados a ejecutar Prettier y, deno fmtde hecho, lo ejecutan bajo la apariencia de algo real.

Digamos que tienes un archivo mal formateado como éste:

Lo ejecutas deno fmt app.tsy se formatea automáticamente de forma correcta, agregando también punto y coma donde falta:

La biblioteca estándar

La biblioteca estándar de Deno es extensa a pesar de que el proyecto es muy joven.

Incluye:

• archiveutilidades del archivo tar
• asyncutilidades asincrónicas
• bytesAyudantes para manipular porciones de bytes
• datetimeanálisis de fecha y hora
• encodingcodificación/decodificación para varios formatos
• flagsAnalizar indicadores de línea de comandos
• fmtformato e impresión
• fsAPI del sistema de archivos
• hashbiblioteca criptográfica
• httpServidor HTTP
• ioBiblioteca de E/S
• logutilidades de registro
• mimeSoporte para datos multiparte
• nodeCapa de compatibilidad de Node.js
• pathmanipulación de ruta
• wsconectores web

Otro ejemplo de Deno

Veamos otro ejemplo de una aplicación Deno, de los ejemplos de Deno cat:

const filenames = Deno.argsfor (const filename of filenames) { const file = await Deno.open(filename) await Deno.copy(file, Deno.stdout) file.close()}

Esto asigna a la filenamesvariable el contenido de Deno.args, que es una variable que contiene todos los argumentos enviados al comando.

Los recorremos en iteración y, para cada uno de ellos, usamos Deno.open()para abrir el archivo y usamos Deno.copy()para imprimir el contenido del archivo en Deno.stdout. Finalmente, cerramos el archivo.

Si ejecuta esto usando

deno run https://deno.land/std/examples/cat.ts

El programa se descarga y se compila, y no pasa nada porque no especificamos ningún argumento.

Pruébalo ahora

deno run https://deno.land/std/examples/cat.ts app.ts

suponiendo que tengas app.tsdel proyecto anterior en la misma carpeta.

Recibirás un error de permiso:

Debido a que Deno no permite el acceso al sistema de archivos de forma predeterminada, se puede conceder acceso a la carpeta actual mediante --allow-read=./:

deno run --allow-read=./ https://deno.land/std/examples/cat.ts app.ts

¿Existe un Express/Hapi/Koa/* para Deno?

Sí, definitivamente. Echa un vistazo a proyectos como

• deno-drash
• deno-express
• roble
• pogo
• Sirve

Ejemplo: utilizar Oak para crear una API REST

Quiero dar un ejemplo sencillo de cómo crear una API REST con Oak. Oak es interesante porque está inspirado en Koa, el popular middleware de Node.js, y por eso resulta muy familiar si ya lo has usado antes.

La API que vamos a construir es muy simple.

Nuestro servidor almacenará, en memoria, una lista de perros con nombre y edad.

Queremos:

• añadir nuevos perros
• lista de perros
• Obtenga detalles sobre un perro específico
• eliminar un perro de la lista
• actualizar la edad de un perro

Lo haremos en TypeScript, pero nada le impide escribir la API en JavaScript: simplemente elimine los tipos.

Crear un app.tsarchivo.

Comencemos importando los objetos Applicationy Routerde Oak:

import { Application, Router } from 'https://deno.land/x/oak/mod.ts'

Luego obtenemos las variables de entorno PORT y HOST:

const env = Deno.env.toObject()const PORT = env.PORT || 4000const HOST = env.HOST || '127.0.0.1'

De forma predeterminada, nuestra aplicación se ejecutará en localhost:4000.

Ahora creamos la aplicación Oak y la iniciamos:

const router = new Router()const app = new Application()app.use(router.routes())app.use(router.allowedMethods())console.log(`Listening on port ${PORT}...`)await app.listen(`${HOST}:${PORT}`)

Ahora la aplicación debería compilarse bien.

Correr

deno run --allow-env --allow-net app.ts

y Deno descargará las dependencias:

y luego escuchar en el puerto 4000.

Las siguientes veces que ejecute el comando, Deno omitirá la parte de instalación porque esos paquetes ya están almacenados en caché:

En la parte superior del archivo, definamos una interfaz para un perro, luego declaramos una dogsmatriz inicial de objetos Perro:

interface Dog { name: string age: number}let dogs: ArrayDog = [ { name: 'Roger', age: 8, }, { name: 'Syd', age: 7, },]

Ahora implementemos realmente la API.

Ya tenemos todo listo. Después de crear el enrutador, agreguemos algunas funciones que se invocarán cada vez que se acceda a uno de esos puntos finales:

const router = new Router()router .get('/dogs', getDogs) .get('/dogs/:name', getDog) .post('/dogs', addDog) .put('/dogs/:name', updateDog) .delete('/dogs/:name', removeDog)

¿Ves? Definimos

• GET /dogs
• GET /dogs/:name
• POST /dogs
• PUT /dogs/:name
• DELETE /dogs/:name

Vamos a implementarlos uno por uno.

A partir de GET /dogs, que devuelve la lista de todos los perros:

export const getDogs = ({ response }: { response: any }) = { response.body = dogs}

A continuación, te explicamos cómo podemos recuperar un solo perro por su nombre:

export const getDog = ({ params, response,}: { params: { name: string } response: any}) = { const dog = dogs.filter((dog) = dog.name === params.name) if (dog.length) { response.status = 200 response.body = dog[0] return } response.status = 400 response.body = { msg: `Cannot find dog ${params.name}` }}

Así es como agregamos un nuevo perro:

export const addDog = async ({ request, response,}: { request: any response: any}) = { const body = await request.body() const dog: Dog = body.value dogs.push(dog) response.body = { msg: 'OK' } response.status = 200}

Tenga en cuenta que ahora uso const body = await request.body()para obtener el contenido del cuerpo, ya que los valores namey agese pasan como JSON.

Así es como actualizamos la edad de un perro:

export const updateDog = async ({ params, request, response,}: { params: { name: string } request: any response: any}) = { const temp = dogs.filter((existingDog) = existingDog.name === params.name) const body = await request.body() const { age }: { age: number } = body.value if (temp.length) { temp[0].age = age response.status = 200 response.body = { msg: 'OK' } return } response.status = 400 response.body = { msg: `Cannot find dog ${params.name}` }}

Y así es como podemos eliminar un perro de nuestra lista:

export const removeDog = ({ params, response,}: { params: { name: string } response: any}) = { const lengthBefore = dogs.length dogs = dogs.filter((dog) = dog.name !== params.name) if (dogs.length === lengthBefore) { response.status = 400 response.body = { msg: `Cannot find dog ${params.name}` } return } response.body = { msg: 'OK' } response.status = 200}

Aquí está el código de ejemplo completo:

Tal vez te puede interesar:

1. Introducción a React
2. Agregar evento de clic a los elementos DOM devueltos desde querySelectorAll
3. Cómo cambiar el valor de un nodo DOM
4. Cómo comprobar si un elemento DOM tiene una clase

El manual de Deno: una introducción concisa a Deno

¿Qué es Deno?¿Por qué Deno? ¿Por qué ahora?¿Deberías aprender Deno?¿Reemplazarás a Node.js?Compatibilidad con TypeScript de primera claseSimilitudes

programar

es

2025-01-09

Si crees que alguno de los contenidos (texto, imagenes o multimedia) en esta página infringe tus derechos relativos a propiedad intelectual, marcas registradas o cualquier otro de tus derechos, por favor ponte en contacto con nosotros en el mail [email protected] y retiraremos este contenido inmediatamente