QCM : Initiation au développement Go — 60 questions

Explication

Le développement informatique regroupe la conception, le codage, les tests et l’intégration d’une solution destinée au client. La configuration d’un réseau et la formation des utilisateurs peuvent accompagner un projet, mais ne définissent pas l’ensemble du développement.

Explication

L’optimisation vise à satisfaire des critères comme le temps d’exécution, la précision et la consommation de ressources. Se concentrer sur l’apparence visuelle ne répond pas directement à ces exigences de performance et de qualité.

Explication

La compilation transforme le code source lisible par l’humain en un fichier binaire exécutable par une machine. La traduction en assembleur et la production d’un fichier objet correspondent à des étapes intermédiaires de la chaîne de production.

Explication

La chaîne suit l’ordre du prétraitement, de la compilation en assembleur, de l’assemblage en fichier objet, puis de l’édition de liens en exécutable. Le fichier objet constitue une étape intermédiaire et n’est pas encore directement exécutable.

Explication

La syntaxe concerne la forme du langage, notamment les accolades et les points-virgules, alors que la sémantique concerne le sens des constructions. Les performances et la génération de fichiers relèvent d’autres aspects du développement et de la compilation.

Explication

Un identificateur C peut contenir des lettres, des chiffres et des soulignements, à condition de ne pas commencer par un chiffre et de ne pas être un mot-clé. « while » est un mot-clé, tandis que « 2total » commence par un chiffre et « valeur-prix » contient un trait d’union.

Explication

Le langage C propose notamment char pour les caractères, int pour les entiers, float et double pour les nombres flottants, ainsi qu'enum, struct et union comme types construits. Les types enum, struct et union ne sont donc pas des types flottants.

Explication

Une chaîne C est un tableau de caractères dont la fin est signalée en mémoire par le caractère \0. Une structure avec une longueur explicite correspond à d’autres représentations possibles, mais ne définit pas la chaîne C classique.

Explication

En C, la valeur 0 est interprétée comme fausse, tandis que toute valeur différente de 0 est interprétée comme vraie. La valeur -1 constitue donc un exemple de valeur vraie, et non une valeur fausse particulière.

Explication

L’instruction if évalue une expression et choisit une première branche si elle est vraie, ou la branche else si elle est fausse. La sélection entre plusieurs constantes correspond plutôt à l’instruction switch.

Explication

L’instruction switch exécute la liste associée à la constante correspondante ou la branche default lorsqu’aucune correspondance n’existe. Elle ne réévalue pas automatiquement l’expression pour rechercher un autre cas.

Explication

La condition d’une boucle while est testée avant le corps, ce qui permet zéro exécution si elle est fausse au départ. Dans une boucle do while, le corps est exécuté avant le test final, donc il s’exécute au moins une fois.

Explication

La fonction func main() contient le code exécuté au lancement d’un programme Go. La déclaration package main identifie le paquet principal, tandis que fmt et fmt.Println servent respectivement à fournir et utiliser l’affichage.

Explication

Les fichiers de code Go présentés commencent par la déclaration package main. Cette ligne identifie le paquet principal et ne doit pas être confondue avec func main(), qui définit la fonction exécutée au lancement.

Explication

Pour exécuter hello.go, il faut se placer dans son répertoire depuis un terminal et lancer la commande go run hello.go. Écrire le code ou importer une bibliothèque prépare le programme, mais ne déclenche pas son exécution.

Explication

Un programme Go standard utilise le paquet main et place le code exécuté au lancement dans la fonction main. Une bibliothèque importée fournit des fonctions, mais elle ne remplace pas la fonction principale du programme.

Explication

Une variable est un emplacement qui conserve une valeur pour permettre sa réutilisation ou sa modification ultérieure. Elle ne définit pas le paquet principal et ne provoque pas automatiquement l’affichage ou la compilation.

Explication

En Go, la déclaration d’une variable utilise var, suivie du nom et du type, lequel reste fixé après la déclaration. Une affectation ultérieure peut modifier la valeur, mais pas le type de la variable.

Explication

Un tableau regroupe plusieurs valeurs de même type et chaque case est repérée par un index entier. Une fonction contient du code, tandis qu’une constante ne représente pas une collection de cases indexées.

Explication

La notation $[]int{1, 2, 3}$ désigne une collection de valeurs de type entier. Le type $[]string$ concerne les chaînes, tandis que les autres formes proposées ne correspondent pas à la déclaration attendue.

Explication

Comme les index commencent à zéro, un tableau de longueur $len(t)$ possède pour dernier index $len(t)-1$. L’expression $len(t)$ désigne une position située après la dernière case.

Explication

La première case d’un tableau porte l’index $0$ et s’écrit donc $t[0]$. L’expression $len(t)-1$ correspond au dernier index lorsque le tableau n’est pas vide, tandis que $len(t)$ dépasse la dernière case.

Explication

La boucle for exécute un bloc plusieurs fois en fonction d’une condition. Une structure if choisit une branche, alors qu'else et switch servent à organiser des choix plutôt qu’à répéter automatiquement un bloc.

Explication

Une boucle for complète initialise la variable, vérifie la condition, exécute le bloc puis applique la mise à jour. La mise à jour intervient donc après le code de l’itération, et non avant son exécution.

Explication

Une variable déclarée dans l’initialisation d’un for appartient à la portée de cette boucle et n’est plus accessible lorsqu’elle se termine. Elle ne devient ni une constante ni une variable globale de la fonction.

Explication

Une conditionnelle if sélectionne le code à exécuter en fonction de la valeur de vérité d’une condition. La répétition d’un bloc relève de for, tandis que la déclaration d’un tableau et le parcours de valeurs répondent à d’autres mécanismes.

Explication

La branche else est choisie lorsque l’expression de la condition est fausse. Lorsque la condition est vraie, c’est le bloc associé à if qui est exécuté, sans passage automatique par else.

Explication

Un switch examine ses case dans l’ordre et exécute le code du premier case dont la condition est vérifiée. Les autres correspondances ne sont donc pas exécutées automatiquement, et default intervient lorsqu’aucun case ne convient.

Explication

Une fonction est un bloc de code nommé pouvant recevoir des arguments et retourner une ou plusieurs valeurs. La fonction principale constitue un cas particulier dans les exemples, mais elle ne définit pas la notion générale de fonction.

Explication

Une déclaration Go utilise func, précise le nom, les types des arguments, le type de retour éventuel et le bloc entre accolades. Les valeurs concrètes sont fournies lors de l’appel et ne font donc pas partie de la déclaration.

Explication

Un type structuré regroupe plusieurs champs, et ces champs peuvent être de types différents. Il ne se définit pas comme une simple adresse mémoire ni comme une liste de valeurs de retour.

Explication

Un pointeur contient l’adresse mémoire d’une valeur plutôt que cette valeur directement. Recevoir une copie d’un argument décrit le passage par valeur, qui est une notion distincte.

Explication

Le passage par valeur transmet une copie de la valeur, de sorte que les modifications locales ne changent pas directement la variable utilisée lors de l’appel. L’accès direct à cette variable nécessite notamment de transmettre un pointeur.

Explication

L’opérateur & appliqué à n produit son adresse, tandis que * appliqué à a déréférence le pointeur et fournit la valeur située à cette adresse. Inverser ces opérateurs confond l’obtention d’une adresse avec l’accès à la valeur pointée.

Explication

Une fonction peut modifier la variable d’origine en recevant un pointeur vers celle-ci et en affectant la valeur déréférencée, par exemple avec *a = 5. Modifier une copie locale ne change pas directement la variable passée à l’appel.

Explication

Une méthode est une fonction particulière associée à un type, ce qui permet de rapprocher les fonctionnalités des données concernées. Elle ne reçoit pas nécessairement un pointeur et ne doit pas forcément retourner une valeur.

Explication

Un récepteur pointeur permet à la méthode d’accéder à la variable d’origine et de la modifier. Avec un récepteur valeur, la méthode travaille sur une copie, comme l’impose le passage des arguments par valeur.

Explication

La longueur d’un array fait partie de son type, alors qu’un slice combine une taille, une capacité et un pointeur vers un tableau sous-jacent. Ainsi, [4]int et [5]int sont des types distincts, contrairement aux slices d’entiers, qui ont le type []int.

Explication

Un array est une valeur normale passée par valeur, donc la fonction reçoit une copie indépendante. Cette règle diffère du comportement d’un slice découpé, qui peut partager le même tableau sous-jacent.

Explication

Un slice contient un entier pour sa taille, un entier pour sa capacité et un pointeur vers un array. Il ne stocke donc pas directement une copie complète des éléments dans sa structure.

Explication

Un slice obtenu par découpage conserve un partage avec le même array sous-jacent que le slice de départ. Une écriture dans une zone commune peut donc être visible depuis l’autre slice, contrairement à une copie indépendante.

Explication

make reçoit le type du slice et sa taille, puis crée ici un slice de cinq entiers. Les éléments sont initialisés à leur valeur par défaut, tandis qu’append sert à ajouter des éléments après la création.

Explication

La taille correspond aux éléments actuellement présents dans le slice, alors que la capacité mesure le nombre d’éléments que son espace sous-jacent peut potentiellement accueillir. Confondre ces deux notions conduit notamment à mal interpréter append.

Explication

Lorsque la capacité est insuffisante, append alloue un espace plus grand, y copie le slice, puis ajoute le nouvel élément. Si la capacité suffit, l’ajout peut se faire dans l’array sous-jacent existant.

Explication

copy reçoit d’abord la destination et ensuite la source, puis écrit les données copiées dans la destination. Cette copie rend les modifications ultérieures de la destination indépendantes de la source.

Explication

go run combine implicitement la compilation et l’exécution du programme. À l’inverse, go build produit un fichier exécutable qui devra être lancé séparément.

Explication

Le tableau os.Args place le nom du programme en première position, à l’indice 0. Les arguments fournis sur la ligne de commande commencent donc à os.Args[1], et non à os.Args[0].

Explication

Les éléments de os.Args sont des chaînes de caractères, y compris lorsqu’ils représentent des nombres. Une conversion explicite est donc nécessaire avant d’effectuer des opérations entières.

Explication

strconv.Atoi convertit la chaîne et retourne simultanément l’entier obtenu ainsi qu’une erreur. Cette erreur permet de détecter une chaîne qui ne peut pas être interprétée comme un entier.

Explication

$os.Create$ retourne le fichier et une erreur, puis la méthode $Close$ doit être appelée après utilisation. La méthode $Scan$ concerne la lecture avec un scanner et ne ferme pas le fichier.

Explication

$fmt.Fprintln$ écrit une ligne dans le fichier indiqué et retourne le nombre d’octets écrits ainsi qu’une erreur. La lecture intégrale relève de $ioutil.ReadFile$, tandis que la lecture ligne par ligne relève notamment de $bufio.Scanner$.

Explication

$ioutil.ReadFile$ lit l’intégralité du fichier identifié par son chemin et retourne son contenu sous forme de $[]byte$ ainsi qu’une erreur. La ligne courante est fournie par $Scanner.Text$, après un appel à $Scan$.

Explication

Un scanner est créé avec $bufio.NewScanner$, $Scan$ lit les lignes successives et $Text$ fournit la ligne courante. $Fprintln$ sert à écrire, tandis que $os.Create$ sert à créer ou ouvrir un fichier.

Explication

Une interface décrit une liste nommée de signatures de méthodes, et un type l’implante en possédant ces méthodes. Elle ne constitue pas une structure concrète contenant directement des attributs.

Explication

Un paramètre d’interface accepte tout type compatible qui implante les méthodes requises. Un paramètre de type concret est davantage restreint et n’accepte pas plusieurs types compatibles de cette manière.

Explication

L’interface $Forme$ exige la méthode $Perimetre() float64$, que $Carre$ et $Cercle$ fournissent. La présence d’un champ commun ou l’utilisation d’une même formule n’est pas nécessaire pour satisfaire cette interface.

Explication

Une interface est une liste nommée de signatures, alors qu’un type l’implante en fournissant les méthodes correspondantes. Elle ne joue donc pas le rôle d’une classe concrète qui stockerait directement les données.

Explication

Tout type qui implante l’interface peut être fourni à la fonction, ce qui permet ici d’utiliser $Carre$ ou $Cercle$. La simple correspondance de nom ne suffit pas : les méthodes requises doivent être présentes.

Explication

Une fonction anonyme est définie sans lui attribuer de nom. Son caractère anonyme ne détermine ni le nombre de paramètres ni le nombre de valeurs retournées.

Explication

Cette signature indique deux paramètres de type entier et une valeur de retour de type entier. Elle ne décrit donc ni deux valeurs retournées ni l’absence de résultat.