Quels conseils généraux avez-vous pour jouer au golf à Haxe ? Je recherche des idées qui peuvent être appliquées aux problèmes de code-golf et qui sont également au moins quelque peu spécifiques à Haxe (par exemple, "supprimer les commentaires" n'est pas une réponse).

Veuillez poster un pourboire par réponse.

Haxe peut être exécuté en ligne ici !

Interpolation de chaînes

Haxe prend en charge l' interpolation de chaînes sur les chaînes de guillemets simples. Comme les chaînes de modèle dans JavaScript ES6, vous pouvez inclure une expression dans une chaîne avec ${...}:

trace('2 + 2 = ${2 + 2}');

Contrairement à ES6, cependant, vous pouvez omettre les accolades lorsque l'expression est une seule variable:

var x = 2 + 2;
trace('2 + 2 = $x');

Ces deux exemples s'impriment 2 + 2 = 4.

Compréhensions de tableau

Haxe prend en charge les compréhensions de tableaux:

trace([for (i in 0...5) i]); // Prints 0,1,2,3,4

Contrairement à de nombreuses autres langues, vous pouvez également utiliser whiledans les compréhensions:

var i = 5;
trace([while (i > 0) i--]); // Prints 5,4,3,2,1

Cela peut être très utile lorsque vous ne savez pas combien de temps vous avez besoin d'un tableau.

Vous pouvez également la chaîne for, while, et ifdéclarations:

trace([for (x in ['A','B','C','D'])
       for (y in ['x','y'])
       if (x + y != "Cx")
       x + y
]); // Prints Ax,Ay,Bx,By,Cy,Dx,Dy

Opérateur de gamme

Haxe possède un opérateur de plage ...qui peut être utilisé pour créer des plages d'entiers. Par exemple, au lieu de cela:

var i = 0;
while (i < 10) trace(i++);

Tu peux le faire:

for (i in 0...10) trace(i++);

Spécificités pour x...y:

• xet ydoivent tous deux être Ints.
• xne peut pas être plus grand que y.
• Cela renvoie un objet IntIterator , qui peut être utilisé aux mêmes endroits que n'importe quel Iterable.

Exécution conditionnelle d'une instruction

Évidemment, vous pouvez exécuter n'importe quoi de manière conditionnelle avec if:

if(n>5)doSomething(n);

Si, cependant, vous n'avez qu'une seule instruction comme ci-dessus, vous pouvez utiliser l'opérateur conditionnel ternaire pour enregistrer un octet:

n>5?doSomething(n):0;

Vous pouvez parfois enregistrer un autre octet en utilisant &&, bien que ce soit très rare car cela &&ne fonctionne que si les deux expressions renvoient des booléens:

n>5&&doSomething(n);

Une exception majeure à cela est les mots clés : si Haxe rencontre un return, breakou continue n'importe où , il l'exécutera immédiatement et quittera l'expression sur laquelle il travaillait. Cela signifie qu'au lieu de cela:

if(n>5)return n;

Vous pouvez le faire pour économiser 2 octets:

n>5&&return n;

Utiliser des mots clés dans les expressions

Une autre caractéristique inhabituelle de Haxe est que tout est une expression . Par exemple, ce code est parfaitement valide:

function(n){while(n>0)n%4==1?return 6:n--;return 3;}

D'accord, c'est un exemple assez inutile, mais j'espère que vous comprendrez mon point. Cela fonctionne avec la plupart des mots clés:

function(n){while(n>0)n%4==1?break:n--;return n;}

Cela vous permet d'utiliser if/ elseinline, comme p=if(n>1)7else 4;, bien que ce soit bien sûr p=n>1?7:4;plus court.

Mots clés que vous ne pouvez pas utiliser en ligne

• var - Le compilateur se plaindra d'essayer d'utiliser Void comme valeur.
• for/ while- Comme ci-dessus, mais vous pouvez les utiliser dans les compréhensions de tableaux .

Omettre les crochets de fonction

Contrairement à la plupart des langues, tout dans Haxe est une expression , y compris {blocks}. Ainsi, les accolades n'importe où dans un programme Haxe (à l'exception des switchexpressions) peuvent être supprimées si elles ne contiennent qu'une seule instruction. Donc au lieu de ça:

function f(n){return Math.pow(3,n);}

Tu peux le faire:

function f(n)return Math.pow(3,n);

Deux octets faciles enregistrés sur de nombreuses fonctions.

Même si une fonction doit contenir plusieurs instructions, vous pouvez souvent enregistrer un octet en déplaçant l' return extérieur du bloc:

function f(a){var b=a*a;return a<0?-b:b;}
function f(a)return{var b=a*a;a<0?-b:b;}

Cela fonctionne car un bloc évalue la dernière expression à l'intérieur du bloc.