Skip to content

Commit

Permalink
Update whats_new.md documentation
Browse files Browse the repository at this point in the history
  • Loading branch information
ReneWerner87 committed Nov 29, 2024
1 parent 86fd29a commit 89452fe
Showing 1 changed file with 40 additions and 53 deletions.
93 changes: 40 additions & 53 deletions docs/whats_new.md
Original file line number Diff line number Diff line change
Expand Up @@ -68,76 +68,63 @@ We have made several changes to the Fiber app, including:
- **Listen**: Now has a configuration parameter.
- **Listener**: Now has a configuration parameter.

### CTX interface + customizable
### Custom Ctx Interface in Fiber v3

Fiber v3 introduces a more customizable `Ctx` interface, allowing developers to create their own context classes. This flexibility enables you to extend the default context with additional methods and properties tailored to your application's needs.
Fiber v3 introduces a customizable `Ctx` interface, allowing developers to extend and modify the context to fit their needs. This feature provides greater flexibility and control over request handling.

#### Idea Behind Custom `Ctx` Classes
#### Idea Behind Custom Ctx Classes

The primary idea behind using custom `Ctx` classes is to provide a way to encapsulate additional logic and data within the context, making it easier to manage and access throughout your application. This can be particularly useful for adding custom middleware, handling specific request/response patterns, or integrating with other libraries.
The idea behind custom `Ctx` classes is to give developers the ability to extend the default context with additional methods and properties tailored to the specific requirements of their application. This allows for better request handling and easier implementation of specific logic.

<details>
<summary>Example</summary>

Here's an example of how to create and use a custom `Ctx` class in Fiber v3:
#### NewCtxFunc

1. **Define a Custom Context Class**:
Create a new struct that embeds the default `fiber.Ctx` and add any additional methods or properties you need.
The `NewCtxFunc` method allows you to customize the `Ctx` struct as needed.

```go
package main

import (
"github.com/gofiber/fiber/v3"
)
```go title="Signature"
func (app *App) NewCtxFunc(function func(app *App) CustomCtx)
```

// CustomCtx extends the default fiber.Ctx
type CustomCtx struct {
fiber.Ctx
}
<details>
<summary>Example</summary>

// NewCustomCtx creates a new instance of CustomCtx
func NewCustomCtx(c fiber.Ctx) *CustomCtx {
return &CustomCtx{Ctx: c}
}
Here’s an example of how to customize the `Ctx` interface:

// CustomMethod is an example of a custom method
func (c *CustomCtx) CustomMethod() string {
return "This is a custom method"
}
```
```go
package main

2. **Middleware to Use Custom Context**:
Create middleware that replaces the default context with your custom context.
import (
"log"
"github.com/gofiber/fiber/v3"
)

```go
func CustomCtxMiddleware(c fiber.Ctx) error {
customCtx := NewCustomCtx(c)
return customCtx.Next()
}
```
type CustomCtx struct {
fiber.Ctx
}

3. **Use Custom Context in Handlers**:
Use the custom context in your route handlers.
// Custom method
func (c *CustomCtx) CustomMethod() string {
return "custom value"
}

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

// Use the custom context middleware
app.Use(CustomCtxMiddleware)
app.NewCtxFunc(func(app *fiber.App) fiber.Ctx {
return &CustomCtx{
Ctx: *fiber.NewCtx(app),
}
})

// Define a route that uses the custom context
app.Get("/", func(c fiber.Ctx) error {
customCtx := c.(*CustomCtx)
return customCtx.SendString(customCtx.CustomMethod())
})
app.Get("/", func(c fiber.Ctx) error {
customCtx := c.(*CustomCtx)
return c.SendString(customCtx.CustomMethod())
})

app.Listen(":3000")
}
```
log.Fatal(app.Listen(":3000"))
}
```

In this example, the `CustomCtx` struct extends the default `fiber.Ctx` with a custom method. The `CustomCtxMiddleware` middleware replaces the default context with the custom context, and the route handler uses the custom context to call the custom method. This approach allows you to encapsulate additional logic and data within the context, making it easier to manage and access throughout your application.
In this example, a custom context `CustomCtx` is created with an additional method `CustomMethod`. The `NewCtxFunc` method is used to replace the default context with the custom one.

</details>

Expand Down

0 comments on commit 89452fe

Please sign in to comment.