Fiber released v1.7! 🎉 What's new and is it still fast, flexible and friendly?

Introduction

Good Friday, everybody! 👋 It's a great day for upgrades and even more so for good ones. So, I'd like to suggest you go to a new level of Fiber Go web framework — new version v1.7.

💭 Please note: official docs may not contains extensive description for some changes. Don't worry, authors are working right now for it.

📝 Table of contents

• Official Fiber logo
• New features
  • Render() method
  • Error() method and re-new Next(err)
  • BodyParser() method
  • Group() method
  • WebSocket() method
  • Recover() method
  • Map() method
• Updates & Improvements
  • Re-new HTTP methods
  • Re-think Settings method
• Deprecated & Removed list
• Benchmarks
• Do you like Fiber?
• Your assistance to project

Official Fiber logo

First of all, Fiber v1.7 have a new awesome logo:

Thanks to Rasmus Andersen for great open source font called Inter 🥰

New features

OK. Let's go to another new features! 👇

✅ Render() method

Add support for template engines:

• html
• amber
• handlebars
• mustache
• pug

You can setup template engine before initiation app:

app := fiber.New(&fiber.Settings{
  TemplateEngine:    "mustache",
  TemplateFolder:    "./views",
  TemplateExtension: ".tmpl",
})

Or after initiation:

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,
  })
})

✅ Error() and Next(err) methods

Now, you may contains the Error information, that thrown by a panic or passed via the Next(err) method:

app.Get("/api/user", func (c *fiber.Ctx) {
  if err := c.JSON(&User); err != nil {
    c.Next(err) 
    // => if something went wrong here, we can handle it
  }
})

app.Use("/api", func(c *fiber.Ctx) {
  c.Set("Content-Type", "application/json")
  c.Status(500).Send(c.Error())
})

✅ BodyParser() method

Binds the request body to a struct:

// curl -X POST -H "Content-Type: application/json" \ 
//   --data '{"name":"john","pass":"doe"}' localhost:3000

// curl -X POST -H "Content-Type: application/xml" \ 
//   --data '<Login><name>john</name><pass>doe</pass><Login>' localhost:3000

// curl -X POST -H "Content-Type: application/x-www-form-urlencoded" \
//   --data 'name=john&pass=doe' localhost:3000

// curl -v -F name=john -F pass=doe localhost:3000

type Person struct {
  Name string `json:"name" xml:"name" form:"name"`
  Pass string `json:"pass" xml:"pass" form:"pass"`
}

app.Post("/", func(c *fiber.Ctx) {
  var person Person

  if err := c.BodyParser(&person); err != nil {
      // Handle error
  }

  // Do something with person.Name or person.Pass
})

✅ Group() method

Add chain function for groupping routes:

api := app.Group("/api", cors())  // /api

v1 := api.Group("/v1", mysql())   // /api/v1
v1.Get("/list", handler)          // /api/v1/list
v1.Get("/user", handler)          // /api/v1/user

v2 := api.Group("/v2", mongodb()) // /api/v2
v2.Get("/list", handler)          // /api/v2/list
v2.Get("/user", handler)          // /api/v2/user

✅ WebSocket() method

Add WebSocket support using gorilla *Conn:

app := fiber.New()

app.WebSocket("/ws/:name", func(c *fiber.Conn) {
  log.Println(c.Params("name"))

  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
    }
  }
})

// ws://localhost:3000/ws/john
app.Listen(3000)

✅ Recover() method

Recover from panic:

app.Get("/", func(c *fiber.Ctx) {
  panic("Something went wrong!") // it's panic time!
})

app.Recover(func(c *fiber.Ctx) {
  c.Status(500).Send(c.Error())
  // => 500 "Something went wrong!"
})

✅ Map() method

Add shortcut for map[string]interface{}:

fiber.Map{
  "first_name": "John",
  "is_admin":   true,
}

Updates & Improvements

And here are updates and improvements, that Fiber has prepared for you! 👇

ℹ️ Re-new HTTP methods

Add multiple middlewares/handlers inside routes & groups:

app.Get("/", middlewareOne(), middlewareTwo(), handler())

🔀 Re-think Settings method

Pass optional settings before app initiation, inside New() method:

app := fiber.New(&fiber.Settings{
  Prefork:       true,
  CaseSensitive: true,
  StrictRouting: true,
  ServerHeader:  "Go Server",
  // ...other settings
})

Deprecated & Removed list

Follow functions are deprecated and removed from Fiber v1.7:

🚫 app.Banner
🚫 ctx.BasicAuth
🚫 ctx.Json
🚫 ctx.JsonBytes
🚫 ctx.JsonString
🚫 ctx.Xml

🤖 Benchmarks

TechEmpower

All results: https://www.techempower.com/benchmarks/#section=data-r19&hw=ph&test=composite&a=2

The Benchmarker

All results: https://github.com/the-benchmarker/web-frameworks

💬 Do you like Fiber? Tell about it!

Fiber authors are always listening to its users in issues and all over the Internet. Therefore, it would be great, if you could share your opinion or/and experience with Fiber to authors in GitHub repository!

[...] because it's only right way to create a fast, flexible and friendly Go web framework for any tasks, deadlines and developer skills!

— Fiber Authors

Your assistance to project 👍

1. Add a GitHub Star to project.
2. Tweet about Fiber on your Twitter.
3. Help to translate README and API Docs to another language (at this moment, Fiber was translated to 10 languages).

Photo by

[Title, 1] Vic Shóstak https://github.com/koddr
[2, 3] Ashley McNamara https://github.com/ashleymcnamara/gophers

P.S.

If you want more articles (like this) on this blog, then post a comment below and subscribe to me. Thanks! 😻

And of course, you can help me make developers' lives even better! Just connect to one of my projects as a contributor. It's easy!

My projects that need your help (and stars) 👇

• 🔥 gowebly: A next-generation CLI tool for easily build amazing web applications with Go on the backend, using htmx & hyperscript and the most popular atomic/utility-first CSS frameworks on the frontend.
• ✨ create-go-app: Create a new production-ready project with Go backend, frontend and deploy automation by running one CLI command.
• 🏃 yatr: Yet Another Task Runner allows you to organize and automate your routine operations that you normally do in Makefile (or else) for each project.
• 📚 gosl: The Go Snippet Library provides snippets collection for working with routine operations in your Go programs with a super user-friendly API and the most efficient performance.
• 🏄‍♂️ csv2api: The parser reads the CSV file with the raw data, filters the records, identifies fields to be changed, and sends a request to update the data to the specified endpoint of your REST API.
• 🚴 json2csv: The parser can read given folder with JSON files, filtering and qualifying input data with intent & stop words dictionaries and save results to CSV files by given chunk size.