Golang: Exploring HTTP and Fiber Web Framework

Golang has a default HTTP library that allows developers to create endpoints and handle requests. However, its functionality is quite limited, lacking built-in support for custom routing, request method-based handling, and dynamic slugs.

For example, with Golang’s built-in HTTP package:

• You can handle basic HTTP methods (GET, POST, DELETE, etc.).
• However, custom routing and enhancements require additional work.
• There is no built-in support for dynamic routes and slugs.

To address these limitations, Fiber — a high-performance web framework inspired by Express.js — steps in to provide better routing, middleware support, and more flexibility.

Go HTTP vs. Fiber Performance

If you’re wondering how Golang’s default HTTP package compares to Fiber, check out this benchmark:

🔗 Golang HTTP vs. Fiber Performance Benchmark

• For small request sizes, the built-in HTTP package is faster.
• For larger request sizes, Fiber outperforms HTTP in speed.
• Among Go web frameworks, Fiber is considered the fastest and most efficient.
• Fiber is powered by FastHTTP, making it highly optimized for performance.

---

Writing Your First Fiber Application

Below is a simple Fiber application demonstrating how to create basic routes:

package main

import (
 g"fmt"
 "net/http"
 "github.com/gofiber/fiber/v2"
)

func main() {
 app := fiber.New()

 // Defining routes
 app.Get("/testing", usingFiber)
 app.Get("/:name", greetUser)
 app.Static("/public", "./public")

 fmt.Println("Server is running on port 3000")
 app.Listen(":3000")
}

// Handler function for "/testing" route
func usingFiber(c *fiber.Ctx) error {
 return c.SendString("Hello, World!")
}

// Handler function for dynamic "/:name" route
func greetUser(c *fiber.Ctx) error {
 name := c.Params("name")
 return c.SendString("Hello, " + name)
}

Code Breakdown:

Initializing Fiber: fiber.New() creates an instance of the Fiber application.

Defining Routes:

• app.Get("/testing", usingFiber): Registers a GET request at /testing.
• app.Get("/:name", greetUser): Uses a dynamic route, where :name is a variable.

Static File Serving: app.Static("/public", "./public") serves static files from the /public directory.

Context (ctx): Each request passes a context object (c *fiber.Ctx), allowing access to request parameters, query strings, and more.

---

Comparing Fiber and Golang HTTP

Here’s a quick look at how the default Go HTTP package compares:

package main
import (
 "fmt"
 "net/http"
)

func main() {
 http.HandleFunc("/testing2", usingHttp)
 fmt.Println("Server is running on port 3001")
 http.ListenAndServe(":3001", nil)
}

func usingHttp(w http.ResponseWriter, r *http.Request) {
 w.Write([]byte("Hello, World2!"))
}

Key Differences:

• The default Go HTTP package handles all types of requests (GET, POST, DELETE, etc.) unless explicitly checked.
• Fiber allows custom endpoints per method, making it cleaner and more flexible.
• Fiber provides built-in support for static files, routing, and middleware, reducing boilerplate code.

---

TL;DR — Quick Takeaways:

✔ Golang has a built-in HTTP library, but it’s limited in routing and flexibility.

✔ Fiber is faster, cleaner, and more expressive than the default HTTP package.

✔ Fiber is inspired by Express.js and uses FastHTTP for better performance.

✔ The default HTTP package is faster for small requests, but Fiber excels at larger workloads.

✔ Fiber makes creating custom routes and handling different HTTP methods easier.

---

Now that you know why Fiber is a top choice for Go web development, why not try it in your next project? 🚀