Comment puis-je formater correctement long composé si les déclarations en Coffeescript

Si j'avais un complexe si l'instruction que je ne voulais pas de débordement simplement pour des raisons esthétiques, ce qui serait le plus casher de façon à le briser, depuis coffeescript va interpréter les rendements, comme le corps de l'énoncé dans ce cas?

if (foo is bar.data.stuff and foo isnt bar.data.otherstuff) or (not foo and not bar)
  awesome sauce
else lame sauce

Si not bar est une possibilité, dans le premier alinéa de l' (comme le deuxième alinéa indique), alors la référence bar.data va provoquer une erreur...

InformationsquelleAutor Evan | 2011-07-08

coffeescript

86

CoffeeScript ne va pas interpréter la ligne suivante comme le corps de la déclaration, si la ligne se termine par un opérateur, donc c'est ok:
```
# OK!
if a and
not 
b
  c()
```
il compile à
```
if (a && !b) {
  c();
}
```
de sorte que votre if pourrait être formaté comme
```
# OK!
if (foo is 
bar.data.stuff and 
foo isnt bar.data.otherstuff) or 
(not foo and not bar)
  awesome sauce
else lame sauce
```
ou de toute autre ligne de rupture régime, tant que les lignes de fin de and ou or ou is ou == ou not ou un opérateur

Comme à l'indentation, vous pouvez mettre en retrait de la non-premières lignes de votre if tant que le corps est encore plus en retrait:
```
# OK!
if (foo is 
bar.data.stuff and 
foo isnt bar.data.otherstuff) or 
(not foo and not bar)
  awesome sauce
else lame sauce
```
Ce que vous ne pouvez pas faire est ceci:
```
# BAD
if (foo  #doesn't end on operator!
  is bar.data.stuff and 
  foo isnt bar.data.otherstuff) or 
  (not foo and not bar)
    awesome sauce
else lame sauce
```
- Merci pour la réponse. C'est une grande règle, je ne savais pas sur les opérateurs étant la clé de coupure de ligne en Coffeescript.
- Si vous ne voulez pas de tiret if statmenet du corps "encore plus", vous pouvez utiliser then, en commençant au même niveau que if. Il est plus lisible, à mon humble avis.
- Une note sur l'indentation; le corps n'a pas à être plus en retrait que les non-premières lignes de la if. Les seules règles pour la syntaxe correcte sont (autant que je sache): 1) Le corps ne peut pas avoir la même indentation que ce soit la première ou la dernière ligne de la if et 2) Ni le corps, ni de n'importe quelle ligne de la if peut avoir moins d'indentation de la première ligne de la if. Notez également que vous pouvez avoir différentes marques sur différents non-premier if lignes.
- J'ai l'habitude de retrait de la non-premier if lignes avec 2 onglets (de manière à les rendre plus visibles qu'ils ne sont ni après ni à l'intérieur de la if) et le corps avec 1 onglet.
InformationsquelleAutor nicolaskruchten
3

Cela change votre code de la signification quelque peu, mais il peut être de quelque utilité:
```
return lame sauce unless foo and bar
if foo is bar.data.stuff isnt bar.data.otherstuff
  awesome sauce
else
  lame sauce
```
Note le is...isnt de la chaîne, ce qui est légitime, tout comme a < b < c est légitime en CoffeeScript. Bien sûr, la répétition de lame sauce est malheureux, et vous ne voulez pas return tout de suite. Une autre approche serait d'utiliser imbibe d'écrire
```
data = bar?.data
if foo and foo is data?.stuff isnt data?.otherstuff
  awesome sauce
else
  lame sauce
```
La if foo and est un peu inélégant; vous pouvez le jeter si il n'y a aucune chance que foo est undefined.

InformationsquelleAutor Trevor Burnham
2

Comme toutes les autres langues, en n'ayant pas d'eux en premier lieu. Donner des noms aux différentes pièces de un de les traiter séparément. En déclarant prédicats, ou par la simple création d'un couple de booléen var.
```
bar.isBaz = -> @data.stuff != @data.otherstuff
bar.isAwsome = (foo) -> @isBaz() && @data.stuff == foo
if not bar? or bar.isAwesome foo
  awesome sauce
else lame sauce
```
- Que faire si certains prédicats sont coûteux à calculer et plus tôt les prédicats sont déjà susceptibles de conclure le résultat de l'instruction si elle est utilisée dans une expression unique?
InformationsquelleAutor John Nilsson

Échapper à la linebreak ressemble le plus lisible pour moi:

if (foo is bar.data.stuff and foo isnt bar.data.otherstuff) \
or (not foo and not bar)
  awesome sauce
else lame sauce

InformationsquelleAutor Cees Timmerman

0

Quand un grand nombre de bas-niveau standard se produit, vous devriez niveau d'augmentation de l'abstrait.

Les meilleures solutions sont:
- à utiliser bonne nommé les variables et les fonctions
- règles logiques dans si/d'autre états
L'une des règles logiques est:

(non A et non B) == non (A ou B)

La première manière. Variables:
```
isStuff              = foo is bar.data.stuff
isntOtherStuff       = foo isnt bar.data.otherstuff
isStuffNotOtherStuff = isStuff and isntOtherStuff
bothFalse            = not (foo or bar)
if isStuffNotOtherStuff or bothFalse
  awesome sauce
else lame sauce
```
Le principal inconvénient de cette méthode est sa lenteur. Nous allons obtenir de meilleures performances si nous utilisons and et or opérateurs fonctions et de remplacer les variables par des fonctions:
- C = A et B
Si A est faux opérateur and wouldnt appel
- C = A ou B
Si A est vrai opérateur or wouldnt appel

La seconde. Fonctions:
```
isStuff              = -> foo is bar.data.stuff
isntOtherStuff       = -> foo isnt bar.data.otherstuff
isStuffNotOtherStuff = -> do isStuff and do isntOtherStuff
bothFalse            = -> not (foo or bar)
if do isStuffNotOtherStuff or do bothFalse
  awesome sauce
else lame sauce
```
- Désolé, je downvote cette. La question était "la plus casher pour rompre [une longue instruction if] jusqu'", et cette réponse est très pertinente.
InformationsquelleAutor Nikita

Vous devez vous connecter pour publier un commentaire.