गो फाइबर राउटिंग

मार्ग प्रतिपादन

Go Fiber फ़्रेमवर्क में मार्ग का कार्य HTTP अनुरोध प्रसंस्करण का समर्थन करने के लिए विभिन्न URL को हैंडलिंग फ़ंक्शनों से बाँधना है। यह सभी वेब फ़्रेमवर्क अनुरोधों के प्रवेश बिंदु के रूप में कार्य करता है।

मार्ग हैंडलर (फ़ंक्शन)

विशिष्ट HTTP विधियों से बंधित मार्ग पंजीकृत करें।

नोट: कुछ फ़्रेमवर्क में, मार्ग हैंडलर को नियंत्रक कहा जाता है, जिसमें सामान्य रूप से एक ही अर्थ होता है - आने वाले HTTP अनुरोध का हैंडल करना।

फ़ंक्शन सिग्नेचर:

// HTTP methods
func (app *App) Get(path string, handlers ...Handler) Router
func (app *App) Head(path string, handlers ...Handler) Router
func (app *App) Post(path string, handlers ...Handler) Router
func (app *App) Put(path string, handlers ...Handler) Router
func (app *App) Delete(path string, handlers ...Handler) Router
func (app *App) Connect(path string, handlers ...Handler) Router
func (app *App) Options(path string, handlers ...Handler) Router
func (app *App) Trace(path string, handlers ...Handler) Router
func (app *App) Patch(path string, handlers ...Handler) Router

// Add allows you to specify methods as values
func (app *App) Add(method, path string, handlers ...Handler) Router

// All registers the route on all HTTP methods
// Similar to app.Use but does not bind a prefix
func (app *App) All(path string, handlers ...Handler) Router

उदाहरण:

// साधारण GET हैंडलर
app.Get("/api/list", func(c *fiber.Ctx) error {
  return c.SendString("यह एक GET अनुरोध है!")
})

// साधारण POST हैंडलर
app.Post("/api/register", func(c *fiber.Ctx) error {
  return c.SendString("यह एक POST अनुरोध है!")
})

Use मध्यस्थ और प्रीफिक्स URL अंतरग्रहण लोड करने के लिए है। ये मार्ग केवल प्रत्येक पथ की शुरुआत से मेल खाते हैं, उदाहरण के लिए, /john में /john/doe, /johnnnnn, वृद्धि होंगी।

कस्टम मध्यस्थ फ़ंक्शन सिग्नेचर:

func (app *App) Use(args ...interface{}) Router

उदाहरण:

// किसी भी अनुरोध का मेल
app.Use(func(c *fiber.Ctx) error {
    return c.Next()
})

// /api से शुरू होने वाले अनुरोध का मेल
app.Use("/api", func(c *fiber.Ctx) error {
    return c.Next()
})

// /api या /home से शुरू होने वाले अनुरोध का मेल (एकाधिक प्रीफिक्स समर्थन)
app.Use([]string{"/api", "/home"}, func(c *fiber.Ctx) error {
    return c.Next()
})

// कई हैंडलर जोड़ें
app.Use("/api", func(c *fiber.Ctx) error {
  c.Set("X-Custom-Header", random.String(32))
  return c.Next()
}, func(c *fiber.Ctx) error {
  return c.Next()
})

पथ

मार्ग पथ, अनुरोध विधि के साथ, पहुंचे जा सकने वाले समाप्तियों को परिभाषित करता है। मार्ग पथ एक स्ट्रिंग या स्ट्रिंग पैटर्न हो सकता है।

स्ट्रिंग-आधारित मार्ग पथ के उदाहरण

// इस मार्ग पथ का अनुरोध रूट पथ, "/" को मिलेगा:
app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("रूट पथ")
})

// इस मार्ग पथ का अनुरोध "/about" को मिलेगा:
app.Get("/about", func(c *fiber.Ctx) error {
  return c.SendString("के बारे में")
})

// इस मार्ग पथ का अनुरोध "/random.txt" को मिलेगा:
app.Get("/random.txt", func(c *fiber.Ctx) error {
  return c.SendString("रैंडम.टेक्स्ट")

ExpressJs फ़्रेमवर्क की तरह, मार्ग की घोषणाएँ किए जाने का क्रम महत्वपूर्ण है। जब एक अनुरोध प्राप्त होता है, तो मार्गों की जाँच क्रम में घोषित किए जाते हैं।

कृपया ध्यान दें: सुनिश्चित करें कि जोटीय पैरामीटर वाले वापरिक मार्ग इस बात के बाद लिखे गए हों कि वे भूमिका परिष्करण के लिए गलती से मेल खाने से बचे, जो अप्रत्याशित व्यवहार का कारण बन सकती है।

रूट पैरामीटर

रूट पैरामीटर रूट में डायनेमिक तत्व हैं और इनका नामित या अनामित सेगमेंट हो सकता है। ये सेगमेंट URL में निर्दिष्ट स्थान पर मानों को कैप्चर करने के लिए प्रयोग किए जाते हैं। आप Params फ़ंक्शन का उपयोग कर सकते हैं इन मानों को प्राप्त करने के लिए, जहां फ़ंक्शन पैरामीटर पथ में तारीख का नाम है, या नामित पैरामीटर के लिए, यह वे पात्र (*, +) और उनकी गणना है।

वाइल्डकार्ड (*) या प्लस साइन (+) लालची पैरामीटर को दर्शाते हैं।

रूट में वैकल्पिक पैरामीटर का उपयोग करने की संभावना भी होती है। नामित पैरामीटर के लिए, इन पैरामीटरों के पीछे एक प्रश्न चिह्न (?) आता है, जबकि प्लस साइन वैकल्पिक नहीं है, और आप वाइल्डकार्ड चरित्रों का प्रयोग कर सकते हैं एक वैकल्पिक और लालची पैरामीटर सीमा को दर्शाने के लिए।

रूट पैरामीटर के साथ रूट को परिभाषित करने का उदाहरण

// पैरामीटर
app.Get("/user/:name/books/:title", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s\n", c.Params("name"))
    fmt.Fprintf(c, "%s\n", c.Params("title"))
    return nil
})
// प्लस - लालची - वैकल्पिक नहीं
app.Get("/user/+", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("+"))
})

// वैकल्पिक पैरामीटर
app.Get("/user/:name?", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("name"))
})

// वाइल्डकार्ड - लालची - वैकल्पिक
app.Get("/user/*", func(c *fiber.Ctx) error {
    return c.SendString(c.Params("*"))
})

// इस रूट पथ का अनुरोध को समान ठहराया जाएगा "/v1/some/resource/name:customVerb" क्योंकि पैरामीटर चरित्रों को बचाया गया है
app.Get(`/v1/some/resource/name\:customVerb`, func(c *fiber.Ctx) error {
    return c.SendString("नमस्ते, समुदाय")
})

हाइफ़न (-) और डॉट (.) को वास्तविक रूप से व्याख्या किया जाता है, इन्हें पैरामीटर के साथ उपयोग किया जा सकता है ताकि उपयोगी उद्देश्य प्राप्त किया जा सके।

सभी विशेष पैरामीटर चरित्रों को भी \ का उपयोग करके बचाया जा सकता है और उनके मूल्यों को अनदेखा किया जाएगा, इसलिए यदि आप रूट में उन्हें उपयोग करना चाहते हैं। यह सुनिश्चित करने के लिए वापसी का उपयोग करना चाहिए क्योंकि जाओ नियमित रूप से कभी भी मुदरिकता नहीं होती है, और भाग के पत्र नियमित अभिव्यक्ति पैटर्न पर प्रभाव डाल सकते हैं।

// http://localhost:3000/plantae/prunus.persica
app.Get("/plantae/:genus.:species", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s.%s\n", c.Params("genus"), c.Params("species"))
    return nil // prunus.persica
})

// http://localhost:3000/flights/LAX-SFO
app.Get("/flights/:from-:to", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s-%s\n", c.Params("from"), c.Params("to"))
    return nil // LAX-SFO
})

हमारा स्मार्ट रूटिंग जानता है कि इस मामले में प्रस्तुत किए गए पैरामीटर चरित्र अनुरोध रूट का एक हिस्सा होना चाहिए और इसे इसी तरह से संभाल सकता है।

// http://localhost:3000/shop/product/color:blue/size:xs
app.Get("/shop/product/color::color/size::size", func(c *fiber.Ctx) error {
    fmt.Fprintf(c, "%s:%s\n", c.Params("color"), c.Params("size"))
    return nil // blue:xs
})

इसके अतिरिक्त, रूट में कई पैरामीटर और कई अनामित पैरामीटर चरित्र श्रंखलाएँ का उपयोग कर सकती हैं, जैसे वाइल्डकार्ड या प्लस चरित्र, जो उपयोक्ताओं के लिए रूट में विस्तार से संभावनाएँ बढ़ाते हैं।

// GET /@v1
// Params: "sign" -> "@", "param" -> "v1"
app.Get("/:sign:param", handler)

// GET /api-v1
// Params: "name" -> "v1" 
app.Get("/api-:name", handler)

// GET /customer/v1/cart/proxy
// Params: "*1" -> "customer/", "*2" -> "/cart"
app.Get("/*v1*/proxy", handler)

// GET /v1/brand/4/shop/blue/xs
// Params: "*1" -> "brand/4", "*2" -> "blue/xs"
app.Get("/v1/*/shop/*", handler)

हमने पहले से ही एक्सप्रेस रूटिंग को एग्जेप्ट रूटिंग में अनुकूलित कर दिया है, लेकिन यह अभी भी नियमित अभिव्यक्तियों का समर्थन नहीं करता है क्योंकि वे अपेक्षाकृत धीमे होते हैं।

बाधाएँ

जब आने वाले URL के साथ मिलता है और URL पथ को पैरामीटर के माध्यम से रूट मानों में विभाजित किया जाता है, तो रोक लागू की जाएगी। यह सुविधा v2.37.0 में लायी गई थी और इसे .NET Core से प्रेरित किया गया था।

बाधाएँ पैरामीटर मान की पुष्टि के लिए नहीं हैं। अगर पैरामीटर मान के लिए बाधा अवैध है, तो फाइबर एक 404 हैंडलर लौटेगा।

उदाहरण

• एकल बाधा
• एकाधिक बाधाएँ
• नियमित अभिव्यंतरीकरण बाधा

app.Get("/:test", func(c *fiber.Ctx) error {
  return c.SendString(c.Params("test"))
})

// कर्ल -एक्स GET http://localhost:3000/12 // 12

// कर्ल -एक्स GET http://localhost:3000/1 // GET /1 नहीं मिला

आप `;` का उपयोग करके एकाधिक बाधाएँ जोड़ सकते हैं।

app.Get("/:test", func(c *fiber.Ctx) error { return c.SendString(c.Params("test")) })

// कर्ल -एक्स GET http://localhost:3000/120000 // GET /120000 नहीं मिला

// कर्ल -एक्स GET http://localhost:3000/1 // GET /1 नहीं मिला

// कर्ल -एक्स GET http://localhost:3000/250 // 250

फाइबर रूटें पंजीकरण के समय नियमित अभिव्यंतरीकरण बाधाओं के लिए पूर्व-संकलित की जाती है, इसलिए नियमित अभिव्यंतरीकरण के लिए कोई परफार्मेंस ओवरहेड नहीं होता है।

```go
app.Get(`/:date`, func(c *fiber.Ctx) error {
  return c.SendString(c.Params("date"))
})

// कर्ल -एक्स GET http://localhost:3000/125 // GET /125 नहीं मिला

// कर्ल -एक्स GET http://localhost:3000/test // GET /test नहीं मिला

// कर्ल -एक्स GET http://localhost:3000/2022-08-27 // 2022-08-27

> जब तारीख-समय बाधाएँ (`*`,`+`,`?`,`:`, `/`,``,``,`>`,';`,`(`,`)`) का उपयोग कर रहे हों (`\\`), मार्ग में विशेष वर्णों का गलत समझा ना हो इसके लिए, समय-समय पर उनसे पहले `\\` का उपयोग करें।

**वैकल्पिक पैरामीटर उदाहरण**

आप वैकल्पिक पैरामीटरों में भी बाधाएँ जोड़ सकते हैं।
```go
app.Get("/:test?", func(c *fiber.Ctx) error {
  return c.SendString(c.Params("test"))
})
// कर्ल -एक्स GET http://localhost:3000/42
// 42
// कर्ल -एक्स GET http://localhost:3000/
//
// कर्ल -एक्स GET http://localhost:3000/7.0
// GET /7.0 नहीं मिला

मिडलवेयर

अनुरोधों या प्रतिक्रियाओं को बदलने के लिए डिज़ाइन किए गए फ़ंक्शन को मिडलवेयर फ़ंक्शन कहा जाता है। Next एक Fiber राउटिंग फ़ंक्शन है जो जब कॉल किया जाता है, वह मौजूदा रूट को मैच करने वाला next फ़ंक्शन निष्पादित करता है।

मिडलवेयर फ़ंक्शन उदाहरण

app.Use(func(c *fiber.Ctx) error {
  // सभी प्रतिक्रियाओं में एक कस्टम हेडर सेट करें:
  c.Set("X-Custom-Header", "नमस्ते, दुनिया")

  // अगले मिडलवेयर पर बढ़ें:
  return c.Next()
})

app.Get("/", func(c *fiber.Ctx) error {
  return c.SendString("नमस्ते, दुनिया!")
})

Use विधि के लिए पथ एक माउंट पथ या प्रिफ़िक्स पथ हो सकता है, और यह मिडलवेयर को उस पथ के साथ शुरू होने वाले अनुरोधों पर ही लागू करने के लिए प्रतिबंधित करता है।

रनटाइम पर रूट सीमाएँ जोड़ना

डिज़ाइन और प्रदर्शन विचारों के कारण, अनुप्रयोग प्रारंभ होने के बाद डाइनामिक रूट को जोड़ना समर्थित नहीं है। कृपया सुनिश्चित करें कि सभी रूट स्थापित कर दी गई हैं पहले एप्लिकेशन प्रारंभ होने से पहले।

समूहीकरण

अगर आपके पास कई एंडप्विंट्स हैं, तो आप Group का उपयोग करके रूट को संगठित कर सकते हैं।

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

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

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

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

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