SOALAN TEMUDUGA GOLANG BIASA

100 häufig gestellte Fragen und Antworten zu Golang-Interviews

1. Was ist Golang?

Go oder Golang ist eine von Google entwickelte Open-Source-Programmiersprache. Es ist statisch typisiert, kompiliert und für die Erstellung skalierbarer und leistungsstarker Anwendungen konzipiert.

2. Was sind die Hauptfunktionen von Go?

• Parallelitätsunterstützung mit Goroutinen.
• Müllabfuhr.
• Statisch typisiert mit dynamischem Verhalten.
• Einfache Syntax.
• Schnelle Zusammenstellung.

3. Was sind Goroutinen?

Goroutinen sind leichtgewichtige Threads, die von der Go-Laufzeit verwaltet werden. Dabei handelt es sich um Funktionen oder Methoden, die gleichzeitig mit anderen Funktionen oder Methoden ausgeführt werden.

4. Wie erstellt man eine Goroutine?

Verwenden Sie das Schlüsselwort go vor einem Funktionsaufruf:

   go myFunction()

5. Was ist ein Kanal in Go?

Kanäle sind eine Möglichkeit für Goroutinen, miteinander zu kommunizieren und ihre Ausführung zu synchronisieren. Sie ermöglichen das Senden und Empfangen von Werten.

6. Wie deklariert man einen Kanal?

   ch := make(chan int)

7. Was ist ein gepufferter Kanal?

Ein gepufferter Kanal hat eine bestimmte Kapazität und ermöglicht das Senden von Werten, bis der Puffer voll ist. Es ist nicht erforderlich, dass ein Empfänger empfangsbereit ist.

8. Wie schließt man einen Kanal?

Verwenden Sie die Funktion close():

   close(ch)

9. Was ist eine Struktur in Go?

Eine Struktur ist ein benutzerdefinierter Typ, der das Gruppieren von Feldern verschiedener Datentypen in einer einzigen Entität ermöglicht.

10. Wie definiert man eine Struktur?

   type Person struct {
    Name string
    Age  int
   }

11. Was ist eine Schnittstelle in Go?

Eine Schnittstelle in Go ist ein Typ, der eine Reihe von Methodensignaturen angibt. Es ermöglicht Polymorphismus durch die Definition von Verhalten.

12. Wie implementiert man eine Schnittstelle?

Ein Typ implementiert eine Schnittstelle, indem er alle seine Methoden implementiert:

    type Animal interface {
       Speak() string
    }

    type Dog struct{}

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

13. Was ist das Schlüsselwort defer?

Defer wird verwendet, um die Ausführung einer Funktion zu verschieben, bis die umgebende Funktion zurückkehrt.

14. Wie funktioniert die Aufschiebung?

Verzögerte Funktionen werden in der LIFO-Reihenfolge (Last In, First Out) ausgeführt:

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

15. Was ist ein Zeiger in Go?

Ein Zeiger enthält die Speicheradresse eines Werts. Es wird verwendet, um Referenzen zu übergeben, anstatt Werte zu kopieren.

16. Wie deklariert man einen Zeiger?

   var p *int
   p = &x

17. Was ist der Unterschied zwischen Neu und Fabrikat?

• new weist Speicher zu, initialisiert den Wert jedoch nicht.
• make reserviert und initialisiert Speicher für Slices, Maps und Kanäle.

18. Was ist ein Slice in Go?

Ein Slice ist ein Array mit dynamischer Größe, das eine flexiblere Möglichkeit bietet, mit Sequenzen von Elementen zu arbeiten.

19. Wie erstellt man ein Slice?

   s := make([]int, 0)

20. Was ist eine Karte in Go?

Eine Karte ist eine Sammlung von Schlüssel-Wert-Paaren.

21. Wie erstellt man eine Karte?

   m := make(map[string]int)

22. Was ist die Select-Anweisung?

Auswahl ermöglicht es einer Goroutine, auf mehrere Kommunikationsvorgänge zu warten.

23. Wie verwenden Sie select?

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

24. Was ist ein Nullkanal?

Ein Nullkanal blockiert sowohl Sende- als auch Empfangsvorgänge.

25. Was ist die Init-Funktion?

init ist eine spezielle Funktion, die Variablen auf Paketebene initialisiert. Es wird vor main ausgeführt.

26. Können mehrere Init-Funktionen vorhanden sein?

Ja, aber sie werden in der Reihenfolge ausgeführt, in der sie erscheinen.

27. Was ist eine leere Struktur {}?

Eine leere Struktur verbraucht null Byte Speicherplatz.

28. Wie führen Sie die Fehlerbehandlung in Go durch?

Indem Sie einen Fehlertyp zurückgeben und ihn überprüfen mit:

   if err != nil {
    return err
   }

29. Was ist eine Typzusicherung?

Typzusicherung wird verwendet, um den zugrunde liegenden Wert einer Schnittstelle zu extrahieren:

   value, ok := x.(string)

30. Was ist der Befehl go fmt?

gehen Sie zu fmt-Formaten. Gehen Sie zum Quellcode gemäß dem Standardstil.

31. Was ist der Zweck von Go Mod?

go mod verwaltet Modulabhängigkeiten in Go-Projekten.

32. Wie erstellt man ein Modul?

  go mod init module-name

33. Was ist ein Paket in Go?

Ein Paket ist eine Möglichkeit, zusammengehörige Go-Dateien zu gruppieren.

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.

Atas ialah kandungan terperinci SOALAN TEMUDUGA GOLANG BIASA. Untuk maklumat lanjut, sila ikut artikel berkaitan lain di laman web China PHP!