Peu importe combien vous aimez un langage de programmation, il y a toujours quelques détails qui ne sont pas aussi agréables qu'ils pourraient l'être.

Dans cette question, je voudrais me concentrer spécifiquement sur les éléments de syntaxe. Dans un langage de programmation que vous utilisez fréquemment (peut-être votre langage de programmation préféré, ou peut-être celui que vous êtes obligé d'utiliser au travail), quel élément de syntaxe trouvez-vous le plus illisible, peu clair, incommode ou désagréable?

Insertion de points-virgules en JavaScript.

Je n'ai pas vraiment été mordu souvent, mais c'est juste une si mauvaise idée que ça me fait tourner la tête.

Voici les règles (de la section 7.9 de l'ECMA-262)

1. Lorsque le programme contient un jeton qui n'est pas autorisé par la grammaire formelle, un point-virgule est inséré si (a) il y a un saut de ligne à ce point, ou (b) le jeton inattendu était une accolade fermante.
2. Lorsque la fin d'un fichier est atteinte, si le programme ne peut pas être analysé autrement, un point-virgule est inséré.
3. Lorsqu'une "production restreinte" est rencontrée et contient un terminateur de ligne à un endroit où la grammaire contient l'annotation "[pas de LineTerminator ici]", un point-virgule est inséré.

Exemple:

return 1; // returns 1

return
1; // returns undefined

Syntaxe Java-bean en raison du manque de propriétés C #

/**
 * Name of user
 */
private String name;

/**
 * Gets name of user
 * @return Name of user
 */
public String getName() {
    return this.name;
}

/**
 * Sets name of user. 
 * @param name
 */
public void setName(final String name) {
    this.name = name;
}

GAH !!!

Problèmes que j'ai avec cela

• Trop de code - Ayez un champ documenté, une méthode getter documentée et une méthode setter documentée. Cet exemple extrêmement basique a 20 lignes de code pour une seule propriété
• Clutter listes de méthode - « Permettez - moi de trouver cette méthode, la main sur: getX, getY, getZ, getAnotherAnnoyingField, getWhyIHateJavaBeans, getThisIsVerbose, getGAH... ah ça y est, hashCode.
• Plusieurs domaines de documentation entraînent une documentation médiocre, obsolète ou manquante - ennuyeux lorsque vous essayez de comprendre ce que fait le code
• Donc, un tiers ennuyeux devait trouver un plugin pour le faire facilement - Spoon , Shark , entre autres.

Sensibilité des espaces.

Python m'énerve à cet égard. Je veux dire, je fais un retrait correct de toute façon, mais ça me dérange que je doive le faire . Faire de la présentation une partie de la syntaxe m'énerve.

L' switchinstruction (en C, C ++, C #, Java, etc.)

Voici un exemple des raisons pour lesquelles je trouve cela très gênant:

switch (someVariable)
{
    case 1:
        int i = something();
        doSomething(i);
        break;

    case 2:
        int i = somethingElse();
        doSomethingElse(i);
        break;
}

Cela ne se compile pas car la variable iest redéclarée dans la même étendue. Cela semble être un détail mineur, mais il me mord très souvent. Je peux ajouter des accolades pour l'atténuer, mais cela aurait été bien si les accolades avaient été une partie obligatoire de la syntaxe, et il n'y avait pas de niveau supplémentaire d'indentation redondant. Je déteste aussi vraiment avoir à écrire le supplément break. Ce serait bien mieux:

switch (someVariable)
case 1
{
    int i = something();
    doSomething(i);
}
case 2
{
    int i = somethingElse();
    doSomethingElse(i);
}
default
{
    ...
}

Cela le fait ressembler davantage à une chaîne if/ else, ce qui est une bonne chose car il est également sémantiquement similaire. Au moins en C #, ce ne serait pas la même chose cependant, car dans une switchdéclaration, l'ordre des étiquettes de cas n'a pas d'importance, mais dans un if/ elseil le fait.

Déclarations de tableau dans VB.NET

J'arrive toujours à oublier que lors de l'initialisation de tableaux fixes dans VB.NET, vous spécifiez la limite supérieure du tableau et non le nombre d'éléments comme en C / C ++, PHP ou Java. Outre VB6 (nous n'irons pas là-bas ...), je ne peux pas penser à une autre langue qui le fasse de cette façon:

Dim myArray(20) as Integer  '# Creates an array with 21 elements,
                            '# indexed from 0 to 20

VB6 - Déclaration et affectation de variable distincte

La plupart des langues vous permettent de déclarer une variable et de l'assigner sur une seule ligne de code; VB6, d'autre part, vous oblige à en utiliser deux.

Dim i as Integer
i = 0

Dim derpderp as Collection
Set derpderp = new Collection

Vous pouvez utiliser deux points pour mettre deux commandes sur une seule ligne, mais cela devient rapidement désordonné dans le code réel.

Dim i as Integer: i = 0
Dim derpderp as Collection: Set derpderp = new Collection

Commenter en CSS

//ne commente pas les lignes de code comme il le fait dans de nombreux autres langages, comme PHP et Javascript. Bien que /* this is commented out */fonctionne, je préfère utiliser //.

C'est une nuisance, car la moitié du temps, j'oublie que je modifie le CSS et que je dois ensuite revenir en arrière et corriger l'erreur.

PHP - ordre cohérent des arguments

PHP a un certain nombre de fonctions pratiques pour faire à peu près toutes les opérations auxquelles vous pouvez penser sur un tableau ou une chaîne. Beaucoup de ces opérations nécessitent d'utiliser à la fois a $needleet a $haystack, mais différentes fonctions les prennent dans des ordres différents. Quelle fonction nécessite quels arguments est l'un de ces faits que mon cerveau refuse d'absorber, peu importe la fréquence à laquelle je les rencontre!

Prenez les fonctions in_array et strstr :

// Check whether $needle occurs in array $haystack
bool in_array (mixed $needle, array $haystack [, bool $strict])

// Check whether $needle is a substring of $haystack
string strstr (string $haystack, mixed $needle [, bool $before_needle=false])

Curieusement, PHP semble être cohérent en interne avec ces ordres dans la mesure où toutes les fonctions de chaîne semblent utiliser $haystack, $needletandis que les fonctions de tableau sont l'inverse, mais cela peut prendre un peu de temps pour s'habituer à quelqu'un de nouveau en PHP. Il y a un bon article sur ExpressionEngine qui parle plus en détail de cette bizarrerie particulière, ainsi qu'une discussion sur la liste des bogues PHP , qui présente une réponse très courte de l'équipe PHP!

helly@php.net
Utilisez alors un IDE décent.

Python

self paramètre dans les définitions de méthode d'instance

Java

Période. Arrêt complet. Fin de l'histoire.

Où commencer? Oh, je sais par où commencer: les génériques de Java incroyablement compliqués et laids et stupides et intrinsèquement cassés . Dois-je en dire plus? :( Ok bien, alors: tapez l'effacement .

Ensuite, il y a la gestion non déterministe des ressources. Kewl feetcher!

Quelle est la prochaine étape? Oh ouais: les stupides regex de Java sont mon boeuf le plus irritant et bouillonnant. Je ne peux pas compter le nombre de fois où j'ai été arrosé parce que je n'ai pas suffisamment de barres obliques inverses. C'est encore pire que de ne pas avoir accès aux propriétés Unicode de ce millénaire - ce qui est un taureau complet. Dix ans effrayants dépassés !!! Totalement inutile. Trash it.

Ensuite, il y a le bogue que les raccourcis de classe de caractères ne fonctionnent pas sur non-ASCII. Quelle douleur royale! Et n'envisagez même pas d'utiliser \p{javaWhiteSpace}; il ne fait pas la bonne chose avec plusieurs points de code d'espaces blancs Unicode très courants.

Saviez-vous qu'il y a une \p{javaJavaIdentifierStart}propriété? À quoi pensaient-ils? Je suis tellement content qu'ils aient eu de tels voyants intelligents wurkin sur dis difficile.

Avez-vous déjà essayé d'utiliser l'indicateur CANON_EQ? Savez-vous que c'est vraiment le cas et ce qu'il ne fait pas ? Qu'en est-il du soi-disant «boîtier Unicode»? Un tas de boîtiers normaux ne fonctionnent tout simplement pas.

Ensuite, il est difficile d'écrire des expressions rationnelles maintenables. Java n'a toujours pas compris comment écrire des chaînes multilignes, vous finissez donc par écrire des choses folles comme ceci:

    "(?= ^ [A-Z] [A-Za-z0-9\\-] + $)      \n"
  + "(?! ^ .*                             \n"
  + "    (?: ^     \\d+      $            \n"
  + "      | ^ [A-Z] - [A-Z] $            \n"
  + "      | Invitrogen                   \n"
  + "      | Clontech                     \n"
  + "      | L-L-X-X                      \n"
  + "      | Sarstedt                     \n"
  + "      | Roche                        \n"
  + "      | Beckman                      \n"
  + "      | Bayer                        \n"
  + "    )      # end alternatives        \n"
  + ")          # end negated lookahead   \n" 

Quelles sont toutes ces nouvelles lignes? Oh, juste la stupidité Java. Ils ont utilisé des commentaires Perl, pas des commentaires Java ( idiots! ) Qui vont jusqu'à la fin de la ligne. Donc, si vous ne les mettez pas \nlà, vous coupez le reste de votre modèle. Duh et double duh!

N'utilisez pas d'expressions régulières en Java: vous finirez par vouloir casser des choses, tout cela est si douloureux et cassé. Je ne peux pas croire que les gens supportent ça. Certains non .

Ensuite, nous pouvons commencer à parler du non-sens idiot de Java avec des encodages. Tout d'abord, il y a le fait que le codage par défaut de la plate-forme est toujours un codage 8 bits boiteux même si les charchars de Java sont Unicode. Ensuite, il y a comment ils ne déclenchent pas d'exception en cas d'erreur de codage. Vous êtes assuré d'obtenir de la merde. Ou que diriez-vous de ceci:

OutputStreamWriter(OutputStream out) 
          Creates an OutputStreamWriter that uses the default character encoding.
OutputStreamWriter(OutputStream out, Charset cs) 
          Creates an OutputStreamWriter that uses the given charset.
OutputStreamWriter(OutputStream out, CharsetEncoder enc) 
          Creates an OutputStreamWriter that uses the given charset encoder.
OutputStreamWriter(OutputStream out, String charsetName) 
          Creates an OutputStreamWriter that uses the named charset.

Quelle est la différence? Saviez-vous qu'un seul de ceux-ci lèvera une exception si vous avez une erreur d'encodage? Les autres les muselent.

Ensuite, il y a l'idiotie des caractères Java qui ne suffisent pas à contenir un personnage! Que diable pensent-ils? C'est pourquoi je les appelle des charchars. Vous devez écrire du code comme celui-ci si vous pensez qu'il fonctionne correctement:

private static void say_physical(String s) { 
    System.out.print("U+");
    for (int i = 0; i < s.length(); i++) {
        System.out.printf("%X", s.codePointAt(i));
        if (s.codePointAt(i) > Character.MAX_VALUE) { i++; }  // UG!
        if (i+1 < s.length()) { System.out.printf("."); }
    }
}

Et qui pense faire ça? À côté de personne.

Combien de personnages y a-t-il "\uD83D\uDCA9"? Un ou deux? Cela dépend de la façon dont vous les comptez. Le moteur d'expression régulière traite bien sûr des caractères logiques, donc un modèle ^.$réussira et un modèle ^..$échouera. Cette folie est démontrée ici:

String { U+61, "\u0061", "a" }  =~ /^.$/ => matched.
String { U+61, "\u0061", "a" }  =~ /^..$/ => failed.
String { U+61.61, "\u0061\u0061", "aa" }  =~ /^.$/ => failed.
String { U+61.61, "\u0061\u0061", "aa" }  =~ /^..$/ => matched.
String { U+DF, "\u00DF", "ß" }  =~ /^.$/ => matched.
String { U+DF, "\u00DF", "ß" }  =~ /^..$/ => failed.
String { U+DF.DF, "\u00DF\u00DF", "ßß" }  =~ /^.$/ => failed.
String { U+DF.DF, "\u00DF\u00DF", "ßß" }  =~ /^..$/ => matched.
String { U+3C3, "\u03C3", "σ" }  =~ /^.$/ => matched.
String { U+3C3, "\u03C3", "σ" }  =~ /^..$/ => failed.
String { U+3C3.3C3, "\u03C3\u03C3", "σσ" }  =~ /^.$/ => failed.
String { U+3C3.3C3, "\u03C3\u03C3", "σσ" }  =~ /^..$/ => matched.
String { U+1F4A9, "\uD83D\uDCA9", "💩" }  =~ /^.$/ => matched.
String { U+1F4A9, "\uD83D\uDCA9", "💩" }  =~ /^..$/ => failed.
String { U+1F4A9.1F4A9, "\uD83D\uDCA9\uD83D\uDCA9", "💩💩" }  =~ /^.$/ => failed.
String { U+1F4A9.1F4A9, "\uD83D\uDCA9\uD83D\uDCA9", "💩💩" }  =~ /^..$/ => matched.

Cette idiotie est tout parce que vous ne pouvez pas écrire le parfaitement raisonnable \u1F4A9, et bien sûr, vous ne recevez aucun avertissement que vous ne pouvez pas le faire. Cela fait juste la mauvaise chose.

Stoooopid.

Pendant que nous y sommes, la \uXXXXnotation entière est congénitalement morte de cerveau. Le préprocesseur Java ( oui, vous m'avez entendu ) y arrive avant Java, il vous est donc interdit d'écrire des choses parfaitement raisonnables comme "\u0022", car au moment où Java voit cela, son préprocesseur l'a transformé """, donc vous perdez. Oh attendez, pas si c'est dans une expression régulière! Vous pouvez donc utiliser "\\u0022"très bien.

Riiiiiiiight!

Saviez-vous qu'il n'y a aucun moyen en Java de faire un isatty(0)appel? Vous n'êtes même pas autorisé à penser de telles pensées. Ce ne serait pas bon pour toi.

Et puis il y a toute l'abomination du chemin de classe.

Ou le fait qu'il n'y a aucun moyen de spécifier l'encodage de votre fichier source Java dans ce même fichier source afin de ne pas le perdre? Encore une fois, je demande à savoir: QU'EN PENSENT-ILS?

Arrète la folie! Je ne peux pas croire que les gens supportent ces ordures. C'est une blague complète. Je préfère être un Walmart plus gourmand que de subir les frondes et les flèches de la folie scandaleuse de Java. Tout est cassé, et non seulement ils ne peuvent pas le réparer, ils ne le répareront pas.

Ceci par les mêmes personnes foxy-grapey qui se targuaient d'une langue qui rendait illégal d'avoir une printf()fonction. Gee, ça a très bien fonctionné, n'est-ce pas!?

Des crânes engourdis. La gifle est trop gentille pour eux. Si je voulais programmer en assembleur, je le ferais. Ce n'est pas une langue récupérable. L'empereur n'a pas de vêtements.

Nous le détestons. Nous le détestons pour toujours . Laissez-le mourir mourir mourir !

Syntaxe de déclaration du pointeur de fonction en C et C ++:

(int)(*f)(int, int);

Cela déclare un pointeur de fonction nommé fdont la pointe peut prendre deux ints et retourner un int.

Je préférerais de loin une syntaxe comme celle-ci:

f: (int, int) => int

Supposons que vous vouliez déclarer un pointeur de fonction gdont la pointe peut prendre deux ints et une fonction de intet intvers int, et renvoyer un int.

Avec la notation C ou C ++, vous le déclareriez comme:

(int)(*g)(int, int, int(int, int));

Avec la notation proposée ci-dessus, la même chose peut être déclarée comme:

g: (int, int, (int, int) => int) => int

Ce dernier est beaucoup plus intuitif IMO.

En plus: Le langage de programmation appelé OOC corrige cette syntaxe (et divers autres problèmes syntaxiques en C et C ++). Consultez sa page d'accueil ici .

Verbosité en Java.

c'est à dire:

public static final int 

\ we \ wouldnt \ fix \ our \ syntaxe de l'espace de noms de l'analyseur en PHP

La syntaxe n'est pas seulement laide, elle conduit à la confusion lorsque les nouveaux développeurs doivent penser aux espaces de noms dans les chaînes. (PHP interpole les barres obliques inverses dans les chaînes entre guillemets doubles en tant que séquences d'échappement. Essayer de représenter un espace de noms comme \you\should\never\do\thatdans une chaîne entre guillemets doubles au lieu d'une chaîne entre guillemets entraînera des sauts de ligne, des tabulations et un désastre.)

Je méprise le fait que les accolades peuvent être facultatives après une instruction if / while / for.

Surtout quand je vois du code comme,

if (...)
    for(...)
        ... One line of stuff ...

Veuillez simplement mettre les accolades et en finir.

VBScript n'a pas d'opérateurs logiques

Contrairement à presque tous les langages sensibles, VBScript utilise des opérateurs au niveau du bit au lieu des opérateurs logiques. Qu'est-ce que cela signifie dans la pratique? Eh bien, comme le souligne Eric Lippert :

If Blah = True Then Print "True!" Else Print "False!"

et

If Blah Then Print "True!" Else Print "False!"

ne sont PAS les mêmes dans VBScript!

Pire encore, cela signifie qu'il n'y a pas d'évaluation de court-circuit dans VBScript, de sorte que l'instruction suivante plantera votre programme s'il BlahestNothing

If (Not Blah Is Nothing) And (Blah.Frob = 123) Then
...

C'est vrai, VBScript évaluera les deux parties de la comparaison ET, même si la première est fausse! Laissez-le simplement pénétrer ...

EDIT: Suite à la discussion dans les commentaires, j'ai décidé de mettre à jour cette réponse pour mieux m'expliquer.

Je déteste vraiment l'apparence des pointeurs de fonction en C. Habituellement, toute déclaration de variable ressemble à un tuple de: type varname; Les déclarations de pointeur de fonction, d'autre part, ressemblent à une déclaration de la fonction avec * avant le nom de la fonction. Je peux accepter cela comme une description d'un type de pointeur, mais en C, cela déclare à la fois le type et le nom d'une variable de ce type. Cela me semble incohérent car les déclarations de type sont par ailleurs distinctes des déclarations de variable. struct myStruct{int X; int Y;}définit uniquement un type, il ne définit pas une variable nommée myStruct. De même, je ne vois aucune raison pour que les déclarations de type et les déclarations de variables soient regroupées en une seule instruction atomique dans les pointeurs de fonction, et je n'apprécie pas non plus l'écart par rapport à la type varname;structure.

Quelqu'un a souligné que cela est cohérent avec une règle en spirale, et cela peut être le cas, mais la marque d'une bonne syntaxe est qu'elle s'explique d'elle-même et que sa logique interne est évidente. La règle en spirale n'est en aucun cas évidente.

Les points-virgules dans VBScript - ou leur absence

Je passe toute la journée à travailler dans des langues qui attendent des points-virgules à la fin de chaque ligne. Ajoutez-en un à la fin de la ligne dans VBScript et votre code ne s'exécute plus.

Arguments d'entrée / sortie. Je suis pour les arguments (c'est une bonne chose que je sois), les arguments sont bien aussi, mais un argument qui doit transmettre ces deux états me fait chier.

Ce que je cible ici, ce sont les fonctions qui prennent l'entrée d'un paramètre puis écrasent cette entrée avec une sortie. Vous pouvez transmettre un objet par référence pour le mettre à jour. Mais, surtout pour les types primitifs, prendre un objet, l'utiliser, puis le changer complètement, ne me convient pas. Vous ne devez pas modifier la signification de l'argument par le biais d'une entrée.

Déclarations de tableaux en C et C ++.

En règle générale, une déclaration de variable est au format type variable_name. Vous pouvez facilement lire ces déclarations de gauche à droite. Mais int foo[size]regarde d'abord comme si elle se déclarait foocomme un entier, puis vous lisez plus loin et voyez ces foo de type «tableau d'entiers». int[size] foolit beaucoup mieux.

Et je déteste aussi quand les programmeurs déclarent des pointeurs comme cela pour une raison similaire: int *foo. Pour une raison que je n'ai pas compris, c'est la façon typique dont c'est écrit.

Paramétrage redondant en Java:

HashMap<String,HashMap<String,String>> foo = new HashMap<String, HashMap<String, String>>();

Quel autre type de paramétrage le compilateur pense foo -t-il avoir?

Étant donné que les gens se sont déjà plaints de =vs ==, permettez-moi de signaler une alternative bien pire. PL / J'avais les deux :=et =, mais quand quelque chose était "évidemment" une tâche, cela vous permettait de vous en passer =. L' utilisation :=vous permettant de forcer quelque chose à être une mission dans une situation où le compilateur autrement interpréter comme une comparaison.

Malheureusement, le compilateur n'a pas toujours décidé des choses comme vous pourriez vous y attendre. Prenons un exemple évident:

A = B = 0;

Maintenant, pour la plupart des gens familiers avec la plupart des langages "ordinaires", la signification de ceci est assez évidente - attribuer 0 à la fois à A et B. PL / I est juste un peu ... différent cependant. Pour des raisons connues des concepteurs (insensés) de la langue, la première =est interprétée comme une affectation, mais la seconde =est interprétée comme une comparaison. Par conséquent, cela compare B à 0, puis attribue le résultat de cette comparaison à A (conformément à la convention de style C selon laquelle "faux" donne 0 et "vrai" en 1).

Donc, si B était 0, alors A devient 1. Sinon, A devient 0. En d'autres termes, plutôt que d'attribuer la même valeur à A et B, cela garantit que A ne peut pas avoir la même valeur que B.

Bottom line: même si le style C / C ++ / PHP semble initialement difficile, l'alternative est bien pire ¹ .

¹ Eh bien, techniquement, il existe une autre alternative: le style Pascal, où =signifie toujours que la comparaison et l'affectation nécessitent toujours :=. Après l'avoir utilisé pendant un certain temps, il est assez évident (au moins pour moi) que l'affectation est suffisamment plus courante que la comparaison que si vous avez besoin de "trucs" supplémentaires pour lever l'ambiguïté des deux, vous devriez certainement garder les affectations propres et simples et exiger le "grunge" supplémentaire sur les comparaisons, et non l'inverse.

Perl

1. J'aimerais que Perl me laisse écrire if($x < 10) do_something();. Pour le moment, vous devez l'écrire soit comme, soit do_something() if($x < 10);comme if($x < 10) { do_something(); }.

reinterpret_cast<unsigned long>en c ++. Cette opération est utile pour gérer les API étrangères et garantir la précision numérique, pourquoi devrait-il être si difficile de taper et si moche à regarder?

La construction for ... in en JavaScript et la construction foreach en PHP lors du bouclage sur des tableaux. Les deux facilitent l'écriture de bogues que le code correct.

Pointeurs de tableaux ou tableaux de pointeurs en C / C ++. Je suis toujours confus à ce sujet.

Le fait que Python repose sur la mise en forme du texte.

Javascript / Java etc, est égal à la comparaison, par exemple si (a == 1)

Combien de fois dois-je écrire si (a = 1)?

En tant qu'humain, je l'ai parfaitement lu. Mais l'interprète / compilateur sacrément dit: "hé je vais assigner 1 à a, puis vérifier si a est égal à 1, et le croiriez-vous oui c'est le cas!

Me conduit sur le mur.

si (a == 1) est beaucoup moins lisible, et l'interpréteur / compilateur devrait de toute façon savoir ce que je veux dire; de nombreuses autres langues moindres (VB) fonctionnent avec succès depuis des centaines d'années.

Verbosité dans les classes anonymes Java. J'espère que ce problème sera bientôt corrigé.

structPointer->memberen C / C ++. Peut être bon pour lire le code de quelqu'un d'autre, mais je n'aime pas ça. Deux personnages au lieu d'un ... quel gaspillage d'espace!

Code multiligne Scala entre parenthèses

Par exemple:

class Foo(
         val bar: String,
         val baz: Int,
         val bing: String,
         val bong: Boolean
 ) extends Model {
   // body here
 }

Ce que vous en tirez est formidable. Il génère le constructeur et les getters et setters pour vous. Mais c'est vraiment moche et brise tous mes modèles mentaux sur la façon de mettre en retrait le code et me donne essentiellement l'impression d'être dans une sorte de sandwich bizarre avec Java d'un côté et Lisp de l'autre. (Oh, attendez ... c'est plutôt le but de Scala.)