Pourquoi la fin des espaces blancs est-elle une grosse affaire? [fermé]

Les espaces de fin sont un problème suffisant pour les programmeurs car les éditeurs tels qu'Emacs ont des fonctions spéciales qui le soulignent ou le suppriment automatiquement, et de nombreuses normes de codage exigent que vous en éliminiez toutes les occurrences. Je ne sais pas trop pourquoi. Je peux penser à une raison pratique d’éviter les espaces inutiles: si les utilisateurs ne le font pas avec prudence, ils peuvent le modifier entre deux commits, puis nous obtenons des différences polluées par des lignes apparemment inchangées, simplement parce que ajouté un espace.

Cela semble déjà être une bonne raison de l'éviter, mais je veux voir s'il y a plus que cela. Alors, pourquoi est-ce que traîner les blancs est un si gros problème?

Raisons que c'est important pour moi:

• Lorsque je clique sur la touche "Fin", je m'attends à ce que le curseur se positionne à la fin de la ligne (en fonction de l'éditeur que j'utilise et de sa configuration) et j'espère pouvoir commencer à taper tout de suite. Si le curseur y arrive et que je dois supprimer 3 ou 4 caractères, c'est embêtant. Surtout s'il y a incompatibilité dans le (s) fichier (s).

• Lorsque des littéraux de chaîne recouvrent plusieurs lignes, les espaces de fin peuvent donner à la chaîne en sortie un aspect incorrect lorsqu'elle est utilisée.

Bien qu’il ne s’agisse pas strictement de programmation, les espaces peuvent gâcher sérieusement la saisie des données s’il existe un fichier de fin / tête dans un fichier qui sera analysé et utilisé comme autre chose. C'est ce qui se produit le plus souvent lorsqu'un fichier d'entrée généré propre est souillé par quelqu'un qui le modifie dans Excel ou quelque chose de ce type, puis les espaces de fin (et autres problèmes de formatage) peuvent s'y glisser.

Je déteste vraiment traîner les espaces, mais la raison exacte est un peu vague.

Je suppose que l’origine de ce sentiment n’est pas dans la programmation, mais dans le domaine de la publication assistée par ordinateur. Avez-vous déjà eu un document dactylographié par quelqu'un d'autre qui devait être composé dans une publication? Dans toutes les publications modernes, en particulier lors de l'utilisation de colonnes, il est d'usage de faire en sorte que les phrases se succèdent dans un paragraphe, sans créer de nouvelle ligne pour chaque phrase. Eh bien, quand il y a des espaces à la fin, il faut beaucoup plus d'efforts pour bien faire les choses (beaucoup d'actions de recherche et de remplacement qui éliminent les doubles espaces, etc.).

Autres raisons (en programmation), ce ne sont pas de bonnes raisons, je le sais, mais elles dérangent mon psychisme subconscient de manière si aggravante et intense qu'elles m'obligent à l'éliminer:

• Cela prend plus d'espace de stockage que nécessaire
• L'analyseur devra sauter un caractère supplémentaire sans raison valable lors de la compilation
• Certains éditeurs peuvent ajouter une ligne vierge supplémentaire lorsque WordWrap est activé et que l'espace de fin ne correspond pas.

Oui oui je sais! Je sais, ce sont des raisons indésirables. Je ne suis pas un perfectionniste, mais ... eh bien peut-être que je le suis?

La dernière raison à laquelle je peux penser est un mouvement de curseur incohérent. On a l'impression que le curseur est suspendu dans les airs à la fin d'une ligne. Chaque pas à droite peut le faire chuter ou le faire glisser plus loin encore, il semble instable (comme ces blocs invisibles ou en train de disparaître que Super Mario sautait dessus).

Probablement que je peux être diagnostiqué avec trailpacefobia?

Beaucoup de ces réponses évoquent presque la raison pour laquelle c'est mauvais pour moi, mais en gros: cela "casse" les éditeurs de texte. Mon expérience est avec vim.

Vim est conçu pour que les actions courantes correspondent aux lettres de manière si nette que vous n’aurez même pas à vous demander quelle lettre ou combinaison de touches utiliser. Divers raccourcis clavier permettent au curseur de contourner le texte si rapidement qu'il ne faut que quelques frappes pour le faire où vous le souhaitez. Même des choses comme plier des blocs de code sont rapides, puisque vous pouvez appuyer sur FIN ou sur $ pour sauter à la fin de la ligne, où le curseur doit se chevaucher {ou} ou (ou) ou quelque chose - il n'y a pas besoin de casser votre flux de pensée à avoir une idée sur l'écran.

Mais ensuite, certains espaces traînent, et les mouvements du curseur ne sont plus prévisibles. Votre processus de frappe est interrompu, car quelque chose que vous ne pouvez pas voir affecte l’affichage du curseur. Vous devez donc interrompre votre pensée pour l’envoyer là où il devrait être.

Avez-vous déjà remarqué à quel point les gens sont agacés quand ils sont vraiment concentrés sur une tâche et que quelqu'un les interrompt? Ouais, trouver le dernier espace quand c'est le moins prévu est exactement comme ça.

_{En tant que note de bas de page, j'ai également remarqué que ce sont les personnes qui ne se soucient pas de la fin des espaces qui utilisent la souris pour la navigation et ont tendance à être des dactylographes plus lents à cause de cela ...}

De manière surprenante, la réponse la plus évidente fait défaut: les espaces de fuite peuvent et vont produire des bugs difficiles à trouver.

La situation la plus évidente est celle des chaînes multilignes. Python, JavaScript et Bash ne sont que quelques exemples des langages concernés:

print("Hello\·
····World")

produit:

  File "demo.py", line 1
    print("Hello\
                 ^
SyntaxError: EOL while scanning string literal

ce qui est en quelque sorte cryptique et difficile à résoudre si l'éditeur n'est pas configuré pour afficher des caractères d'espacement.

La mise en surbrillance de la syntaxe peut aider à éviter de tels cas, mais il est encore plus facile de ne pas avoir le problème en premier lieu en ne laissant pas d'espace blanc à la fin des lignes. C'est pourquoi certains vérificateurs de style émettent un avertissement lorsqu'ils rencontrent des espaces, et certains éditeurs les découpent automatiquement.

^{Illustration: la syntaxe en surbrillance peut aider à éviter les espaces blancs dans les situations où cela peut conduire à des bogues, mais ne vous fiez pas uniquement à cela.}

Un autre contexte, mentionné brièvement dans une réponse précédente , concerne les données stockées dans des fichiers.

Par exemple, les fichiers CSV contenant des espaces de fin peuvent entraîner une incohérence des données, ce qui est également très difficile à détecter: des analyseurs syntaxiques conformes aux normes vont supprimer les espaces (la norme indique que les espaces de début ou de fin ne sont pas pertinents, sauf s'ils sont délimités par des guillemets), mais certains analyseurs peuvent mal se comporter et conserver les espaces comme faisant partie d'une valeur.

D'autres formats personnalisés peuvent spécifiquement considérer que les espaces sont la partie de la valeur, conduisant à des situations cohérentes mais toujours difficiles à déboguer.

J'ai récemment passé une journée à rechercher un bogue qui se révélait être un espace de fin inattendu derrière les données.

Lorsque je sélectionne le code source du programme afin de le copier / coller (ou de le supprimer), je trouve un peu gênant de voir tout l'espace extra blanc irrégulier à la fin des lignes: je dois lire le code pendant que je le sélectionne. , l'espace blanc de fuite est un bruit inutile. Exemple (les points représentent l'espace blanc):

if (fp)........
{....
    fclose(fp);.
}
else
{.....
    prinft("File is NULL\n");
}..

Cet exemple est artificiel, mais j'ai vu beaucoup de code qui ressemble à ceci.

Outre le problème évident que cela casse l'analyse dans certains cas? Comme l'a noté une autre affiche, cela peut entraîner des erreurs subtiles et difficiles à retracer. Les espaces ne sont pas toujours insignifiants. Dans certains cas, les espaces finaux peuvent modifier de manière significative la signification d’une ligne de code ou de données.

Dans la plupart des cas, les espaces sont là pour formater le code pour les lecteurs humains. Les espaces de fin peuvent indiquer plusieurs éléments, notamment:

• Une déclaration incomplète;
• Un commentaire manquant
• Un montage erroné; ou
• Édition bâclée.

Deux d'entre elles peuvent entraîner un fonctionnement incorrect, et une autre peut rendre plus difficile la compréhension du code.

Il existe des langages de programmation sensibles aux espaces finaux. Par exemple, un script TCL générera une erreur s'il y a un espace à la fin d'une ligne.