En développant aujourd'hui, je me suis posé une question existentielle
qui m'empêchera de dormir pendant plusieurs années : comment implémenter
proprement les accesseurs d'une classe.
En développant aujourd'hui, je me suis posé une question existentielle
qui m'empêchera de dormir pendant plusieurs années : comment implémenter
proprement les accesseurs d'une classe.
En développant aujourd'hui, je me suis posé une question existentielle
qui m'empêchera de dormir pendant plusieurs années : comment implémenter
proprement les accesseurs d'une classe.
Bonjour,
En développant aujourd'hui, je me suis posé une question existentielle
qui m'empêchera de dormir pendant plusieurs années : comment implémenter
proprement les accesseurs d'une classe.
Je m'explique en prenant un
exemple simple (écrit en PHP5). J'ignore volontairement les tests pour
éviter d'alourdir les exemples. En fait, j'hésite toujours entre les
trois philosophies suivantes, sans pouvoir trancher réellement.
La première approche me semble être la plus proche de la philosophie
PHP5. On utilises que des méthodes magiques. Le problème ici est que si
on a plus d'une donnée à protéger dans sa classe, les méthodes __get et
__set deviennent rapidement illisibles. Et surtout, lors d'un héritage
on a des problèmes assurés avec le polymorphisme.
class directAccess
{
(snip)
}
La seconde approche serait plus proche du C++, mais avec la surcharge
des méthodes en moins. Le seul inconvénient qu'on peut y trouver, c'est
l'imposibilité d'assigner la valeur null sans devoir recourir à une
méthode supplémentaire.
class allInOne
{
(snip)
}
La troisième méthode est certainement la plus propre d'un point de vue
de la conception. Le désavantage est la lourdeur d'écriture.
class javaStyle
{
(snip - le nom de la classe est assez explicite !-)
}
Laquelle de ces méthodes utilisez-vous ?
Peut-être un mélange ? Ou
encore en fonction de la situation rencontrée ? J'ai conscience que
c'est un concentré de troll
, car personne n'est d'accord sur la façon de
développer.
Bonjour,
En développant aujourd'hui, je me suis posé une question existentielle
qui m'empêchera de dormir pendant plusieurs années : comment implémenter
proprement les accesseurs d'une classe.
Je m'explique en prenant un
exemple simple (écrit en PHP5). J'ignore volontairement les tests pour
éviter d'alourdir les exemples. En fait, j'hésite toujours entre les
trois philosophies suivantes, sans pouvoir trancher réellement.
La première approche me semble être la plus proche de la philosophie
PHP5. On utilises que des méthodes magiques. Le problème ici est que si
on a plus d'une donnée à protéger dans sa classe, les méthodes __get et
__set deviennent rapidement illisibles. Et surtout, lors d'un héritage
on a des problèmes assurés avec le polymorphisme.
class directAccess
{
(snip)
}
La seconde approche serait plus proche du C++, mais avec la surcharge
des méthodes en moins. Le seul inconvénient qu'on peut y trouver, c'est
l'imposibilité d'assigner la valeur null sans devoir recourir à une
méthode supplémentaire.
class allInOne
{
(snip)
}
La troisième méthode est certainement la plus propre d'un point de vue
de la conception. Le désavantage est la lourdeur d'écriture.
class javaStyle
{
(snip - le nom de la classe est assez explicite !-)
}
Laquelle de ces méthodes utilisez-vous ?
Peut-être un mélange ? Ou
encore en fonction de la situation rencontrée ? J'ai conscience que
c'est un concentré de troll
, car personne n'est d'accord sur la façon de
développer.
Bonjour,
En développant aujourd'hui, je me suis posé une question existentielle
qui m'empêchera de dormir pendant plusieurs années : comment implémenter
proprement les accesseurs d'une classe.
Je m'explique en prenant un
exemple simple (écrit en PHP5). J'ignore volontairement les tests pour
éviter d'alourdir les exemples. En fait, j'hésite toujours entre les
trois philosophies suivantes, sans pouvoir trancher réellement.
La première approche me semble être la plus proche de la philosophie
PHP5. On utilises que des méthodes magiques. Le problème ici est que si
on a plus d'une donnée à protéger dans sa classe, les méthodes __get et
__set deviennent rapidement illisibles. Et surtout, lors d'un héritage
on a des problèmes assurés avec le polymorphisme.
class directAccess
{
(snip)
}
La seconde approche serait plus proche du C++, mais avec la surcharge
des méthodes en moins. Le seul inconvénient qu'on peut y trouver, c'est
l'imposibilité d'assigner la valeur null sans devoir recourir à une
méthode supplémentaire.
class allInOne
{
(snip)
}
La troisième méthode est certainement la plus propre d'un point de vue
de la conception. Le désavantage est la lourdeur d'écriture.
class javaStyle
{
(snip - le nom de la classe est assez explicite !-)
}
Laquelle de ces méthodes utilisez-vous ?
Peut-être un mélange ? Ou
encore en fonction de la situation rencontrée ? J'ai conscience que
c'est un concentré de troll
, car personne n'est d'accord sur la façon de
développer.
Il y a eu un fil de discussion à ce sujet très interressant il y a quelques
mois [ 17 Mai 2007 14:08 "Getter et Setter generateur ????"].
Il en ressortait qu'il y avait grand débat entre ceux qui voulaient
encapsuler et tout mettre en protected, et ceux qui passaient tout en public
et qui ne se donnait la peine que pour des accesseurs de propriétés
calculées.
Un contributeur, gaetan, avait posté une solution innovante basée sur la
methode __call de PHP5 :
http://www.vmeste.fr/index.php?2007/05/31/131-simuler-des-accesseurs-en-php
(malheureusement le site semble ne pas répondre aujourd'hui).
Autrement, 100% d'accord., __get et __set ne sont pas réellement utilisables
, et les IDE que je connais ne génèrent pas ces méthodes à coup de grand
click droit comme cela existe pour les autres langages.
Tiens nous au courant si tu trouves d'autres pistes et d'autres
informations.
Il y a eu un fil de discussion à ce sujet très interressant il y a quelques
mois [ 17 Mai 2007 14:08 "Getter et Setter generateur ????"].
Il en ressortait qu'il y avait grand débat entre ceux qui voulaient
encapsuler et tout mettre en protected, et ceux qui passaient tout en public
et qui ne se donnait la peine que pour des accesseurs de propriétés
calculées.
Un contributeur, gaetan, avait posté une solution innovante basée sur la
methode __call de PHP5 :
http://www.vmeste.fr/index.php?2007/05/31/131-simuler-des-accesseurs-en-php
(malheureusement le site semble ne pas répondre aujourd'hui).
Autrement, 100% d'accord., __get et __set ne sont pas réellement utilisables
, et les IDE que je connais ne génèrent pas ces méthodes à coup de grand
click droit comme cela existe pour les autres langages.
Tiens nous au courant si tu trouves d'autres pistes et d'autres
informations.
Il y a eu un fil de discussion à ce sujet très interressant il y a quelques
mois [ 17 Mai 2007 14:08 "Getter et Setter generateur ????"].
Il en ressortait qu'il y avait grand débat entre ceux qui voulaient
encapsuler et tout mettre en protected, et ceux qui passaient tout en public
et qui ne se donnait la peine que pour des accesseurs de propriétés
calculées.
Un contributeur, gaetan, avait posté une solution innovante basée sur la
methode __call de PHP5 :
http://www.vmeste.fr/index.php?2007/05/31/131-simuler-des-accesseurs-en-php
(malheureusement le site semble ne pas répondre aujourd'hui).
Autrement, 100% d'accord., __get et __set ne sont pas réellement utilisables
, et les IDE que je connais ne génèrent pas ces méthodes à coup de grand
click droit comme cela existe pour les autres langages.
Tiens nous au courant si tu trouves d'autres pistes et d'autres
informations.
Il y a eu un fil de discussion à ce sujet très interressant il y a quelques
mois [ 17 Mai 2007 14:08 "Getter et Setter generateur ????"].
Merci beaucoup pour la référence à la discussion.Il en ressortait qu'il y avait grand débat entre ceux qui voulaient
encapsuler et tout mettre en protected, et ceux qui passaient tout en public
et qui ne se donnait la peine que pour des accesseurs de propriétés
calculées.
Ça m'intéresserait de savoir dans quels cas un attribut n'a pas besoin
d'être vérifié avant d'être inséré, et donc d'être purement public.
L'intérêt des fonctionnalités objets, c'est quand même de canaliser les
bogues,
et donc d'éviter que le bogue puisse survenir d'une génération
spontanée :)
Il y a eu un fil de discussion à ce sujet très interressant il y a quelques
mois [ 17 Mai 2007 14:08 "Getter et Setter generateur ????"].
Merci beaucoup pour la référence à la discussion.
Il en ressortait qu'il y avait grand débat entre ceux qui voulaient
encapsuler et tout mettre en protected, et ceux qui passaient tout en public
et qui ne se donnait la peine que pour des accesseurs de propriétés
calculées.
Ça m'intéresserait de savoir dans quels cas un attribut n'a pas besoin
d'être vérifié avant d'être inséré, et donc d'être purement public.
L'intérêt des fonctionnalités objets, c'est quand même de canaliser les
bogues,
et donc d'éviter que le bogue puisse survenir d'une génération
spontanée :)
Il y a eu un fil de discussion à ce sujet très interressant il y a quelques
mois [ 17 Mai 2007 14:08 "Getter et Setter generateur ????"].
Merci beaucoup pour la référence à la discussion.Il en ressortait qu'il y avait grand débat entre ceux qui voulaient
encapsuler et tout mettre en protected, et ceux qui passaient tout en public
et qui ne se donnait la peine que pour des accesseurs de propriétés
calculées.
Ça m'intéresserait de savoir dans quels cas un attribut n'a pas besoin
d'être vérifié avant d'être inséré, et donc d'être purement public.
L'intérêt des fonctionnalités objets, c'est quand même de canaliser les
bogues,
et donc d'éviter que le bogue puisse survenir d'une génération
spontanée :)
En pratique[1], dans une bonne majorité des cas - tant que la valeur ne
vient pas du monde extérieur, of course.
[1] C'est à dire par expérience effective de plusieurs années sur du code
en production. Et si mon expérience personnelle te sembles insuffisante,
il y a l'expérience collective accumulée par les développeurs Python
depuis plus de quinze ans, sur des projets de toutes tailles et
complexités.
En pratique[1], dans une bonne majorité des cas - tant que la valeur ne
vient pas du monde extérieur, of course.
[1] C'est à dire par expérience effective de plusieurs années sur du code
en production. Et si mon expérience personnelle te sembles insuffisante,
il y a l'expérience collective accumulée par les développeurs Python
depuis plus de quinze ans, sur des projets de toutes tailles et
complexités.
En pratique[1], dans une bonne majorité des cas - tant que la valeur ne
vient pas du monde extérieur, of course.
[1] C'est à dire par expérience effective de plusieurs années sur du code
en production. Et si mon expérience personnelle te sembles insuffisante,
il y a l'expérience collective accumulée par les développeurs Python
depuis plus de quinze ans, sur des projets de toutes tailles et
complexités.
Dans les deux cas, on peut tout de meme s'etonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible.
Style generation bouton droit comme eclipse/java , encapsulation
interne VS/C#.
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
Dans les deux cas, on peut tout de meme s'etonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible.
Style generation bouton droit comme eclipse/java , encapsulation
interne VS/C#.
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
Dans les deux cas, on peut tout de meme s'etonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible.
Style generation bouton droit comme eclipse/java , encapsulation
interne VS/C#.
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
En pratique[1], dans une bonne majorité des cas - tant que la valeur ne
vient pas du monde extérieur, of course.
[1] C'est à dire par expérience effective de plusieurs années sur du code
en production. Et si mon expérience personnelle te sembles insuffisante,
il y a l'expérience collective accumulée par les développeurs Python
depuis plus de quinze ans, sur des projets de toutes tailles et
complexités.
Arguments non recevables.
Ce n'est pas parcequt tu as vu des gens faire quelque chose et que tu fais
apreil que cela devient une règle applicable pour tout le monde.
Preuve en est des techniques Java / C# et de quelques autres.
Après, qu'il y est plusieurs écoles et méthodologies actuellement en
pratique, cela par contre est fort possible. Mais il loin de moi l'idée de
dire qui a raison et de trancher le débat à la hache, meme si ma préférence
va aux accesseurs.
Dans les deux cas, on peut tout de meme s'etonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible. Style generation
bouton droit comme eclipse/java , encapsulation interne VS/C#. Meme si cela
relève bien sur plus de l'IDE que du langage lui meme...
En pratique[1], dans une bonne majorité des cas - tant que la valeur ne
vient pas du monde extérieur, of course.
[1] C'est à dire par expérience effective de plusieurs années sur du code
en production. Et si mon expérience personnelle te sembles insuffisante,
il y a l'expérience collective accumulée par les développeurs Python
depuis plus de quinze ans, sur des projets de toutes tailles et
complexités.
Arguments non recevables.
Ce n'est pas parcequt tu as vu des gens faire quelque chose et que tu fais
apreil que cela devient une règle applicable pour tout le monde.
Preuve en est des techniques Java / C# et de quelques autres.
Après, qu'il y est plusieurs écoles et méthodologies actuellement en
pratique, cela par contre est fort possible. Mais il loin de moi l'idée de
dire qui a raison et de trancher le débat à la hache, meme si ma préférence
va aux accesseurs.
Dans les deux cas, on peut tout de meme s'etonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible. Style generation
bouton droit comme eclipse/java , encapsulation interne VS/C#. Meme si cela
relève bien sur plus de l'IDE que du langage lui meme...
En pratique[1], dans une bonne majorité des cas - tant que la valeur ne
vient pas du monde extérieur, of course.
[1] C'est à dire par expérience effective de plusieurs années sur du code
en production. Et si mon expérience personnelle te sembles insuffisante,
il y a l'expérience collective accumulée par les développeurs Python
depuis plus de quinze ans, sur des projets de toutes tailles et
complexités.
Arguments non recevables.
Ce n'est pas parcequt tu as vu des gens faire quelque chose et que tu fais
apreil que cela devient une règle applicable pour tout le monde.
Preuve en est des techniques Java / C# et de quelques autres.
Après, qu'il y est plusieurs écoles et méthodologies actuellement en
pratique, cela par contre est fort possible. Mais il loin de moi l'idée de
dire qui a raison et de trancher le débat à la hache, meme si ma préférence
va aux accesseurs.
Dans les deux cas, on peut tout de meme s'etonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible. Style generation
bouton droit comme eclipse/java , encapsulation interne VS/C#. Meme si cela
relève bien sur plus de l'IDE que du langage lui meme...
[1] C'est à dire par expérience effective de plusieurs années sur du
code en production. Et si mon expérience personnelle te sembles
insuffisante, il y a l'expérience collective accumulée par les
développeurs Python depuis plus de quinze ans, sur des projets de toutes
tailles et complexités.
Ah bon ? Moi, j'aurais mis le polymorphisme en premier.
C'est très beau. Mais hélas pas nécessairement vrai. Tout code que tu
ajoutes est potentiellement source de bug, donc moins tu a de code (et
plus ton code est simple), moins tu a de bugs potentiels !-)
Argument on ne peut plus recevable, au contraire. Je sais par
expérience, et nous sommes des *milliers* de développeurs à partager
cette expérience, pour certains depuis plus de 15 ans, que l'accès
direct aux attributs fonctionne parfaitement dans une grande majorité
des cas. Sur des gros projets. En prod. Demande donc à Google ce
qu'ils en pensent...
Preuve en est des techniques Java / C# et de quelques autres.
Je ne m'étendrais pas sur C# que je n'ai guère utilisé (mais qui m'a
l'air partiellement moins débile que Java, au moins sur certains
points), mais en ce qui me concerne, Java est tout sauf une référence en
matière d'OO - ou alors, a contrario. La seule raison d'être des
getter/setter systématiques en Java (la seule qui ne relève pas du cargo
cult, j'entends), c'est une réserve pour refactorisation en l'absence de
support pour les attributs calculés. A preuve, dans environ 99% des cas,
les getters/setters ne font aucun contrôle d'aucune sorte.
Donc dans un
langage qui supporte les attributs calculés - ce qui est le cas, entre
autre, de Python, Ruby et PHP - les accesseurs sont dans l'écrasante
majorité des cas purements et simplement inutiles.
Ca ne relève *que* de l'éditeur. Et - once again - dans un langage qui
supporte les attributs calculés, c'est inutile.
[1] C'est à dire par expérience effective de plusieurs années sur du
code en production. Et si mon expérience personnelle te sembles
insuffisante, il y a l'expérience collective accumulée par les
développeurs Python depuis plus de quinze ans, sur des projets de toutes
tailles et complexités.
Ah bon ? Moi, j'aurais mis le polymorphisme en premier.
C'est très beau. Mais hélas pas nécessairement vrai. Tout code que tu
ajoutes est potentiellement source de bug, donc moins tu a de code (et
plus ton code est simple), moins tu a de bugs potentiels !-)
Argument on ne peut plus recevable, au contraire. Je sais par
expérience, et nous sommes des *milliers* de développeurs à partager
cette expérience, pour certains depuis plus de 15 ans, que l'accès
direct aux attributs fonctionne parfaitement dans une grande majorité
des cas. Sur des gros projets. En prod. Demande donc à Google ce
qu'ils en pensent...
Preuve en est des techniques Java / C# et de quelques autres.
Je ne m'étendrais pas sur C# que je n'ai guère utilisé (mais qui m'a
l'air partiellement moins débile que Java, au moins sur certains
points), mais en ce qui me concerne, Java est tout sauf une référence en
matière d'OO - ou alors, a contrario. La seule raison d'être des
getter/setter systématiques en Java (la seule qui ne relève pas du cargo
cult, j'entends), c'est une réserve pour refactorisation en l'absence de
support pour les attributs calculés. A preuve, dans environ 99% des cas,
les getters/setters ne font aucun contrôle d'aucune sorte.
Donc dans un
langage qui supporte les attributs calculés - ce qui est le cas, entre
autre, de Python, Ruby et PHP - les accesseurs sont dans l'écrasante
majorité des cas purements et simplement inutiles.
Ca ne relève *que* de l'éditeur. Et - once again - dans un langage qui
supporte les attributs calculés, c'est inutile.
[1] C'est à dire par expérience effective de plusieurs années sur du
code en production. Et si mon expérience personnelle te sembles
insuffisante, il y a l'expérience collective accumulée par les
développeurs Python depuis plus de quinze ans, sur des projets de toutes
tailles et complexités.
Ah bon ? Moi, j'aurais mis le polymorphisme en premier.
C'est très beau. Mais hélas pas nécessairement vrai. Tout code que tu
ajoutes est potentiellement source de bug, donc moins tu a de code (et
plus ton code est simple), moins tu a de bugs potentiels !-)
Argument on ne peut plus recevable, au contraire. Je sais par
expérience, et nous sommes des *milliers* de développeurs à partager
cette expérience, pour certains depuis plus de 15 ans, que l'accès
direct aux attributs fonctionne parfaitement dans une grande majorité
des cas. Sur des gros projets. En prod. Demande donc à Google ce
qu'ils en pensent...
Preuve en est des techniques Java / C# et de quelques autres.
Je ne m'étendrais pas sur C# que je n'ai guère utilisé (mais qui m'a
l'air partiellement moins débile que Java, au moins sur certains
points), mais en ce qui me concerne, Java est tout sauf une référence en
matière d'OO - ou alors, a contrario. La seule raison d'être des
getter/setter systématiques en Java (la seule qui ne relève pas du cargo
cult, j'entends), c'est une réserve pour refactorisation en l'absence de
support pour les attributs calculés. A preuve, dans environ 99% des cas,
les getters/setters ne font aucun contrôle d'aucune sorte.
Donc dans un
langage qui supporte les attributs calculés - ce qui est le cas, entre
autre, de Python, Ruby et PHP - les accesseurs sont dans l'écrasante
majorité des cas purements et simplement inutiles.
Ca ne relève *que* de l'éditeur. Et - once again - dans un langage qui
supporte les attributs calculés, c'est inutile.
[1] C'est à dire par expérience effective de plusieurs années sur du
code en production. Et si mon expérience personnelle te sembles
insuffisante, il y a l'expérience collective accumulée par les
développeurs Python depuis plus de quinze ans, sur des projets de toutes
tailles et
Arguments non recevables.
Argument on ne peut plus recevable, au contraire.
Je sais par expérience
Sur des gros projets. En prod. Demande donc à Google ce qu'ils en
pensent...
Je te dirais que ça dépend des projets. Je ne suis pas très loin de leur
Tu ne me prendrais pas un peu pour un bleubite, là ?-)
Si tu codes en Java ou en C++, c'est un non-choix. En PHP, c'est à mon
très humble avis - lequel se base sur plusieurs années d'expérience
professionnelle - une perte de temps pure et simple (tant bien sûr que tu
n'a pas *effectivement* besoin de l'accesseur).
Dans les deux cas, on peut tout de meme s'étonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible. Style
génération bouton droit comme eclipse/java , encapsulation interne VS/C#.
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
Ca ne relève *que* de l'éditeur. Et - once again - dans un langage qui
supporte les attributs calculés, c'est inutile.
[1] C'est à dire par expérience effective de plusieurs années sur du
code en production. Et si mon expérience personnelle te sembles
insuffisante, il y a l'expérience collective accumulée par les
développeurs Python depuis plus de quinze ans, sur des projets de toutes
tailles et
Arguments non recevables.
Argument on ne peut plus recevable, au contraire.
Je sais par expérience
Sur des gros projets. En prod. Demande donc à Google ce qu'ils en
pensent...
Je te dirais que ça dépend des projets. Je ne suis pas très loin de leur
Tu ne me prendrais pas un peu pour un bleubite, là ?-)
Si tu codes en Java ou en C++, c'est un non-choix. En PHP, c'est à mon
très humble avis - lequel se base sur plusieurs années d'expérience
professionnelle - une perte de temps pure et simple (tant bien sûr que tu
n'a pas *effectivement* besoin de l'accesseur).
Dans les deux cas, on peut tout de meme s'étonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible. Style
génération bouton droit comme eclipse/java , encapsulation interne VS/C#.
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
Ca ne relève *que* de l'éditeur. Et - once again - dans un langage qui
supporte les attributs calculés, c'est inutile.
[1] C'est à dire par expérience effective de plusieurs années sur du
code en production. Et si mon expérience personnelle te sembles
insuffisante, il y a l'expérience collective accumulée par les
développeurs Python depuis plus de quinze ans, sur des projets de toutes
tailles et
Arguments non recevables.
Argument on ne peut plus recevable, au contraire.
Je sais par expérience
Sur des gros projets. En prod. Demande donc à Google ce qu'ils en
pensent...
Je te dirais que ça dépend des projets. Je ne suis pas très loin de leur
Tu ne me prendrais pas un peu pour un bleubite, là ?-)
Si tu codes en Java ou en C++, c'est un non-choix. En PHP, c'est à mon
très humble avis - lequel se base sur plusieurs années d'expérience
professionnelle - une perte de temps pure et simple (tant bien sûr que tu
n'a pas *effectivement* besoin de l'accesseur).
Dans les deux cas, on peut tout de meme s'étonner que la "possibilité" ne
soit pas offerte. Non pas obligatoire, mais juste possible. Style
génération bouton droit comme eclipse/java , encapsulation interne VS/C#.
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
Ca ne relève *que* de l'éditeur. Et - once again - dans un langage qui
supporte les attributs calculés, c'est inutile.
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
Ah ! Est-ce qu'il ne te suffit pas alors de définir tes propres macros
dans ton éditeur favori ?
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
Ah ! Est-ce qu'il ne te suffit pas alors de définir tes propres macros
dans ton éditeur favori ?
Meme si cela relève bien sur plus de l'IDE que du langage lui meme...
Ah ! Est-ce qu'il ne te suffit pas alors de définir tes propres macros
dans ton éditeur favori ?