Go: routes and routing parameters in Fiber

  • Go
  • Gabriele Romanato

Fiber is a web framework for Go (Golang) that is designed to be fast, flexible, and easy to use. One of its powerful features is the ability to define routes with parameters, allowing developers to create dynamic and customizable endpoints for their web applications. In this article, we will explore how to leverage routes with parameters in Fiber to enhance the functionality and flexibility of your web applications.

What are Routes with Parameters?

Routes with parameters enable you to define dynamic parts in the URL, allowing your web application to handle varying inputs without having to create separate routes for each scenario. Parameters are placeholders in the URL that can capture values and pass them to your handlers. For example, a route like /user/:id can match URLs like /user/123 or /user/456, capturing the user IDs as parameters.

Let's dive into the key concepts and syntax for working with routes and parameters in Fiber.

Setting Up a Basic Fiber Application

Before we explore routes with parameters, let's set up a basic Fiber application. Make sure you have Fiber installed using:


go get -u github.com/gofiber/fiber/v2

Now, you can create a simple Fiber application:


package main

import "github.com/gofiber/fiber/v2"

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

    app.Get("/", func(c *fiber.Ctx) error {
        return c.SendString("Hello, Fiber!")
    })

    // Add more routes here

    app.Listen(":3000")
}

Creating Routes with Parameters

To create a route with parameters, you can use the colon : followed by the parameter name. Let's create a route that takes a user ID as a parameter:


app.Get("/user/:id", func(c *fiber.Ctx) error {
    userID := c.Params("id")
    return c.SendString("User ID: " + userID)
})

In this example, the :id part of the route is a parameter, and we retrieve its value using c.Params("id"). This allows us to access the user ID from the URL and use it in our handler.

Handling Multiple Parameters

You can have multiple parameters in a single route. For instance, a route like /product/:category/:id can capture both the product category and ID:


app.Get("/product/:category/:id", func(c *fiber.Ctx) error {
    category := c.Params("category")
    productID := c.Params("id")
    return c.SendString("Product Category: " + category + ", Product ID: " + productID)
})

Optional Parameters

You can make parameters optional by using the question mark ?. For example, /user/:id/:name? allows the name parameter to be optional:


app.Get("/user/:id/:name?", func(c *fiber.Ctx) error {
    userID := c.Params("id")
    userName := c.Params("name", "Guest")
    return c.SendString("User ID: " + userID + ", User Name: " + userName)
})

Query Parameters

While route parameters are part of the URL path, you can also work with query parameters. Fiber makes it easy to retrieve query parameters using c.Query:


app.Get("/search", func(c *fiber.Ctx) error {
    query := c.Query("q")
    return c.SendString("Search Query: " + query)
})

In this example, the URL /search?q=example would result in the message "Search Query: example."

Conclusion

Routes with parameters in Fiber provide a powerful mechanism for creating flexible and dynamic web applications. By understanding how to define, capture, and use parameters in your routes, you can build applications that can handle a wide range of scenarios without cluttering your code with numerous routes. Take advantage of Fiber's elegant syntax and powerful features to create robust and scalable web applications in Go.

Back to top