QUESTIONS COMMUNES D'ENTRETIEN AVEC GOLANG

100 questions et réponses courantes pour les entretiens avec Golang

1. Qu'est-ce que Golang ?

Go, ou Golang, est un langage de programmation open source développé par Google. Il est typé statiquement, compilé et conçu pour créer des applications évolutives et hautes performances.

2. Quelles sont les principales fonctionnalités de Go ?

• Prise en charge de la concurrence à l'aide de Goroutines.
• Collecte des déchets.
• Tacté statiquement avec un comportement dynamique.
• Syntaxe simple.
• Compilation rapide.

3. Que sont les Goroutines ?

Les Goroutines sont des threads légers gérés par le runtime Go. Ce sont des fonctions ou des méthodes qui s'exécutent simultanément avec d'autres fonctions ou méthodes.

4. Comment créer une Goroutine ?

Utilisez le mot-clé go avant un appel de fonction :

   go myFunction()

5. Qu'est-ce qu'une chaîne dans Go ?

Les canaux sont un moyen pour les Goroutines de communiquer entre eux et de synchroniser leur exécution. Ils permettent d'envoyer et de recevoir des valeurs.

6. Comment déclarer une chaîne ?

   ch := make(chan int)

7. Qu'est-ce qu'un canal tamponné ?

Un canal tamponné a une capacité spécifiée et permet l'envoi de valeurs jusqu'à ce que le tampon soit plein. Il n'est pas nécessaire qu'un récepteur soit prêt à recevoir.

8. Comment fermer une chaîne ?

Utilisez la fonction close() :

   close(ch)

9. Qu'est-ce qu'une structure dans Go ?

Une structure est un type défini par l'utilisateur qui permet de regrouper des champs de différents types de données en une seule entité.

10. Comment définir une structure ?

   type Person struct {
    Name string
    Age  int
   }

11. Qu'est-ce qu'une interface dans Go ?

Une interface dans Go est un type qui spécifie un ensemble de signatures de méthodes. Il permet le polymorphisme en définissant le comportement.

12. Comment implémenter une interface ?

Un type implémente une interface en implémentant toutes ses méthodes :

    type Animal interface {
       Speak() string
    }

    type Dog struct{}

    func (d Dog) Speak() string {
        return "Woof!"
    }

13. Quel est le mot-clé defer ?

defer est utilisé pour reporter l'exécution d'une fonction jusqu'au retour de la fonction environnante.

14. Comment fonctionne le report ?

Les fonctions différées sont exécutées dans l'ordre LIFO (Last In, First Out) :

   defer fmt.Println("world")
   fmt.Println("hello")
   // Output: hello world

15. Qu'est-ce qu'un pointeur dans Go ?

Un pointeur contient l'adresse mémoire d'une valeur. Il est utilisé pour transmettre des références au lieu de copier des valeurs.

16. Comment déclarer un pointeur ?

   var p *int
   p = &x

17. Quelle est la différence entre neuf et marque ?

• new alloue de la mémoire mais n'initialise pas la valeur.
• make alloue et initialise la mémoire pour les tranches, les cartes et les canaux.

18. Qu'est-ce qu'une tranche au Go ?

Une tranche est un tableau de taille dynamique qui offre un moyen plus flexible de travailler avec des séquences d'éléments.

19. Comment créer une tranche ?

   s := make([]int, 0)

20. Qu'est-ce qu'une carte dans Go ?

Une carte est une collection de paires clé-valeur.

21. Comment créer une carte ?

   m := make(map[string]int)

22. Qu'est-ce que l'instruction select ?

select permet à une Goroutine d'attendre plusieurs opérations de communication.

23. Comment utilisez-vous Select ?

   select {
    case msg := <-ch:
        fmt.Println(msg)
    default:
        fmt.Println("No message received")
    }

24. Qu'est-ce qu'un canal nul ?

Un canal nul bloque les opérations d'envoi et de réception.

25. Quelle est la fonction init ?

init est une fonction spéciale qui initialise les variables au niveau du package. Il est exécuté avant main.

26. Pouvez-vous avoir plusieurs fonctions d'initialisation ?

Oui, mais ils seront exécutés dans l'ordre dans lequel ils apparaissent.

27. Qu'est-ce qu'une structure vide {} ?

Une structure vide ne consomme aucun octet de stockage.

28. Comment effectuez-vous la gestion des erreurs dans Go ?

En renvoyant un type d'erreur et en le vérifiant à l'aide de :

   if err != nil {
    return err
   }

29. Qu'est-ce que l'assertion de type ?

L'assertion de type est utilisée pour extraire la valeur sous-jacente d'une interface :

   value, ok := x.(string)

30. Qu'est-ce que la commande go fmt ?

go fmt formats Go code source selon le style standard.

31. Quel est le but du mod go ?

go mod gère les dépendances des modules dans les projets Go.

32. Comment créer un module ?

  go mod init module-name

33. Qu'est-ce qu'un package dans Go ?

Un package est un moyen de regrouper des fichiers Go associés.

34. How do you import a package?

  import "fmt"

35. What are the visibility rules in Go?

• Exported identifiers start with an uppercase letter.
• Unexported identifiers start with a lowercase letter.

36. What is the difference between var and :=?

• var is used for variable declaration with explicit types.
• := is used for short variable declaration with inferred types.

37. What is a panic in Go?

panic is used to terminate the program immediately when an error occurs.

38. What is recover?

recover is used to regain control after a panic.

39. How do you use recover?

It is used inside a deferred function:

  defer func() {
    if r := recover(); r != nil {
        fmt.Println("Recovered:", r)
    }
   }()

40. What is a constant in Go?

Constants are immutable values declared using the const keyword.

41. How do you declare a constant?

  const Pi = 3.14

42. What are iota in Go?

iota is a constant generator that increments by 1 automatically.

43. What is go test?

go test is used to run unit tests written in Go.

44. How do you write a test function?

Test functions must start with Test:

  func TestAdd(t *testing.T) {
    result := Add(2, 3)
    if result != 5 {
        t.Errorf("expected 5, got %d", result)
    }
  }

45. What is benchmarking in Go?

Benchmarking is used to measure the performance of a function using go test.

46. How do you write a benchmark function?

Benchmark functions must start with Benchmark:

    func BenchmarkAdd(b *testing.B) {
        for i := 0; i < b.N; i++ {
            Add(2, 3)
        }
    }

47. What is a build constraint?

Build constraints are used to include or exclude files from the build process based on conditions.

48. How do you set a build constraint?

Place the constraint in a comment at the top of the file:

    // +build linux

49. What are slices backed by arrays?

Slices are built on top of arrays and provide a dynamic view over the array.

50. What is garbage collection in Go?

Go automatically manages memory using garbage collection, which frees up memory that is no longer in use.

51. What is the context package in Go?

The context package is used for managing deadlines, cancellation signals, and request-scoped values. It helps in controlling the flow of Goroutines and resources.

52. How do you use context in Go?

   ctx, cancel := context.WithTimeout(context.Background(), time.Second)
   defer cancel()

53. What is sync.WaitGroup?

sync.WaitGroup is used to wait for a collection of Goroutines to finish executing.

54. How do you use sync.WaitGroup?

    var wg sync.WaitGroup
    wg.Add(1)
    go func() {
        defer wg.Done()
        // Do some work
    }()
    wg.Wait()

55. What is sync.Mutex?

sync.Mutex provides a lock mechanism to protect shared resources from concurrent access.

56. How do you use sync.Mutex?

   var mu sync.Mutex
    mu.Lock()
    // critical section
    mu.Unlock()

57. What is select used for with channels?

select is used to handle multiple channel operations simultaneously, allowing a Goroutine to wait for multiple communication operations.

58. What is go generate?

go generate is a command for generating code. It reads special comments within the source code to execute commands.

59. What are method receivers in Go?

Method receivers specify the type the method is associated with, either by value or pointer:

    func (p *Person) GetName() string {
        return p.Name
    }

60. What is the difference between value and pointer receivers?

• Value receivers get a copy of the original value.
• Pointer receivers get a reference to the original value, allowing modifications.

61. What are variadic functions?

Variadic functions accept a variable number of arguments:

    func sum(nums ...int) int {
        total := 0
        for _, num := range nums {
            total += num
        }
        return total
   }

62. What is a rune in Go?

A rune is an alias for int32 and represents a Unicode code point.

63. What is a select block without a default case?

A select block without a default will block until one of its cases can proceed.

64. What is a ticker in Go?

A ticker sends events at regular intervals:

    ticker := time.NewTicker(time.Second)

65. How do you handle JSON in Go?

Use the encoding/json package to marshal and unmarshal JSON:

    jsonData, _ := json.Marshal(structure)
    json.Unmarshal(jsonData, &structure)

66. What is go vet?

go vet examines Go source code and reports potential errors, focusing on issues that are not caught by the compiler.

67. What is an anonymous function in Go?

An anonymous function is a function without a name and can be defined inline:

    func() {
        fmt.Println("Hello")
    }()

68. What is the difference between == and reflect.DeepEqual()?

• == checks equality for primitive types.
• reflect.DeepEqual() compares deep equality of complex types like slices, maps, and structs.

69. What is a time.Duration in Go?

time.Duration represents the elapsed time between two points and is a type of int64.

70. How do you handle timeouts with context?

Use context.WithTimeout to set a timeout:

    ctx, cancel := context.WithTimeout(context.Background(), time.Second)
    defer cancel()

71. What is a pipeline in Go?

A pipeline is a series of stages connected by channels, where each stage is a collection of Goroutines that receive values from upstream and send values downstream.

72. What is pkg directory convention in Go?

pkg is a directory used to place reusable packages. It is a common convention but not enforced by Go.

73. How do you debug Go code?

Use tools like dlv (Delve), print statements, or the log package.

74. What is type alias in Go?

type aliasing allows you to create a new name for an existing type:

  type MyInt = int

75. What is the difference between Append and Copy in slices?

• append adds elements to a slice and returns a new slice.
• copy copies elements from one slice to another.

slice1 := []int{1, 2}
slice2 := []int{3, 4}
copy(slice2, slice1) // [1, 2]

76. What is the purpose of go doc?

go doc is used to display documentation for a Go package, function, or variable.

77. How do you handle panics in production code?

Use recover to gracefully handle panics and log them for debugging:

defer func() {
    if r := recover(); r != nil {
        log.Println("Recovered from:", r)
    }
}()

78. What is the difference between map and struct?

• map is a dynamic data structure with key-value pairs.
• struct is a static data structure with fixed fields.

79. What is unsafe package?

The unsafe package allows low-level memory manipulation. It is not recommended for regular use.

80. How do you achieve dependency injection in Go?

Use interfaces and constructor functions to pass dependencies, allowing easy mocking and testing.

type HttpClient interface{}

func NewService(client HttpClient) *Service {
    return &Service{client: client}
}

81. How does Goroutine differ from a thread?

A Goroutine is a lightweight thread managed by the Go runtime. It differs from OS threads as it uses a smaller initial stack (2KB) and is multiplexed onto multiple OS threads. This makes Goroutines more efficient for handling concurrency.

82. How does the Go scheduler work?

The Go scheduler uses a work-stealing algorithm with M:N scheduling, where M represents OS threads and N represents Goroutines. It schedules Goroutines across available OS threads and CPUs, aiming to balance workload for optimal performance.

83. What is a memory leak, and how do you prevent it in Go?

A memory leak occurs when allocated memory is not released. In Go, it can happen if Goroutines are not terminated or references to objects are kept unnecessarily. Use defer for cleanup and proper cancellation of Goroutines to prevent leaks.

84. How does garbage collection work in Go?

Go uses a concurrent, mark-and-sweep garbage collector. It identifies reachable objects during the mark phase and collects the unreachable ones during the sweep phase, allowing other Goroutines to continue running during collection.

85. Explain differences between sync.Mutex and sync.RWMutex.

• sync.Mutex is used to provide exclusive access to a shared resource.
• sync.RWMutex allows multiple readers or one writer at a time, providing better performance for read-heavy workloads.

86. What are race conditions, and how do you detect them in Go?

Race conditions occur when multiple Goroutines access a shared variable concurrently without proper synchronization. Use go run -race to detect race conditions in Go programs.

87. What is a struct tag, and how is it used?

Struct tags provide metadata for struct fields, often used for JSON serialization:

type User struct {
    Name string `json:"name"`
    Age  int    `json:"age"`
}

88. How do you create a custom error in Go?

Create a custom error by implementing the error interface:

type MyError struct {
    Msg string
}
func (e *MyError) Error() string {
    return e.Msg
}

89. What is a nil pointer dereference, and how do you avoid it?

A nil pointer dereference occurs when you attempt to access the value a nil pointer points to. Avoid this by checking for nil before using pointers.

90. Explain the difference between sync.Pool and garbage collection.

sync.Pool is used for reusing objects and reducing GC pressure. It provides a way to cache reusable objects, unlike the GC which automatically frees unused memory.

91. How do you implement a worker pool in Go?

Use channels to distribute tasks and manage worker Goroutines:

jobs := make(chan int, 100)
for w := 1; w <= 3; w++ {
    go worker(w, jobs)
}

92. What is reflect in Go?

The reflect package allows runtime inspection of types and values. It is used for dynamic operations like inspecting struct fields or methods.

93. What is the difference between buffered and unbuffered channels?

• A buffered channel has a capacity, allowing Goroutines to send data without blocking until the buffer is full.
• An unbuffered channel has no capacity and blocks until the receiver is ready.

94. How do you avoid Goroutine leaks?

Ensure Goroutines are terminated using context for cancellation or using timeouts with channels.

95. What are the key differences between panic and error?

• error is used for handling expected conditions and can be returned.
• panic is used for unexpected conditions and stops the normal flow of execution.

96. Explain the io.Reader and io.Writer interfaces.

io.Reader has a Read method for reading data, while io.Writer has a Write method for writing data. They form the basis of Go's I/O abstractions.

97. What is a nil value interface, and why is it problematic?

A nil value interface is an interface with a nil underlying value. It can cause unexpected behavior when check nil, as an interface with a nil underlying value is not equal to nil.

type MyInterface interface{}
var i MyInterface
var m map[string]int
i = m // This case, m is nil but i not nil

To handle above case, we could use interface assertion as following

    if v, ok := i.(map[string]int); ok && v != nil {
        fmt.Printf("value not nil: %v\n", v)
    }

98. How do you prevent deadlocks in concurrent Go programs?

To prevent deadlocks, ensure that:

• Locks are always acquired in the same order across all Goroutines.
• Use defer to release locks.
• Avoid holding a lock while calling another function that might acquire the same lock.
• Limit the use of channels within locked sections.

99. How do you optimize the performance of JSON encoding/decoding in Go?

• Use jsoniter or easyjson libraries for faster encoding/decoding than the standard encoding/json.
• Predefine struct fields using json:"field_name" tags to avoid reflection costs.
• Use sync.Pool to reuse json.Encoder or json.Decoder instances when encoding/decoding large JSON data repeatedly.

100. What is the difference between GOMAXPROCS and runtime.Gosched()?

• GOMAXPROCS controls the maximum number of OS threads that can execute Goroutines concurrently. It allows adjusting the parallelism level.
• runtime.Gosched() yields the processor, allowing other Goroutines to run. It does not suspend the current Goroutine but instead gives a chance for the Go scheduler to run other Goroutines.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!