mirror of https://github.com/vapor/docs.git
93 lines
3.2 KiB
Markdown
93 lines
3.2 KiB
Markdown
# Ficheros
|
|
|
|
Vapor ofrece una API sencilla para leer y escribir archivos de forma asíncrona dentro de los controladores de rutas. Esta API se construye sobre el tipo [`NonBlockingFileIO`](https://swiftpackageindex.com/apple/swift-nio/main/documentation/nioposix/nonblockingfileio) de NIO.
|
|
|
|
## Lectura
|
|
|
|
El método principal para leer un archivo entrega fragmentos al controlador de devolución de llamadas a medida que se leen del disco. El archivo a leer se especifica mediante su ruta. Las rutas relativas buscarán en el directorio de trabajo actual del proceso.
|
|
|
|
```swift
|
|
// Lee un archivo del disco de forma asíncrona.
|
|
let readComplete: EventLoopFuture<Void> = req.fileio.readFile(at: "/path/to/file") { chunk in
|
|
print(chunk) // ByteBuffer
|
|
}
|
|
|
|
// O
|
|
try await req.fileio.readFile(at: "/path/to/file") { chunk in
|
|
print(chunk) // ByteBuffer
|
|
}
|
|
// La lectura ha finalizado
|
|
```
|
|
|
|
Si se utiliza `EventLoopFuture`, el futuro devuelto indicará cuándo ha completado la lectura o si ha ocurrido un error. Si se utiliza `async`/`await`, cuando regresa del `await`, la lectura se ha completado. En caso de error, se lanzará una excepción.
|
|
|
|
### Flujo
|
|
|
|
El método `streamFile` convierte un archivo de transmisión en una respuesta `Response`. Este método establecerá automáticamente los encabezados apropiados, como `ETag` y `Content-Type`.
|
|
|
|
```swift
|
|
// Transmite el archivo como una respuesta HTTP de forma asíncrona.
|
|
req.fileio.streamFile(at: "/path/to/file").map { res in
|
|
print(res) // Response
|
|
}
|
|
|
|
// O
|
|
let res = req.fileio.streamFile(at: "/path/to/file")
|
|
print(res)
|
|
```
|
|
|
|
El resultado puede ser devuelto directamente por su controlador de ruta.
|
|
|
|
### Recolector
|
|
|
|
El método `collectFile` lee el archivo especificado en un buffer.
|
|
|
|
```swift
|
|
// Lee el archivo en un buffer.
|
|
req.fileio.collectFile(at: "/path/to/file").map { buffer in
|
|
print(buffer) // ByteBuffer
|
|
}
|
|
|
|
// o
|
|
let buffer = req.fileio.collectFile(at: "/path/to/file")
|
|
print(buffer)
|
|
```
|
|
|
|
!!! warning "Advertencia"
|
|
Este método requiere que el archivo entero esté en la memoria desde el inicio. Utilice una lectura por fragmentos (chunked) o flujo contínuo (streaming) para limitar el uso de memoria.
|
|
|
|
## Escritura
|
|
|
|
El método `writeFile` permite escribir un buffer a un archivo.
|
|
|
|
```swift
|
|
// Escribe un buffer a un archivo.
|
|
req.fileio.writeFile(ByteBuffer(string: "Hello, world"), at: "/path/to/file")
|
|
```
|
|
|
|
El futuro devuelto indicará cuándo se ha completado la escritura o si se ha producido un error.
|
|
|
|
## Middleware
|
|
|
|
Para más información acerca de cómo enviar archivos automáticamente desde la carpeta _Public_ de su projecto, visite [Middleware → FileMiddleware](middleware.md#file-middleware).
|
|
|
|
## Avanzado
|
|
|
|
En casos donde la API de vapor no de asistencia, puede utilizar directamente el tipo `NonBlockingFileIO` de NIO.
|
|
|
|
```swift
|
|
// Hilo principal
|
|
let fileHandle = try await app.fileio.openFile(
|
|
path: "/path/to/file",
|
|
eventLoop: app.eventLoopGroup.next()
|
|
).get()
|
|
print(fileHandle)
|
|
|
|
// En un controlador de ruta.
|
|
let fileHandle = try await req.application.fileio.openFile(
|
|
path: "/path/to/file",
|
|
eventLoop: req.eventLoop)
|
|
print(fileHandle)
|
|
```
|
|
Para más información, visite la [API reference](https://swiftpackageindex.com/apple/swift-nio/main/documentation/nioposix/nonblockingfileio) de SwiftNIO.
|