GIN-Gonic

Question 1

What is the Gin framework

Answer 1

“A high-performance HTTP web framework for Go designed for building fast and efficient web apps/APIs”

Question 2

How do you install Gin

Answer 2

“Run the command: go get -u github.com/gin-gonic/gin”

Question 3

What does the gin.Default() function do

Answer 3

“Creates a Gin router with default middleware (logging and recovery)”

Question 4

How to define a GET route for the root path in Gin

Answer 4

“r.GET(“/”, handlerFunction)”

Question 5

What method sends a plain text response in Gin

Answer 5

“c.String(statusCode, content)”

Question 6

How to start a Gin server on port 8080

Answer 6

“r.Run(“:8080”)”

Question 7

How to extract a path parameter named ““name”” in Gin

Answer 7

“Use c.Param(““name””)”

Question 8

How to access a query parameter ““q”” in Gin

Answer 8

“Use c.Query(““q””)”

Question 9

What is middleware in Gin

Answer 9

“Functions that process requests before reaching the final handler (e.g., logging/auth)”

Question 10

How to create custom middleware for authentication

Answer 10

“Define a function that checks tokens and uses c.AbortWithStatusJSON() or c.Next()”

Question 11

How to apply middleware to a specific route

Answer 11

“Add the middleware as an argument in the route definition: r.GET(“/secure”, AuthMiddleware, handler)”

Question 12

What are route groups used for in Gin

Answer 12

“To organize routes with shared prefixes or middleware”

Question 13

How to serve static files from a “./static” directory

Answer 13

“Use r.Static(“/static”, “./static”)”

Question 14

How to bind JSON data to a struct in Gin

Answer 14

“Use c.ShouldBindJSON(&structVariable) inside the handler”

Question 15

What is the purpose of binding tags like ““binding:”“required”””

Answer 15

“To enforce validation rules for incoming data”

Question 16

How to handle file uploads in Gin

Answer 16

“Use c.FormFile(““file””) and c.SaveUploadedFile()”

Question 17

How to send a JSON response in Gin

Answer 17

“Use c.JSON(statusCode, data)”

Question 18

How to render HTML templates in Gin

Answer 18

“Load templates with r.LoadHTMLGlob() and use c.HTML() in handlers”

Question 19

What does the Recovery middleware do

Answer 19

“Handles panics gracefully and prevents server crashes”

Question 20

How to create a custom validation rule like ““is_cool”” in Gin

Answer 20

“Register it via validator.Validate.RegisterValidation()”

Question 21

How to test Gin handlers

Answer 21

“Use Go’s httptest package to simulate requests and record responses”

Question 22

What command builds a production binary for a Gin app

Answer 22

“go build -o app”

Question 23

How to run Gin in production mode

Answer 23

“Set environment variable: GIN_MODE=release”

Question 24

Name two best practices for Gin deployment

Answer 24

“Use structured logging and implement graceful shutdown”

Question 25

What library can be used for rate limiting in Gin

Answer 25

github.com/ulule/limiter/v3

Question 27

What is the purpose of the `Param(key string) string` method in Gin's `Context`?

Answer 27

Extracts path parameters from the URL. For example, in the route `/user/:id`, calling `c.Param(\"id\")` returns the value associated with `id`.

Question 28

How do you retrieve query parameters using Gin's `Context`?

Answer 28

Use the `Query(key string) string` method. For instance, for the URL `/search?q=gin`, `c.Query(\"q\")` returns `\"gin\"`.

Question 29

Which method in Gin's `Context` is used to obtain request headers?

Answer 29

The `GetHeader(key string) string` method retrieves the value of the specified request header.

Question 30

How can you bind a JSON request body to a struct in Gin?

Answer 30

By using the `ShouldBindJSON(obj interface{}) error` method. Example: `err := c.ShouldBindJSON(&user)` binds the JSON body to the `user` struct.

Question 31

What is the function of the `FormFile(name string) (*multipart.FileHeader, error)` method?

Answer 31

It retrieves uploaded files from a form. For example, `file, _ := c.FormFile(\"avatar\")` gets the file associated with the form field named `\"avatar\"`.

Question 32

How do you send a JSON response using Gin's `Context`?

Answer 32

Utilize the `JSON(code int, obj interface{})` method. Example: `c.JSON(200, gin.H{\"status\": \"success\"})` sends a JSON response with a status of `\"success\"`.

Question 33

What method would you use to render HTML templates in Gin?

Answer 33

The `HTML(code int, name string, obj interface{})` method. After loading templates with `r.LoadHTMLGlob(\"templates/*\")`, you can render them using `c.HTML(200, \"index.html\", gin.H{\"title\": \"Home\"})`.

Question 34

How can you send a plain text response in Gin?

Answer 34

"By using the `String(code int, format string, values ...interface{})` method. Example: `c.String(200, \"Hello

Question 35

What is the purpose of the `Redirect(code int, location string)` method in Gin?

Answer 35

It redirects the client to a new URL. For instance, `c.Redirect(301, \"/login\")` redirects the client to the `/login` page with a 301 status code.

Question 36

How do you bind path parameters to a struct in Gin?

Answer 36

Use the `ShouldBindUri(obj interface{}) error` method. Example: `c.ShouldBindUri(&userURI)` binds `/user/:id` to `UserURI.ID`.

Question 37

Which method allows binding of query parameters to a struct in Gin?

Answer 37

The `ShouldBindQuery(obj interface{}) error` method. For example, `c.ShouldBindQuery(&filter)` binds `?page=2` to `Filter.Page`.

Question 38

What does the `Next()` method do in Gin's middleware?

Answer 38

It passes control to the next handler in the middleware chain. Example: `c.Next()` proceeds to the next handler after executing the current middleware logic.

Question 39

When would you use the `Abort()` method in Gin?

Answer 39

To stop the current handler chain, often used in middleware. For instance, if a user is not authenticated, `c.Abort()` can halt further processing.

Question 40

How can you abort the handler chain and send a JSON response immediately in Gin?

Answer 40

By using the `AbortWithStatusJSON(code int, obj interface{})` method. Example: `c.AbortWithStatusJSON(400, gin.H{\"error\": \"Invalid input\"})`.

Question 41

What is the function of the `SaveUploadedFile(file *multipart.FileHeader, dst string) error` method?

Answer 41

It saves an uploaded file to disk. For example, `c.SaveUploadedFile(file, \"uploads/avatar.jpg\")` saves the uploaded file to the specified path.

Question 42

How do you serve a file as the response in Gin?

Answer 42

Use the `File(filepath string)` method. Example: `c.File(\"static/image.png\")` serves the file located at `\"static/image.png\"`.

Question 43

Which method in Gin's `Context` allows you to add an error to the context?

Answer 43

The `Error(err error)` method. Example: `c.Error(errors.New(\"validation failed\"))` adds an error to the context.

Question 44

How can you retrieve all errors attached to the context in Gin?

Answer 44

By accessing the `Errors` field. Example: `errors := c.Errors` retrieves all errors associated with the context.

Question 45

What is the purpose of the `Get(key string) (value interface{}, exists bool)` method in Gin?

Answer 45

It retrieves data stored in the context, often set by middleware. Example: `user, exists := c.Get(\"user\")` gets the `\"user\"` value if it exists.

Question 46

How do you store data in the context for later use in Gin?

Answer 46

Use the `Set(key string, value interface{})` method. Example: `c.Set(\"request_id\", \"123\")` stores the value `\"123\"` with the key `\"request_id\"`.

Question 47

Which method retrieves the client's IP address in Gin?

Answer 47

The `ClientIP() string` method. Example: `ip := c.ClientIP()` gets the client's IP address, accounting for proxies.

Question 48

How can you determine the MIME type of the request in Gin?

Answer 48

By using the `ContentType() string` method. Example: `if c.ContentType() == \"application/json\" { // Handle JSON }` checks if the request is of type `\"application/json\"`.

Question 49

What is `gin.HandlerFunc`?

Answer 49

A function type in Gin that handles HTTP requests: `type HandlerFunc func(*gin.Context)`.

Question 50

Why return `gin.HandlerFunc` instead of defining it directly?

Answer 50

To enable dependency injection (e.g., pass a database) or create reusable/closured handlers.

Question 51

What is a key use case for returning `gin.HandlerFunc`?

Answer 51

Injecting dependencies like a database: `func GetUser(db *DB) gin.HandlerFunc { ... }`.

Question 52

What happens if you don’t return `gin.HandlerFunc`?

Answer 52

You lose flexibility (e.g., can’t inject dependencies) and must define handlers statically.

Question 53

How do you set up a route with a handler that returns `gin.HandlerFunc`?

Answer 53

`router.GET(\"/path\", GetUser())` (note the `()` to invoke the factory function).

Question 54

What is a key takeaway about `gin.HandlerFunc`?

Answer 54

Returning it acts like a factory, creating configured handlers for routes.

Question 55

What HTTP status code should authorization failures use?

Answer 55

`http.StatusForbidden` (403), not `BadRequest` (400).

Question 56

How to set up a route with a direct handler function?

Answer 56

`router.GET(\"/path\", GetUser)` (no `()`, passes function directly).

Question 57

What analogy explains returning `gin.HandlerFunc`?

Answer 57

Think of it as a factory producing handlers with dependencies pre-configured.

Question 58

What’s wrong with `CheckUserType(c, userType)` in `MatchUserTypeToUid`?

Answer 58

It’s redundant; `userType` is already known, so the check always passes.