Fiber é um framework web inspirado no Express, construído sobre o Fasthttp, o motor HTTP mais rápido do Go. Projetado para facilitar e acelerar o desenvolvimento, com zero de alocação de memória e desempenho em mente.
## ⚡️ Início rápido
```go
package main
import "github.com/gofiber/fiber"
func main() {
app := fiber.New()
app.Get("/", func(c *fiber.Ctx) {
c.Send("Hello, World!")
})
app.Listen(3000)
}
```
## ⚙️ Instalação
Primeiro de tudo, faça o [download](https://golang.org/dl/) e instale o Go. É necessário a versão `1.11` ou superior.
A instalação é feita usando o comando [`go get`](https://golang.org/cmd/go/#hdr-Add_dependencies_to_current_module_and_install_them) :
```bash
go get -u github.com/gofiber/fiber/...
```
## 🤖 Benchmarks
Esses testes são realizados pelo [TechEmpower](https://github.com/TechEmpower/FrameworkBenchmarks) e [Go Web](https://github.com/smallnest/go-web-framework-benchmark). Se você quiser ver todos os resultados, visite nosso [Wiki](https://fiber.wiki/benchmarks) .
## 🎯 Recursos
- [Roteamento](https://fiber.wiki/routing) robusto
- Servir [arquivos estáticos](https://fiber.wiki/application#static)
- [Desempenho](https://fiber.wiki/benchmarks) extremo
- [Baixo consumo de memória](https://fiber.wiki/benchmarks)
- [API de rotas](https://fiber.wiki/context)
- Suporte para Middleware e [Next](https://fiber.wiki/context#next)
- Programação [rápida](https://dev.to/koddr/welcome-to-fiber-an-express-js-styled-fastest-web-framework-written-with-on-golang-497) de aplicações de servidor
- Traduzido em [5 idiomas](https://fiber.wiki/)
- E muito mais, [explore o Fiber](https://fiber.wiki/)
## 💡 Filosofia
Os novos gophers que mudaram do [Node.js](https://nodejs.org/en/about/) para o [Go](https://golang.org/doc/) estão tendo que lidar com uma curva de aprendizado antes que possam começar a criar seus aplicativos web ou microsserviços. O Fiber, como um **framework web**, foi criado com a ideia de ser **minimalista** e seguindo o **caminho UNIX**, para que novos gophers possam, rapidamente, entrar no mundo do Go com uma recepção calorosa e confiável.
O Fiber é **inspirado** no Express, o framework web mais popular da Internet. Combinamos a **facilidade** do Express e o **desempenho bruto** do Go. Se você já implementou um aplicativo web com Node.js ( _usando Express.js ou similar_ ), então muitos métodos e princípios parecerão **muito comuns** para você.
## 👀 Exemplos
Listados abaixo estão alguns exemplos comuns. Se você quiser ver mais exemplos de código, visite nosso [repositório de receitas](https://github.com/gofiber/recipes) ou a [documentação da API](https://fiber.wiki).
### Routing
```go
func main() {
app := fiber.New()
// GET /john
app.Get("/:name", func(c *fiber.Ctx) {
fmt.Printf("Hello %s!", c.Params("name"))
// => Hello john!
})
// GET /john
app.Get("/:name/:age?", func(c *fiber.Ctx) {
fmt.Printf("Name: %s, Age: %s", c.Params("name"), c.Params("age"))
// => Name: john, Age:
})
// GET /api/register
app.Get("/api*", func(c *fiber.Ctx) {
fmt.Printf("/api%s", c.Params("*"))
// => /api/register
})
app.Listen(3000)
}
```
### Serve static files
https://fiber.wiki/application#static
```go
func main() {
app := fiber.New()
app.Static("/", "/public")
// => http://localhost:3000/js/script.js
// => http://localhost:3000/css/style.css
app.Static("/prefix", "/public")
// => http://localhost:3000/prefix/js/script.js
// => http://localhost:3000/prefix/css/style.css
app.Static("*", "/public/index.html")
// => http://localhost:3000/any/path/shows/index/html
app.Listen(3000)
}
```
### Middleware & Next
https://fiber.wiki/routing#middleware
https://fiber.wiki/context#next
```go
func main() {
app := fiber.New()
// Match any route
app.Use(func(c *fiber.Ctx) {
fmt.Println("First middleware")
c.Next()
})
// Match all routes starting with /api
app.Use("/api", func(c *fiber.Ctx) {
fmt.Println("Second middleware")
c.Next()
})
// POST /api/register
app.Post("/api/register", func(c *fiber.Ctx) {
fmt.Println("Last middleware")
c.Send("Hello, World!")
})
app.Listen(3000)
}
```
📚 Show more code examples
### Template engines
https://fiber.wiki/application#settings
https://fiber.wiki/context#render
Supported engines:
- [html](https://golang.org/pkg/html/template/)
- [amber](https://github.com/eknkc/amber)
- [handlebars](https://github.com/aymerick/raymond)
- [mustache](https://github.com/cbroglie/mustache)
- [pug](https://github.com/Joker/jade)
```go
func main() {
// You can setup template engine before initiation app:
app := fiber.New(&fiber.Settings{
TemplateEngine: "mustache",
TemplateFolder: "./views",
TemplateExtension: ".tmpl",
})
// OR after initiation app at any convenient location:
app.Settings.TemplateEngine = "mustache"
app.Settings.TemplateFolder = "./views"
app.Settings.TemplateExtension = ".tmpl"
// And now, you can call template `./views/home.tmpl` like this:
app.Get("/", func(c *fiber.Ctx) {
c.Render("home", fiber.Map{
"title": "Homepage",
"year": 1999,
})
})
// ...
}
```
### Grouping routes into chains
https://fiber.wiki/application#group
```go
func main() {
app := fiber.New()
// Root API route
api := app.Group("/api", cors()) // /api
// API v1 routes
v1 := api.Group("/v1", mysql()) // /api/v1
v1.Get("/list", handler) // /api/v1/list
v1.Get("/user", handler) // /api/v1/user
// API v2 routes
v2 := api.Group("/v2", mongodb()) // /api/v2
v2.Get("/list", handler) // /api/v2/list
v2.Get("/user", handler) // /api/v2/user
// ...
}
```
### Middleware logger
https://fiber.wiki/middleware#logger
```go
import (
"github.com/gofiber/fiber"
"github.com/gofiber/fiber/middleware"
)
func main() {
app := fiber.New()
// If you want to change default Logger config
loggerConfig := middleware.LoggerConfig{
Format: "${time} - ${method} ${path}\n",
TimeFormat: "Mon, 2 Jan 2006 15:04:05 MST",
}
// Middleware for Logger with config
app.Use(middleware.Logger(loggerConfig))
// ...
}
```
### Cross-Origin Resource Sharing (CORS)
https://fiber.wiki/middleware#cors
[CORS](https://developer.mozilla.org/en-US/docs/Web/HTTP/CORS) is a mechanism that uses additional HTTP headers to tell browsers to give a web application running at one origin, access to selected resources from a different origin. A web application executes a cross-origin HTTP request when it requests a resource that has a different origin (domain, protocol, or port) from its own.
```go
import (
"github.com/gofiber/fiber"
"github.com/gofiber/fiber/middleware"
)
func main() {
app := fiber.New()
// Connect CORS for each route as middleware
app.Use(middleware.CORS())
app.Get("/", func(c *fiber.Ctx) {
c.Send("CORS is enabled!")
})
app.Listen(3000)
}
```
Check CORS by passing any domain in `Origin` header:
```bash
curl -H "Origin: http://example.com" --verbose http://localhost:3000
```
### Custom 404 response
```go
func main() {
app := fiber.New()
app.Static("/public")
app.Get("/demo", func(c *fiber.Ctx) {
c.Send("This is a demo!")
})
app.Post("/register", func(c *fiber.Ctx) {
c.Send("Welcome!")
})
// Last middleware to match anything
app.Use(func(c *fiber.Ctx) {
c.SendStatus(404) // => 404 "Not Found"
})
app.Listen(3000)
}
```
### JSON Response
https://fiber.wiki/context#json
```go
type User struct {
Name string `json:"name"`
Age int `json:"age"`
}
func main() {
app := fiber.New()
app.Get("/user", func(c *fiber.Ctx) {
c.JSON(&User{"John", 20})
// {"name":"John", "age":20}
})
app.Get("/json", func(c *fiber.Ctx) {
c.JSON(&fiber.Map{
"success": true,
"message": "Hi John!",
})
// {"success":true, "message":"Hi John!"}
})
app.Listen(3000)
}
```
### WebSocket support
https://fiber.wiki/application#websocket
```go
func main() {
app := fiber.New()
app.WebSocket("/ws", func(c *fiber.Conn) {
for {
mt, msg, err := c.ReadMessage()
if err != nil {
log.Println("read:", err)
break
}
log.Printf("recovery: %s", msg)
err = c.WriteMessage(mt, msg)
if err != nil {
log.Println("write:", err)
break
}
}
})
// Listen on ws://localhost:3000/ws
app.Listen(3000)
}
```
### Recover middleware
https://fiber.wiki/middleware#recover
```go
package main
import (
"github.com/gofiber/fiber"
"github.com/gofiber/fiber/middleware"
)
func main() {
app := fiber.New()
app.Use(middleware.Recover(func(c *fiber.Ctx, err error) {
log.Println(err) // "Something went wrong!"
c.SendStatus(500) // Internal Server Error
})))
app.Get("/", func(c *fiber.Ctx) {
panic("Something went wrong!")
})
app.Listen(3000)
}
```
## 💬 Mídia
- [Bem-vindo ao Fiber — uma estrutura da Web com estilo Express.js, escrita em Go com ❤️](https://dev.to/koddr/welcome-to-fiber-an-express-js-styled-fastest-web-framework-written-with-on-golang-497) _por [Vic Shóstak](https://github.com/koddr), 03 fev 2020_
## 👍 Contribuindo
Se você quer **agradecer** e/ou apoiar o desenvolvimento ativo do `Fiber`:
1. Deixe uma [estrela no GitHub](https://github.com/gofiber/fiber/stargazers) do projeto.
2. Tweet sobre o projeto [no seu Twitter](https://twitter.com/intent/tweet?text=%F0%9F%9A%80%20Fiber%20%E2%80%94%20is%20an%20Express.js%20inspired%20web%20framework%20build%20on%20Fasthttp%20for%20%23Go%20https%3A%2F%2Fgithub.com%2Fgofiber%2Ffiber) .
3. Escreva um review ou tutorial no [Medium](https://medium.com/), [Dev.to](https://dev.to/) ou blog pessoal.
4. Nos ajude a traduzir esses `README` e a [documentação da API](https://fiber.wiki/) para outros idiomas.
## ☕ Supporters
## ⭐️ Estrelas
## ⚠️ Licença
`Fiber` é um software livre e de código aberto licenciado sob a [Licença MIT](https://github.com/gofiber/fiber/blob/master/LICENSE).
JustDave
HenrikBinggl
Vic Shóstak
MarvinJWendt
ToishY