Il suffit de faire un bloc de données.
Il suffit de faire un bloc de données.
ie ? Une structure (C) ? Dans ce cas le problème est déplacé : le bout de code à conserver pour réutilisation est la suite des définitions de chaque variable, je me trompe ?
pas forcement. Tout dépend comment tu organise ton code.
Un bloc de code c’est une boite dans laquelle tu as des entrées et des sorties; et dedans un traitement. C’est le traitement qui définit les variables d’entrées et de sorties (on parle ici de blocs de code, bien sur).
Bonjour,
C’est probablement trop simpl(ist)e et surtout pas le style d’outil recherché,
mais on peut faire ce genre d’insertion de « bout de code » (ou de texte) avec les Snippets de Geany.
Ça tient dans un fichier texte.
Tu auras probablement besoin d’écrire un bout de script pour automatiser les sauts de lignes et autres indentations et échappements de quelques caractères.
L’usage est ultra simple ,
on tape le mot-clé correspondant au snippet à insérer et [Tab] ;
les snippets pour les divers languages vont chacun dans une section dédiée,
qu’ on peut créer selon les besoins.
Voici un échantillon pour les scripts BASH :
#######
# SHELL
#######
[Sh]
bang=#!/bin/bash
header=#!/bin/bash\n#\n# \n# Script:\t%cursor%.sh \n# Auteur:\tToto \n# Date:\t\t\n# Version:\t0.1\n#\n# Fonction:\t\n#\n#\n#\n#################################\n
for=for var in item1 item2 ;\n\tdo\n\t\t<liste>;\ndone\n
while=while <liste-1>;\n\tdo\n\t\t<liste-2>;\ndone\n
if=if <liste>;\n\tthen\n\t\t<liste>;\n\telif\n\t\t<liste>;\n\tthen\n\t\t<liste>;\n\telse\n\t\t<liste>;\nfi
func=maFonction\s()\n\t{\n\t<cmdes>\n\t}
#
# Scripts Modulaires
msge=cat ${MOD_DIR}/%cursor%.msg ;
mod=source ${MOD_DIR}/%cursor%.sh ;
nocomment=cat <file> | grep -vP '(^$|^[\\t\\s]*#)'
....
Avec ce qui précède, taper : header+[Tab]
produit dans un ficher *.sh :
#!/bin/bash
#
#
# Script: _.sh
# Auteur: Toto
# Date:
# Version: 0.1
#
# Fonction:
#
#
#
#################################Pas si simpliste car c’est le fondement de la méthode UML et de SADT: faire du code réutilisable.
Mais effectivement, c’est peut être trop complexe ici. Encore que l’utilisation de code en copié collé soit aussi une des cause de non qualité dans les codes développés à travers le monde.
@nh3oh
Bonjour et merci pour ta réponse,
D’accord avec @Zargos : ça n’a pas l’air si simple. Mais si ça fait le job alors ça vaut le coup de le faire.
Mais je crois comprendre que c’est une fonctionnalité Geany. Or j’utilise Qt Creator et mon projet est beaucoup trop avancé pour envisager un portage sous Geany.
Encore que l’utilisation de code en copié collé soit aussi une des cause de non qualité dans les codes développés à travers le monde.
Triste monde en effet. Borges convenait effectivement que « le langage est un ensemble de citations » (Le livre des sables). Le langage informatique étant par nature plus simple qu’une langue vivante, les duplications de code semblent inévitables.
Plus sérieusement, tu évoques plus haut une organisation du code pour répondre à mon besoin. Peux-tu être plus clair ?
Si je reprends l’exemple de mon bout de code :
- instanciant une boîte de dialogue ;
- fixant les paramètres P1 de cette boîte de dialogue ;
- affichant cette boîte de dialogue.
Si j’appelle ce bout de code BdC(P1) de 6 lignes, je souhaite - par pure fainéantise - le mettre quelque part pour le réutiliser plus tard ailleurs sous la forme BdC(P2), soit une même boîte de dialogue mais avec d’autres paramètres.
Je pourrais bien sûr définir une structure (struct du C) de données S contenant les paramètres et envoyer des instances de S à une fonction contenant BdC. Mais dans ce cas, j’ai un nouveau « bout de code » pour affecter chaque membre de S et appeler la fonction. Je serais alors intéressé, pour gagner du temps, de mettre de côté cette succession d’instructions pour réemploi ultérieur, en adaptant les variables bien sûr.
Comment ferais-tu dans ce cas là ?
Geany est juste un éditeur de texte avec des fonctionnalités supplémentaires,
il semble donc envisageable de ne l’utiliser que pour les insertions.
Geany prévient et propose de recharger les fichiers en cours d’édition, s’ils ont été modifiés par ailleurs ; Qt creator (que j’ignore) doit aussi en être capable.
Geany dispose d’un panneau latéral avec (entre autres) une fonction gestionnaire de fichiers, il dispose aussi (dans le même panneau) d’un gestionnaire de projet permettant un ciblage des fichiers en relations.
Je n’ai pas d’actions sur Geany 
… c’est juste pour te donner une idée des possibilités
et faire gagner du temps dans tes choix.
@+
J’utiliserai de la programmation object car c’est justement pour cela qu"elle a été créée.
Tu as une classe d’objet avec :
- Des données externes (tes paramètres d’entrées et/ou de sortie)
- Des données internes (uniquement utilisées par l’object)
- Des traitements
Tu instancies alors cet objet tel qu’il est.
Tu as besoin de modifier cet objet mais tout en conservant sa classe d’origine. Dans ce cas:
- Tu créées une classe héritée de la classe précédent
- Tu surclasses les données et les traitements que tu veux modifier (le mot surclasse n’est pas le bon mais j’ai oublié le mot correct que quelqu’un pourra corriger
) - Tu surclasses
Tu as alors deux classe que tu peux instancier indifféremment.
Si tu veux modifier la même chose dans les deux, tu modifies la classe père, et celle-ci sera automatiquement prise en compte dans la classe fils. Quitte dans celle-ci à ne modifier que ce qui importe au regard de ce qui a été déjà différencié.
C’est en fait une part des fondements de la programmation objet.
Dans le corps principal ne sont utilisé que des objets avec des entrées, des sorties et un traitement. La façon dont est fait le code interne de ces objet n’y est plus d’importance.
Le fondement principal est de pouvoir réutiliser du code d’un programme à un autre.
@Zargos
Je suis bien dans le cadre d’un programme orientée objet. Je te propose donc de te traduire dans le cas de l’exemple d’une boîte de dialogue simple de type message à l’utilisateur.
Je définis une classe MaBoiteD comptant des données membre, les « seteur » associés et une méthode qui va finalement afficher ma boîte de dialogue avec en paramètres les données membre.
Pas besoin dans ce cas de données « internes » à la classe.
J’instancie la classe dans un objet « parent », je me retrouve avec un objet maBoiteD. Grâce aux « seteurs », je fixe la valeur des variables membre (ici, 4 lignes de codes). Enfin j’appelle la méthode d’affichage, 1 ligne de code.
Si je veux alors, à un autre endroit de mon objet parent, ouvrir une boîte de dialogue avec des valeurs différentes, j’écris à nouveau 5 lignes de codes. C’est là qu’un catalogue de « bouts de code » m’intéresse afin de gagner quelques minutes, je te l’accorde… dans le cas présent.
Maintenant imaginons un objet qui contiendrait toutes les boîtes de dialogue « message simple à l’utilisateur » employées dans l’application. Je me retrouve alors avec une classe contenant une succession de méthodes, toutes aillant la même suite de bouts de code, qui vont fixer la valeur des variables et appeler la méthode d’affichage.
La classe parent devient alors beaucoup plus lisible, mais mon petit souci de bout de code est déplacé dans la classe collection de boîte de dialogue, ce qui est plus simple à gérer…
ça c’est valable pour cet exemple.
Concernant le cas n° 1 ci-dessus (affichage d’un sablier), c’est différent car il y a deux lignes de code qui encadrent un traitement long.
Pourquoi ne pas utiliser un compte gitlab ?
Avec le format Markdown, le code est respecté et avec la coloration syntaxique.
On peut utiliser le dépôt, les snippets ou le wiki pour un projet et organiser en fonction de ses besoins.
J’utilise pas github mais j’imagine que les fonctionnalités sont similaires.
En plus, on il est possible d’avoir les infos en ligne. En local, on perd la recherche mais il possible de visualiser le markdown ou le code simplement.
Il y a longtemps j’utilisais Zim wiki puis je suis passer à Dokuwiki et j’utilise de plus en plus gitlab.
@nh3oh
Oui, Qt Creator détecte les changements et recharge un fichier modifié ailleurs que dans l’IDE. Donc ta solution marcherait.
Toutefois c’est sans doute un peu trop élaboré pour ce que je souhaite faire.
Mais je retiens la possibilité !
@yatta
Ah Git… longue bataille en ce qui me concerne… J’utilise rarement, et c’est un tord, et à chaque fois dans la douleur.
Comme la solution de @nh3oh cela me semble un brin plus complexe que ce que je souhaite : à savoir juste avoir une sorte de calepin électronique dans lequel je prends des notes pour éviter de rechercher une seconde fois les commandes ad-hoc dans tel ou tel cas.
Merci !
Alors tester Zim : apt install zim
Alors tester Zim
Après un petit essai et ça a l’air bien.
J’aime bien la possibilité de faire des liens d’une page vers une autre, ça fera un index.
Merci !
Zim est quasi la première application que j’installe sur un système neuf avec GUI,
car il me permet de noter toutes les modifications apportées au système tout au long de son existence.
Voir le manuel [F1]
… pour les liens :
- entre pages,
- dans la page,
- vers pages d’autres blocs-notes,
- vers des répertoires et fichiers locaux,
- et vers le web,
bref tout ce que l’on veux et tout ça dans des fichiers *.txt
J’espère que tu vas apprécier les services rendus.
Le style d’affiche d’origine, n’est pas génial,
mais ça se modifie dans :
~/.config/zim/style.conf
1 J'aime
@nh3oh
Oui, merci encore pour l’info !
J’ai poussé un peu plus loin mes essais et l’outil me paraît assez puissant !
En tout cas il règle un soucis que j’avais avec Zotero : il conserve la mise en forme du texte.
Bien vu pour la modification du style d’origine, j’ai pu adapter la couleur des liens qui avaient un contraste trop faible avec mon thème global sombre.