Question Caractéristique du langage la plus étrange


Quelle est, à votre avis, la fonctionnalité de langage la plus surprenante, la plus étrange, la plus étrange ou la plus «WTF» que vous ayez rencontrée?

S'il vous plaît seulement une fonctionnalité par réponse.


975


origine


Réponses:


En C, les tableaux peuvent être indexés comme suit:

a[10]

ce qui est très commun.

Cependant, la forme la moins connue (qui fonctionne vraiment!) Est:

10[a]

ce qui signifie la même chose que ci-dessus.


1861



En JavaScript:

 '5' + 3 gives '53'

Tandis que

 '5' - 3 gives 2

1296



En JavaScript, la construction suivante

return
{
    id : 1234,
    title : 'Tony the Pony'
};

résultats undefined est une erreur de syntaxe due à l'insertion sournoise implicite de point-virgule sur le retour à la ligne après return. Les travaux suivants que vous attendez si:

return {
    id : 1234,
    title : 'Tony the Pony'
};

Pire encore, celui-ci fonctionne aussi (dans Chrome, au moins):

return /*
*/{
    id : 1234,
    title : 'Tony the Pony'
};

Voici une variante du même problème qui ne génère pas d'erreur de syntaxe, mais qui échoue silencieusement:

return
    2 + 2;

872



Table de vérité JavaScript:

''        ==   '0'           // false
0         ==   ''            // true
0         ==   '0'           // true
false     ==   'false'       // false
false     ==   '0'           // true
false     ==   undefined     // false
false     ==   null          // false
null      ==   undefined     // true
" \t\r\n" ==   0             // true

Source: Doug Crockford


797



Trigraphs en C et C ++.

int main() {
   printf("LOL??!");
}

Cela va imprimer LOL|parce que le trigraph ??! est converti en |.


662



Amusez-vous avec la boxe automatique et le cache entier en Java:

Integer foo = 1000;
Integer bar = 1000;

foo <= bar; // true
foo >= bar; // true
foo == bar; // false

//However, if the values of foo and bar are between 127 and -128 (inclusive)
//the behaviour changes:

Integer foo = 42;
Integer bar = 42;

foo <= bar; // true
foo >= bar; // true
foo == bar; // true

Explication

Un rapide coup d'oeil sur le code source Java va apparaître ce qui suit:

/**
 * Returns a <tt>Integer</tt> instance representing the specified
 * <tt>int</tt> value.
 * If a new <tt>Integer</tt> instance is not required, this method
 * should generally be used in preference to the constructor
 * {@link #Integer(int)}, as this method is likely to yield
 * significantly better space and time performance by caching
 * frequently requested values.
 *
 * @param  i an <code>int</code> value.
 * @return a <tt>Integer</tt> instance representing <tt>i</tt>.
 * @since  1.5
 */
public static Integer valueOf(int i) {
    if (i >= -128 && i <= IntegerCache.high)
        return IntegerCache.cache[i + 128];
    else
        return new Integer(i);
}

Remarque:  IntegerCache.high par défaut 127 sauf si défini par une propriété.

Qu'est-ce qui se passe avec la boxe automatique est que les deux foo et bar le même objet entier extrait du cache, sauf si explicitement créé: par exemple. foo = new Integer(42)Ainsi, en comparant l'égalité de référence, ils seront vrais plutôt que faux. La bonne façon de comparer la valeur Integer est d'utiliser .equals;


574



Citant Neil Fraser (regardez à la fin de cette page),

try {
    return true;
} finally {
    return false;
}

(en Java, mais le comportement est apparemment le même en JavaScript et en Python). Le résultat est laissé comme un exercice au lecteur.

EDITED: Tant que nous sommes sur le sujet considérons aussi ceci:

try {
    throw new AssertionError();
} finally {
    return false;
}

373