si je fais x = y = z = 255, j'obtient x = 0
si je fais x = 255, j'obtient x = 255
dans la logique je devrais aussi obtenir x = 0
l'operateur de comparaison ne devrait s'appliquer que si
il y a la presence de IF et ca faciliterait certaines
initialisations...
si je fais x = y = z = 255, j'obtient x = 0
si je fais x = 255, j'obtient x = 255
dans la logique je devrais aussi obtenir x = 0
l'operateur de comparaison ne devrait s'appliquer que si
il y a la presence de IF et ca faciliterait certaines
initialisations...
si je fais x = y = z = 255, j'obtient x = 0
si je fais x = 255, j'obtient x = 255
dans la logique je devrais aussi obtenir x = 0
l'operateur de comparaison ne devrait s'appliquer que si
il y a la presence de IF et ca faciliterait certaines
initialisations...
si je fais x = y = z = 255, j'obtient x = 0
si je fais x = 255, j'obtient x = 255
dans la logique je devrais aussi obtenir x = 0
l'operateur de comparaison ne devrait s'appliquer que si
il y a la presence de IF et ca faciliterait certaines
initialisations...
si je fais x = y = z = 255, j'obtient x = 0
si je fais x = 255, j'obtient x = 255
dans la logique je devrais aussi obtenir x = 0
l'operateur de comparaison ne devrait s'appliquer que si
il y a la presence de IF et ca faciliterait certaines
initialisations...
si je fais x = y = z = 255, j'obtient x = 0
si je fais x = 255, j'obtient x = 255
dans la logique je devrais aussi obtenir x = 0
l'operateur de comparaison ne devrait s'appliquer que si
il y a la presence de IF et ca faciliterait certaines
initialisations...
Étant donné qu'en vb.net, l'opérateur de comparaison et celui
est le même, la norme est que l'opérateur le plus à gauche est celui
d'affectation et les autres, celui de comparaison. Cela évite les
au niveau du compilateur entre les 2 opérateurs.
Étant donné qu'en vb.net, l'opérateur de comparaison et celui
est le même, la norme est que l'opérateur le plus à gauche est celui
d'affectation et les autres, celui de comparaison. Cela évite les
au niveau du compilateur entre les 2 opérateurs.
Étant donné qu'en vb.net, l'opérateur de comparaison et celui
est le même, la norme est que l'opérateur le plus à gauche est celui
d'affectation et les autres, celui de comparaison. Cela évite les
au niveau du compilateur entre les 2 opérateurs.
Bonsoir,Étant donné qu'en vb.net, l'opérateur de comparaison et celui
d'affectationest le même, la norme est que l'opérateur le plus à gauche est celui
d'affectation et les autres, celui de comparaison. Cela évite les
ambiguitésau niveau du compilateur entre les 2 opérateurs.
Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
valeur et que donc à partir du moment où on utilisait la valeur d'une
opération a=b, c'était l'opérateur de comparaison et sinon, c'était
l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
documentation en faveur de votre version ni de la mienne. Vous pouvez
confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
compilateur.)
--
Zazar
Bonsoir,
Étant donné qu'en vb.net, l'opérateur de comparaison et celui
d'affectation
est le même, la norme est que l'opérateur le plus à gauche est celui
d'affectation et les autres, celui de comparaison. Cela évite les
ambiguités
au niveau du compilateur entre les 2 opérateurs.
Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
valeur et que donc à partir du moment où on utilisait la valeur d'une
opération a=b, c'était l'opérateur de comparaison et sinon, c'était
l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
documentation en faveur de votre version ni de la mienne. Vous pouvez
confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
compilateur.)
--
Zazar
Bonsoir,Étant donné qu'en vb.net, l'opérateur de comparaison et celui
d'affectationest le même, la norme est que l'opérateur le plus à gauche est celui
d'affectation et les autres, celui de comparaison. Cela évite les
ambiguitésau niveau du compilateur entre les 2 opérateurs.
Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
valeur et que donc à partir du moment où on utilisait la valeur d'une
opération a=b, c'était l'opérateur de comparaison et sinon, c'était
l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
documentation en faveur de votre version ni de la mienne. Vous pouvez
confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
compilateur.)
--
Zazar
Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
les autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
variables sur une seule ligne de code, c'est probablement ce que l'OP
essayait de faire, mais c'est impossible en VB.Net (du moins dans les
version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
C#:
z = x = y; //y0, x0, z0
Eric
"Zazar" wrote in message
news:
> Bonsoir,
>
>> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> d'affectation
>> est le même, la norme est que l'opérateur le plus à gauche est celui
>> d'affectation et les autres, celui de comparaison. Cela évite les
> ambiguités
>> au niveau du compilateur entre les 2 opérateurs.
>
> Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
> valeur et que donc à partir du moment où on utilisait la valeur d'une
> opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> documentation en faveur de votre version ni de la mienne. Vous pouvez
> confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> compilateur.)
>
> --
> Zazar
>
>
Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
les autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
variables sur une seule ligne de code, c'est probablement ce que l'OP
essayait de faire, mais c'est impossible en VB.Net (du moins dans les
version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
C#:
z = x = y; //y0, x0, z0
Eric
"Zazar" <DILAVNI.nicolas.prats@iie.cnam.fr.INVALID> wrote in message
news:OJe5PlaoEHA.1576@TK2MSFTNGP12.phx.gbl...
> Bonsoir,
>
>> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> d'affectation
>> est le même, la norme est que l'opérateur le plus à gauche est celui
>> d'affectation et les autres, celui de comparaison. Cela évite les
> ambiguités
>> au niveau du compilateur entre les 2 opérateurs.
>
> Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
> valeur et que donc à partir du moment où on utilisait la valeur d'une
> opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> documentation en faveur de votre version ni de la mienne. Vous pouvez
> confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> compilateur.)
>
> --
> Zazar
>
>
Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
les autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
variables sur une seule ligne de code, c'est probablement ce que l'OP
essayait de faire, mais c'est impossible en VB.Net (du moins dans les
version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
C#:
z = x = y; //y0, x0, z0
Eric
"Zazar" wrote in message
news:
> Bonsoir,
>
>> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> d'affectation
>> est le même, la norme est que l'opérateur le plus à gauche est celui
>> d'affectation et les autres, celui de comparaison. Cela évite les
> ambiguités
>> au niveau du compilateur entre les 2 opérateurs.
>
> Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
> valeur et que donc à partir du moment où on utilisait la valeur d'une
> opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> documentation en faveur de votre version ni de la mienne. Vous pouvez
> confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> compilateur.)
>
> --
> Zazar
>
>
Avantage, avantage, j'en suis pas si sur.
C# permet effectivement d'écrire plein de truc en une seule ligne, a telle
point que certaines lignes en deviennent incompréhensibles.
C'est pour cela que je conseille fortement d'éviter, quelque soit le
langage, des "concaténations" excessives.
Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
compilateur C#.
Que vaut, a t'on avis x après:
x=4;
x += x++;
LOL
Richard
"Eric Guillemette" a écrit dans le
message de news:
> Supposons que l'on fait des manupiluations sur des structures
>
> si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
>
> supposons:
> x = 20
> y = 30
> z = 10
>
> Retirer l'option strict
>
> z = x = y
>
> Dans la variable z, il y aura false, donc 0 car dans la variable z,
> j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
arriver
> à la conclusion que l'opérateur le plus à gauche est celui d'affectation
et
> les autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans
> livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
>
> L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
plusieurs
> variables sur une seule ligne de code, c'est probablement ce que l'OP
> essayait de faire, mais c'est impossible en VB.Net (du moins dans les
> version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
>
> C#:
> z = x = y; //y0, x0, z0
>
> Eric
>
> "Zazar" wrote in message
> news:
> > Bonsoir,
> >
> >> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> > d'affectation
> >> est le même, la norme est que l'opérateur le plus à gauche est celui
> >> d'affectation et les autres, celui de comparaison. Cela évite les
> > ambiguités
> >> au niveau du compilateur entre les 2 opérateurs.
> >
> > Je pensais que la règle, c'était qu'une affectation ne renvoyait pas
> > valeur et que donc à partir du moment où on utilisait la valeur d'une
> > opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> > l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> > documentation en faveur de votre version ni de la mienne. Vous pouvez
> > confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> > compilateur.)
> >
> > --
> > Zazar
> >
> >
>
>
Avantage, avantage, j'en suis pas si sur.
C# permet effectivement d'écrire plein de truc en une seule ligne, a telle
point que certaines lignes en deviennent incompréhensibles.
C'est pour cela que je conseille fortement d'éviter, quelque soit le
langage, des "concaténations" excessives.
Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
compilateur C#.
Que vaut, a t'on avis x après:
x=4;
x += x++;
LOL
Richard
"Eric Guillemette" <ericPasDeSpam@jalphaDeleteThis.com> a écrit dans le
message de news: u8fCo7aoEHA.800@TK2MSFTNGP14.phx.gbl...
> Supposons que l'on fait des manupiluations sur des structures
>
> si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
>
> supposons:
> x = 20
> y = 30
> z = 10
>
> Retirer l'option strict
>
> z = x = y
>
> Dans la variable z, il y aura false, donc 0 car dans la variable z,
> j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
arriver
> à la conclusion que l'opérateur le plus à gauche est celui d'affectation
et
> les autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans
> livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
>
> L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
plusieurs
> variables sur une seule ligne de code, c'est probablement ce que l'OP
> essayait de faire, mais c'est impossible en VB.Net (du moins dans les
> version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
>
> C#:
> z = x = y; //y0, x0, z0
>
> Eric
>
> "Zazar" <DILAVNI.nicolas.prats@iie.cnam.fr.INVALID> wrote in message
> news:OJe5PlaoEHA.1576@TK2MSFTNGP12.phx.gbl...
> > Bonsoir,
> >
> >> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> > d'affectation
> >> est le même, la norme est que l'opérateur le plus à gauche est celui
> >> d'affectation et les autres, celui de comparaison. Cela évite les
> > ambiguités
> >> au niveau du compilateur entre les 2 opérateurs.
> >
> > Je pensais que la règle, c'était qu'une affectation ne renvoyait pas
> > valeur et que donc à partir du moment où on utilisait la valeur d'une
> > opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> > l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> > documentation en faveur de votre version ni de la mienne. Vous pouvez
> > confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> > compilateur.)
> >
> > --
> > Zazar
> >
> >
>
>
Avantage, avantage, j'en suis pas si sur.
C# permet effectivement d'écrire plein de truc en une seule ligne, a telle
point que certaines lignes en deviennent incompréhensibles.
C'est pour cela que je conseille fortement d'éviter, quelque soit le
langage, des "concaténations" excessives.
Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
compilateur C#.
Que vaut, a t'on avis x après:
x=4;
x += x++;
LOL
Richard
"Eric Guillemette" a écrit dans le
message de news:
> Supposons que l'on fait des manupiluations sur des structures
>
> si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
>
> supposons:
> x = 20
> y = 30
> z = 10
>
> Retirer l'option strict
>
> z = x = y
>
> Dans la variable z, il y aura false, donc 0 car dans la variable z,
> j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
arriver
> à la conclusion que l'opérateur le plus à gauche est celui d'affectation
et
> les autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans
> livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
>
> L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
plusieurs
> variables sur une seule ligne de code, c'est probablement ce que l'OP
> essayait de faire, mais c'est impossible en VB.Net (du moins dans les
> version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
>
> C#:
> z = x = y; //y0, x0, z0
>
> Eric
>
> "Zazar" wrote in message
> news:
> > Bonsoir,
> >
> >> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> > d'affectation
> >> est le même, la norme est que l'opérateur le plus à gauche est celui
> >> d'affectation et les autres, celui de comparaison. Cela évite les
> > ambiguités
> >> au niveau du compilateur entre les 2 opérateurs.
> >
> > Je pensais que la règle, c'était qu'une affectation ne renvoyait pas
> > valeur et que donc à partir du moment où on utilisait la valeur d'une
> > opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> > l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> > documentation en faveur de votre version ni de la mienne. Vous pouvez
> > confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> > compilateur.)
> >
> > --
> > Zazar
> >
> >
>
>
9
"c2i" a écrit dans le message de
news:%
> Avantage, avantage, j'en suis pas si sur.
> C# permet effectivement d'écrire plein de truc en une seule ligne, a
> point que certaines lignes en deviennent incompréhensibles.
> C'est pour cela que je conseille fortement d'éviter, quelque soit le
> langage, des "concaténations" excessives.
> Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
> compilateur C#.
>
> Que vaut, a t'on avis x après:
> x=4;
> x += x++;
>
> LOL
>
> Richard
>
> "Eric Guillemette" a écrit dans le
> message de news:
> > Supposons que l'on fait des manupiluations sur des structures
> >
> > si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
> >
> > supposons:
> > x = 20
> > y = 30
> > z = 10
> >
> > Retirer l'option strict
> >
> > z = x = y
> >
> > Dans la variable z, il y aura false, donc 0 car dans la variable z,
> > j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
> arriver
> > à la conclusion que l'opérateur le plus à gauche est celui
> et
> > les autres, de comparaison. J'ai lu ça aussi il y a quelques temps
un
> > livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
> part.
> >
> > L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
> plusieurs
> > variables sur une seule ligne de code, c'est probablement ce que l'OP
> > essayait de faire, mais c'est impossible en VB.Net (du moins dans les
> > version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
> >
> > C#:
> > z = x = y; //y0, x0, z0
> >
> > Eric
> >
> > "Zazar" wrote in message
> > news:
> > > Bonsoir,
> > >
> > >> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> > > d'affectation
> > >> est le même, la norme est que l'opérateur le plus à gauche est
> > >> d'affectation et les autres, celui de comparaison. Cela évite les
> > > ambiguités
> > >> au niveau du compilateur entre les 2 opérateurs.
> > >
> > > Je pensais que la règle, c'était qu'une affectation ne renvoyait pas
de
> > > valeur et que donc à partir du moment où on utilisait la valeur
> > > opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> > > l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver
> > > documentation en faveur de votre version ni de la mienne. Vous
> > > confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire
> > > compilateur.)
> > >
> > > --
> > > Zazar
> > >
> > >
> >
> >
>
>
9
"c2i" <rcnospam@c2i.fr> a écrit dans le message de
news:%23F8wqZfoEHA.3488@TK2MSFTNGP12.phx.gbl...
> Avantage, avantage, j'en suis pas si sur.
> C# permet effectivement d'écrire plein de truc en une seule ligne, a
> point que certaines lignes en deviennent incompréhensibles.
> C'est pour cela que je conseille fortement d'éviter, quelque soit le
> langage, des "concaténations" excessives.
> Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
> compilateur C#.
>
> Que vaut, a t'on avis x après:
> x=4;
> x += x++;
>
> LOL
>
> Richard
>
> "Eric Guillemette" <ericPasDeSpam@jalphaDeleteThis.com> a écrit dans le
> message de news: u8fCo7aoEHA.800@TK2MSFTNGP14.phx.gbl...
> > Supposons que l'on fait des manupiluations sur des structures
> >
> > si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
> >
> > supposons:
> > x = 20
> > y = 30
> > z = 10
> >
> > Retirer l'option strict
> >
> > z = x = y
> >
> > Dans la variable z, il y aura false, donc 0 car dans la variable z,
> > j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
> arriver
> > à la conclusion que l'opérateur le plus à gauche est celui
> et
> > les autres, de comparaison. J'ai lu ça aussi il y a quelques temps
un
> > livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
> part.
> >
> > L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
> plusieurs
> > variables sur une seule ligne de code, c'est probablement ce que l'OP
> > essayait de faire, mais c'est impossible en VB.Net (du moins dans les
> > version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
> >
> > C#:
> > z = x = y; //y0, x0, z0
> >
> > Eric
> >
> > "Zazar" <DILAVNI.nicolas.prats@iie.cnam.fr.INVALID> wrote in message
> > news:OJe5PlaoEHA.1576@TK2MSFTNGP12.phx.gbl...
> > > Bonsoir,
> > >
> > >> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> > > d'affectation
> > >> est le même, la norme est que l'opérateur le plus à gauche est
> > >> d'affectation et les autres, celui de comparaison. Cela évite les
> > > ambiguités
> > >> au niveau du compilateur entre les 2 opérateurs.
> > >
> > > Je pensais que la règle, c'était qu'une affectation ne renvoyait pas
de
> > > valeur et que donc à partir du moment où on utilisait la valeur
> > > opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> > > l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver
> > > documentation en faveur de votre version ni de la mienne. Vous
> > > confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire
> > > compilateur.)
> > >
> > > --
> > > Zazar
> > >
> > >
> >
> >
>
>
9
"c2i" a écrit dans le message de
news:%
> Avantage, avantage, j'en suis pas si sur.
> C# permet effectivement d'écrire plein de truc en une seule ligne, a
> point que certaines lignes en deviennent incompréhensibles.
> C'est pour cela que je conseille fortement d'éviter, quelque soit le
> langage, des "concaténations" excessives.
> Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
> compilateur C#.
>
> Que vaut, a t'on avis x après:
> x=4;
> x += x++;
>
> LOL
>
> Richard
>
> "Eric Guillemette" a écrit dans le
> message de news:
> > Supposons que l'on fait des manupiluations sur des structures
> >
> > si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
> >
> > supposons:
> > x = 20
> > y = 30
> > z = 10
> >
> > Retirer l'option strict
> >
> > z = x = y
> >
> > Dans la variable z, il y aura false, donc 0 car dans la variable z,
> > j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
> arriver
> > à la conclusion que l'opérateur le plus à gauche est celui
> et
> > les autres, de comparaison. J'ai lu ça aussi il y a quelques temps
un
> > livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
> part.
> >
> > L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
> plusieurs
> > variables sur une seule ligne de code, c'est probablement ce que l'OP
> > essayait de faire, mais c'est impossible en VB.Net (du moins dans les
> > version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
> >
> > C#:
> > z = x = y; //y0, x0, z0
> >
> > Eric
> >
> > "Zazar" wrote in message
> > news:
> > > Bonsoir,
> > >
> > >> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> > > d'affectation
> > >> est le même, la norme est que l'opérateur le plus à gauche est
> > >> d'affectation et les autres, celui de comparaison. Cela évite les
> > > ambiguités
> > >> au niveau du compilateur entre les 2 opérateurs.
> > >
> > > Je pensais que la règle, c'était qu'une affectation ne renvoyait pas
de
> > > valeur et que donc à partir du moment où on utilisait la valeur
> > > opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> > > l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver
> > > documentation en faveur de votre version ni de la mienne. Vous
> > > confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire
> > > compilateur.)
> > >
> > > --
> > > Zazar
> > >
> > >
> >
> >
>
>
Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y.
Ce qui me fait arriver
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
les autres, de comparaison.
J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y.
Ce qui me fait arriver
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
les autres, de comparaison.
J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y.
Ce qui me fait arriver
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
les autres, de comparaison.
J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
Bonjour,Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y.
Tout à fait d'accord.Ce qui me fait arriver
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
etles autres, de comparaison.
Ca marche dans un cas donc ça marche partout ? :)
Contre exemple :
Console.WriteLine (x = y)
Votre règle ne fonctionne plus ici, contrairement à la mienne (je ne
prétend
pas pour autant que c'est la mienne qui est correcte).J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
J'ai épluché toutes les specs du langage, je n'ai rien retrouvé, donc si
vous retombez dessus par hasard, je suis preneur; cependant ne vous
embêtez
pas à rechercher ça explicitement.
--
Zazar
Bonjour,
Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y.
Tout à fait d'accord.
Ce qui me fait arriver
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
et
les autres, de comparaison.
Ca marche dans un cas donc ça marche partout ? :)
Contre exemple :
Console.WriteLine (x = y)
Votre règle ne fonctionne plus ici, contrairement à la mienne (je ne
prétend
pas pour autant que c'est la mienne qui est correcte).
J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
J'ai épluché toutes les specs du langage, je n'ai rien retrouvé, donc si
vous retombez dessus par hasard, je suis preneur; cependant ne vous
embêtez
pas à rechercher ça explicitement.
--
Zazar
Bonjour,Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y.
Tout à fait d'accord.Ce qui me fait arriver
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
etles autres, de comparaison.
Ca marche dans un cas donc ça marche partout ? :)
Contre exemple :
Console.WriteLine (x = y)
Votre règle ne fonctionne plus ici, contrairement à la mienne (je ne
prétend
pas pour autant que c'est la mienne qui est correcte).J'ai lu ça aussi il y a quelques temps dans un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
J'ai épluché toutes les specs du langage, je n'ai rien retrouvé, donc si
vous retombez dessus par hasard, je suis preneur; cependant ne vous
embêtez
pas à rechercher ça explicitement.
--
Zazar
Avantage, avantage, j'en suis pas si sur.
C# permet effectivement d'écrire plein de truc en une seule ligne, a telle
point que certaines lignes en deviennent incompréhensibles.
C'est pour cela que je conseille fortement d'éviter, quelque soit le
langage, des "concaténations" excessives.
Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
compilateur C#.
Que vaut, a t'on avis x après:
x=4;
x += x++;
LOL
Richard
"Eric Guillemette" a écrit dans le
message de news:Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
arriverà la conclusion que l'opérateur le plus à gauche est celui d'affectation
etles autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans
un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
plusieursvariables sur une seule ligne de code, c'est probablement ce que l'OP
essayait de faire, mais c'est impossible en VB.Net (du moins dans les
version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
C#:
z = x = y; //y0, x0, z0
Eric
"Zazar" wrote in message
news:
> Bonsoir,
>
>> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> d'affectation
>> est le même, la norme est que l'opérateur le plus à gauche est celui
>> d'affectation et les autres, celui de comparaison. Cela évite les
> ambiguités
>> au niveau du compilateur entre les 2 opérateurs.
>
> Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
> valeur et que donc à partir du moment où on utilisait la valeur d'une
> opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> documentation en faveur de votre version ni de la mienne. Vous pouvez
> confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> compilateur.)
>
> --
> Zazar
>
>
Avantage, avantage, j'en suis pas si sur.
C# permet effectivement d'écrire plein de truc en une seule ligne, a telle
point que certaines lignes en deviennent incompréhensibles.
C'est pour cela que je conseille fortement d'éviter, quelque soit le
langage, des "concaténations" excessives.
Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
compilateur C#.
Que vaut, a t'on avis x après:
x=4;
x += x++;
LOL
Richard
"Eric Guillemette" <ericPasDeSpam@jalphaDeleteThis.com> a écrit dans le
message de news: u8fCo7aoEHA.800@TK2MSFTNGP14.phx.gbl...
Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
arriver
à la conclusion que l'opérateur le plus à gauche est celui d'affectation
et
les autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans
un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
plusieurs
variables sur une seule ligne de code, c'est probablement ce que l'OP
essayait de faire, mais c'est impossible en VB.Net (du moins dans les
version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
C#:
z = x = y; //y0, x0, z0
Eric
"Zazar" <DILAVNI.nicolas.prats@iie.cnam.fr.INVALID> wrote in message
news:OJe5PlaoEHA.1576@TK2MSFTNGP12.phx.gbl...
> Bonsoir,
>
>> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> d'affectation
>> est le même, la norme est que l'opérateur le plus à gauche est celui
>> d'affectation et les autres, celui de comparaison. Cela évite les
> ambiguités
>> au niveau du compilateur entre les 2 opérateurs.
>
> Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
> valeur et que donc à partir du moment où on utilisait la valeur d'une
> opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> documentation en faveur de votre version ni de la mienne. Vous pouvez
> confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> compilateur.)
>
> --
> Zazar
>
>
Avantage, avantage, j'en suis pas si sur.
C# permet effectivement d'écrire plein de truc en une seule ligne, a telle
point que certaines lignes en deviennent incompréhensibles.
C'est pour cela que je conseille fortement d'éviter, quelque soit le
langage, des "concaténations" excessives.
Ce qui a été confirmé d'ailleurs il y a peu par un dev de l'équipe du
compilateur C#.
Que vaut, a t'on avis x après:
x=4;
x += x++;
LOL
Richard
"Eric Guillemette" a écrit dans le
message de news:Supposons que l'on fait des manupiluations sur des structures
si j'écris x = y, la valeur de "y" sera copiée dans la variable "x"
supposons:
x = 20
y = 30
z = 10
Retirer l'option strict
z = x = y
Dans la variable z, il y aura false, donc 0 car dans la variable z,
j'affecte le résultat de la comparaison entre x et y. Ce qui me fait
arriverà la conclusion que l'opérateur le plus à gauche est celui d'affectation
etles autres, de comparaison. J'ai lu ça aussi il y a quelques temps dans
un
livre, mais je ne me souviens plus lequel. Si je trouve, je t'en ferai
part.
L'avantage de C# à ce niveau permet d'affecter la valeur de y dans
plusieursvariables sur une seule ligne de code, c'est probablement ce que l'OP
essayait de faire, mais c'est impossible en VB.Net (du moins dans les
version 1.0 et 1.1 du framework, pour la 2.0, je ne sais pas)
C#:
z = x = y; //y0, x0, z0
Eric
"Zazar" wrote in message
news:
> Bonsoir,
>
>> Étant donné qu'en vb.net, l'opérateur de comparaison et celui
> d'affectation
>> est le même, la norme est que l'opérateur le plus à gauche est celui
>> d'affectation et les autres, celui de comparaison. Cela évite les
> ambiguités
>> au niveau du compilateur entre les 2 opérateurs.
>
> Je pensais que la règle, c'était qu'une affectation ne renvoyait pas de
> valeur et que donc à partir du moment où on utilisait la valeur d'une
> opération a=b, c'était l'opérateur de comparaison et sinon, c'était
> l'opérateur d'affectation. Cependant, je n'ai pas réussi à trouver de
> documentation en faveur de votre version ni de la mienne. Vous pouvez
> confirmer ? (Juste par curiosité, je n'ai pas l'intention d'écrire un
> compilateur.)
>
> --
> Zazar
>
>
