Entretien technique Go

Questions theoriques frequentes

Q: Qu'est-ce que la concurrence en Go ? La concurrence en Go est gérée par le langage via des goroutines et des channels. Les goroutines sont légers et peuvent être lancées pour exécuter du code concurrent, tandis que les channels permettent de synchroniser les données entre les goroutines.

Q: Quelle est la différence entre make et new en Go ? new(T) alloue un objet T initialisé à zéro et retourne son pointeur. Par exemple : i := new(int). En revanche, make(T) est spécifique aux types slices, maps et channels, créant une structure initiale prête à être utilisée.

Exercices de code classiques

E1: Écrivez une fonction qui renvoie la somme des nombres pairs d'un slice.

func sumEvenNumbers(slice []int) int {
    sum := 0
    for _, num := range slice {
        if num % 2 == 0 {
            sum += num
        }
    }
    return sum
}

E2: Implémentez une fonction qui retourne la plus grande valeur dans un slice.

func maxInSlice(slice []int) int {
    max := slice[0]
    for _, value := range slice {
        if value > max {
            max = value
        }
    }
    return max
}

E3: Créez une fonction qui prend deux slices et retourne un nouveau slice contenant les éléments communs.

func commonElements(slice1, slice2 []int) []int {
    var result []int
    for _, value := range slice1 {
        if contains(slice2, value) {
            result = append(result, value)
        }
    }
    return result
}

func contains(slice []int, element int) bool {
    for _, e := range slice {
        if e == element {
            return true
        }
    }
    return false
}

E4: Implémentez une fonction qui renvoie la valeur maximale et sa position dans un slice.

func maxAndIndex(slice []int) (int, int) {
    max := slice[0]
    index := 0
    for i, value := range slice {
        if value > max {
            max = value
            index = i
        }
    }
    return max, index
}

E5: Écrivez une fonction qui trie un slice d'entiers en utilisant l'algorithme de tri rapide.

func quickSort(slice []int) []int {
    if len(slice) <= 1 {
        return slice
    }
    pivot := slice[0]
    less, equal, greater := make([]int, 0), make([]int, 0), make([]int, 0)
    for _, value := range slice {
        switch {
        case value < pivot:
            less = append(less, value)
        case value == pivot:
            equal = append(equal, value)
        default:
            greater = append(greater, value)
        }
    }
    return append(append(quickSort(less), equal...), quickSort(greater)...)
}

Pieges courants en entretien

P1: Confusion entre := et = := est utilisé pour déclarer et initialiser une variable locale, tandis que = est utilisé pour affecter une valeur à une variable déjà déclarée.

P2: Ignorance de la panique et du recupération avec defer, panic, recover En Go, il est important de comprendre comment gérer les erreurs grâce aux paniques. Utiliser defer, panic, et recover permet de récupérer une erreur après qu'elle ait été levée.

P3: Mauvaise utilisation des channels Les channels sont essentiels pour la communication entre goroutines. Il est crucial d'attendre que les channels soient vides ou pleins avant d'y écrire ou de les lire, sinon cela peut entraîner une deadlock.

Complexite algorithmique

TC: Complexité temporelle

• O(1): Opération constante (ex: accès à un élément dans un array)
• O(n): Opération linéaire (ex: parcours d'un slice)
• O(log n): Opération logarithmique (ex: recherche binaire)
• O(n^2): Opération quadratique (ex: deux boucles imbriquées sur un slice)

SC: Complexité spatiale

• O(1): Utilisation constante de la mémoire
• O(n): Utilisation linéaire de la mémoire (ex: création d'un nouveau slice)
• O(log n): Utilisation logarithmique de la mémoire (ex: pile d'appel pour une recherche binaire)

Concepts avances a connaitre

C1: Goroutines et channels Les goroutines sont des threads légers qui permettent une exécution concurrente, tandis que les channels synchronisent les données entre les goroutines.

C2: Pointeurs nil Un pointeur nul est un pointeur qui ne pointe sur aucune valeur. Il est important de vérifier si un pointeur est nul avant de le déréférencer.

C3: Slices et maps dynamiques Les slices en Go sont des structures dynamiques qui peuvent croître ou diminuer en taille au fil du temps, tandis que les maps permettent une association clé-valeur avec des clés de type générique.

C4: Pointeurs vers des structures En Go, les pointeurs vers des structures permettent d'accéder et de modifier directement les champs d'une structure sans avoir à copier toute la structure.

C5: Type alias Les types alias en Go permettent de créer un nouveau nom pour un type existant, ce qui peut rendre le code plus lisible et plus facile à comprendre.

Conseils pratiques

T1: Préparez-vous avec des exemples concrets Pratiquez sur des problèmes réels plutôt que de simplement rester théorique. Avoir des exemples concrets montre votre compréhension pratique du langage.

T2: Explicitez vos raisonnements Lorsqu'on vous pose une question, expliquez clairement comment vous avez abordé le problème et pourquoi vous avez choisi une certaine solution. Cela montre votre pensée critique et votre capacité à résoudre des problèmes.

T3: Soyez proactif Si vous n'êtes pas sûr d'une réponse, n'hésitez pas à demander plus de détails ou à faire des recherches pour mieux comprendre la situation. Cela montre votre engagement et votre volonté d'apprendre.

T4: Montrez vos connaissances sur les bonnes pratiques Pratiquez des techniques de codage efficaces comme la modularisation, le test unitaire et la documentation. Cela montre que vous êtes conscient des meilleures pratiques en programmation.

T5: Soyez confiant Confiance fait partie intégrante d'un bon entretien. Soyez confiant dans vos capacités et n'hésitez pas à affirmer votre expertise sur un sujet spécifique si c'est le cas.