utilisation du ";"

perso, à chaque ligne de code je tremine par un ";"

C'est une excellente chose, même s'ils sont souvent optionnels pour
rester compatible avec les toutes premières versions de JavaScript.

mais je note que certains scripts trouvés sur le net ajoutent un ";"
derrière un "}".

c'est le cas de Yahoo dans son objet "YAHOO.util.Color", par exemple
(lignes 8 à 10) :

var real2int = function(n) {
return Math.min(255, Math.round(n*256));
};
---^--- c'est de ce ";" là que je souhaite discuter

quand est-il nécessaire ?

Je ne dois pas trop m'avancer en disant qu'il n'est jamais nécessaire
mais jamais interdit non plus. Note que tu peux mettre autant de « ; »
que tu veux entre deux instructions, par exemple :
var real2int = function(n) {
return Math.min(255, Math.round(n*256));;;;;;;;;;;;
};;;;;;;;;;;;

Olivier Miakinen <om+news@miakinen.net> wrote:

var real2int = function(n) {
return Math.min(255, Math.round(n*256));
};
---^--- c'est de ce ";" là que je souhaite discuter

quand est-il nécessaire ?

Je ne dois pas trop m'avancer en disant qu'il n'est jamais nécessaire
mais jamais interdit non plus. Note que tu peux mettre autant de « ; »
que tu veux entre deux instructions, par exemple :
var real2int = function(n) {
return Math.min(255, Math.round(n*256));;;;;;;;;;;;
};;;;;;;;;;;;

oui, bien sûr ;-)

j'avais cru qu'il était nécessaire dans le cas précédent car on a une
instruction du type :

var machin = function(bidule) {}
à "machin on affecte "function(bidule) {...} d'où l'intérêt du ";" dans
ce cas...

mais bon "dans le temps", je crois bien me souvenir qu'un ";" n'est pas
nécessaire ni avant ni après un "}"...

mais comme tu le dis "cà ne mange pas de pain"...
--
Artaban de Médée

j'avais cru qu'il était nécessaire dans le cas précédent car on a une
instruction du type :

var machin = function(bidule) {}
à "machin on affecte "function(bidule) {...} d'où l'intérêt du ";" dans
ce cas...

Dans un langage qui impose les point-virgules à chaque instruction, il
serait sûrement obligatoire en effet.

mais bon "dans le temps", je crois bien me souvenir qu'un ";" n'est pas
nécessaire ni avant ni après un "}"...

Si j'ai bien compris, le saut de ligne sert de fin d'instruction à tout
endroit où une instruction peut se terminer. Quoique... ça ne doit pas
être exactement ça, sinon des deux instructions suivantes seule la
première serait valide :
machin = truc +
bidule;
machin = truc
+ bidule;

mais comme tu le dis "cà ne mange pas de pain"...

Voui.

var real2int = function(n) {
return Math.min(255, Math.round(n*256));
};
---^--- c'est de ce ";" là que je souhaite discuter

quand est-il nécessaire ?

En fin de ligne ? ==> jamais nécessaire

Après une '}' ça fait double emploi.

C'est plus une habitude, qui, une fois intégrée, peut aider à savoir où
l'instruction s'arrête. Et puis ... dans le doute ... ça ne peut nuire.
(on finit par mettre ce ';' par réflexe)

C'est comme l'histoire des { } qui assez souvent n'apportent rien au
fonctionnement du code.

Cependant ...
il devient impératif si on pense passer le code au réducteur
(tout sur une ligne sans les espaces inutiles)

var real2int=function(n){return Math.min(255,Math.round(n*256));};var
real3int=...

En tous cas http://www.jslint.com/ est très pointilleux à ces sujets et
réclame les '{ } ;' de partout.
exemple :
onload=function(){var N=[1,2,3];for(i in N)if(N[i]!='a')alert(N[i])}
ne montre aucune erreur dans la console de FF
mais chez jsLint ... ce n'est pas le même tabac !

--
Stephane Moriaux et son (moins) vieux Mac déjà dépassé

j'avais cru qu'il était nécessaire dans le cas précédent car on a une
instruction du type :

var machin = function(bidule) {}
à "machin on affecte "function(bidule) {...} d'où l'intérêt du ";" dans
ce cas...

Non, même ici et dans cette forme, aucun intérêt, sauf la force de
l'habitude.
(visuellement ça vient à me manquer parfois)

mais bon "dans le temps", je crois bien me souvenir qu'un ";" n'est pas
nécessaire ni avant ni après un "}"...

voilà ! puisque '}' fait la même chose que ';' mais en plus costaud
(finit, enclot, un groupe commun d'instructions)


--
Stephane Moriaux et son (moins) vieux Mac déjà dépassé

ASM <stephanemoriaux.NoAdmin@wanadoo.fr.invalid> wrote:

En fin de ligne ? ==> jamais nécessaire

ouais.

Après une '}' ça fait double emploi.

C'est plus une habitude, qui, une fois intégrée, peut aider à savoir où
l'instruction s'arrête. Et puis ... dans le doute ... ça ne peut nuire.
(on finit par mettre ce ';' par réflexe)

C'est comme l'histoire des { } qui assez souvent n'apportent rien au
fonctionnement du code.

ben quand même dans :

var truc = function(){...}

les {} me paraissent nécessaires non ?

Cependant ...
il devient impératif si on pense passer le code au réducteur
(tout sur une ligne sans les espaces inutiles)

var real2int=function(n){return Math.min(255,Math.round(n*256));};var
real3int=...

En tous cas http://www.jslint.com/ est très pointilleux à ces sujets et
réclame les '{ } ;' de partout.
exemple :
onload=function(){var N=[1,2,3];for(i in N)if(N[i]!='a')alert(N[i])}
ne montre aucune erreur dans la console de FF
mais chez jsLint ... ce n'est pas le même tabac !

ouais, le truc serait de savoir si le parseur est plus rapide quand les
{} sont utilisés, en tout cas, perso, je ne pourrais pas écrire le
onload comme tu le fais + haut, j'ajouterais des {} après le for pour
entourrer le if.


bon effectivement jslint est pointilleux, avec :

var N=[1,2,3];
for(var i in N){if(N[i]!=2){alert(N[i]);}}

qui par rapport à ta version m'a demandé deux niveaux de {} + le dernier
; avant les }}.

en tk merci pour ce lien à jslint que je ne connaoissais pas...
--
Artaban de Médée

ASM <stephanemoriaux.NoAdmin@wanadoo.fr.invalid> wrote:

C'est comme l'histoire des { } qui assez souvent n'apportent rien au
fonctionnement du code.

ben quand même dans :

var truc = function(){...}

les {} me paraissent nécessaires non ?

J'ai dit : *assez souvent* et non pas *toujours*

onload=function(){var N=[1,2,3];for(i in N)if(N[i]!='a')alert(N[i])}

ouais, le truc serait de savoir si le parseur est plus rapide quand les
{} sont utilisés,

je doute que ça l'impressionne bp

en tout cas, perso, je ne pourrais pas écrire le
onload comme tu le fais + haut, j'ajouterais des {} après le for pour
entourrer le if.

Je ne le fais jamais sauf si nécessaire
(ça a tendance à me troubler la comprenette)

c'est à comparer avec la grammaire écrite

"s'il n'y a plus de pain mange des biscottes."
if(pain==0) alert('biscottes');

"s'il n'y a plus de pain, decongèle des croissants et mange les beurrés."
if(pain==0){pain='croissants'; alert(pain+' beurrés')}

Dans le doute,
à Olivier : doit-on écrire
"s'il n'y a plus de pain, mange des biscottes."
?


--
Stephane Moriaux et son (moins) vieux Mac déjà dépassé

var real2int = function(n) {
return Math.min(255, Math.round(n*256));
};
---^--- c'est de ce ";" là que je souhaite discuter

quand est-il nécessaire ?

En fin de ligne ? ==> jamais nécessaire

Humm, dit tel quel et avec l'exemple fourni, c'est faux. En fin de
ligne, ça dépend du contexte et avec l'exemple fourni ci-dessus c'est
obligatoire.

ECMA-262 - chapitre 7.9 - Automatic Semicolon Insertion
http://www.ecma-international.org/publications/standards/Ecma-262.htm

La règle existe, elle n'est pas "simple" mais il existe une vrai règle.
chapitre 7.9 du standard ECMA-262 qui en substance explique que les ";"
sont obligatoires mais que l'interpréteur (le navigateur) *doit* les
insérer aux endroits manquants avant d'exécuteur le script.

Le résumé "court" (voir la specification pour la règle complète)
explique que le semicolon ( le ";" ) de fin *obligatoire* peut être omis si
- il se trouve juste après une nouvelle ligne (ou après, mais il sera
inséré avant), avant un "block-end-bracket" ou à la fin du script
*et*
- quand il n'existe aucun doute qu'un point-virgule devrait être présent
(ce qui veut dire que la suppression du caractère ne doit pas donner
d'erreur syntaxique)

Et 6 cas spéciaux où une nouvelle ligne n'est pas autorisée:
- entre une expression et le ++ ou le -- qui suit
- entre "continue" ou "break" et l'identifiant qui suit
- entre "return" ou "throw" et l'expression qui suit

Après une '}' ça fait double emploi.

Pas toujours, ca dépend de l'expression qui se trouve devant...

function foo() {} // inutile ici
var foo = function() {}; // requis ici

C'est plus une habitude, qui, une fois intégrée, peut aider à savoir où
l'instruction s'arrête. Et puis ... dans le doute ... ça ne peut nuire.

Oui mais non. Dans le doute, on relit (ou lit pour la première fois) la
spécification qui explique que le doute n'est pas permis. J'espère que
la prochaine spécification décretera que ce doute n'est pas possible.

C'est comme l'histoire des { } qui assez souvent n'apportent rien au
fonctionnement du code.
Cependant ...
il devient impératif si on pense passer le code au réducteur
(tout sur une ligne sans les espaces inutiles)

Oui, parce que

for ( ... )
if ( ... )
foo()
bar()

est radicalement différent de

for ( ... )
{
if ( ... )
{
foo();
bar();
}
}

qui est tout aussi différent que

for ( ... );
if ( ... )
{
foo();
}
bar();

En tous cas http://www.jslint.com/ est très pointilleux à ces sujets et
réclame les '{ } ;' de partout.
exemple :
onload=function(){var N=[1,2,3];for(i in N)if(N[i]!='a')alert(N[i])}
ne montre aucune erreur dans la console de FF
mais chez jsLint ... ce n'est pas le même tabac !

Parce que jslint dit en substance "alerte ... règle syntaxique 7.9 en
échec, essayes encore". Alors que les navigateurs l'appliquent sans nous
en avertir.

for ( ... )
if ( ... )
foo()

est différent de
for ( ... );
if ( ... );
foo();

Ou encore, quid de ceci
var X = foo+
+bar(foobar());

Selon la règle d'insertion automatique et la suppression des
"white-spaces" inutiles, l'interpréteur doit il considérer

var X = a++; bar(foobar());

ou alors ?

var X = a+; +bar(foobar());

ou alors ?

var X = a+ +bar(foobar());

et on peut trouver des milliers de façons différentes d'interpréter et
de donner un résultat lui aussi radicalement différent. Par exemple :

var X = a; ++bar; (foobar());

Le 7.9 indique que le navigateur, lorsque il tombe dans ces situations,
doit remplacer les sauts de lignes par des ";" et essayer *encore*.

La vitesse d'analyse et d'application des différentes règles syntaxiques
comme la 7.9 est ultra rapide par rapport à l'exécution proprement dit
du script, mais est-ce une raison pour laisser le navigateur essayer de
comprendre ce qu'on a bien voulu lui dire ? Il me semble que les
implémentations ECMA-262 sont toutes différentes selon les navigateurs,
alors autant ne pas les faire deviner pour nous. Enfin, je pense...

--
laurent

j'avais cru qu'il était nécessaire dans le cas précédent car on a une
instruction du type :

var machin = function(bidule) {}
à "machin on affecte "function(bidule) {...} d'où l'intérêt du ";" dans
ce cas...

Non, même ici et dans cette forme, aucun intérêt, sauf la force de
l'habitude.
(visuellement ça vient à me manquer parfois)

Désolé Stéphane mais tu as tort sur ce point.

Le point virgule à la fin d'une ligne d'assignation est *obligatoire*

var machin = function() {}; // ; obligatoire
function machin() {} // ; inutile

http://www.ecma-international.org/publications/standards/Ecma-262.htm
chapitre 7.9 toujours

--
laurent

Laurent vilday <mokhet@mokhet.com> wrote:

Le point virgule à la fin d'une ligne d'assignation est *obligatoire*

var machin = function() {}; // ; obligatoire
function machin() {} // ; inutile

c'est ce qu'il me semblait aussi "logiquement"...

http://www.ecma-international.org/publications/standards/Ecma-262.htm
chapitre 7.9 toujours

merci pour cette réf qui précise bien les choses !
--
Artaban de Médée