Suite

Pourquoi la classe arcpy.da.SearchCursor() ne se complète-t-elle pas automatiquement dans Eclipse ?

Pourquoi la classe arcpy.da.SearchCursor() ne se complète-t-elle pas automatiquement dans Eclipse ?


Je suis très nouveau dans le SIG.

Je viens d'installer eclipse luna avec le plug-in pydev et ArcGIS 10.1 for Desktop.

Lorsque j'écris un script, en essayant d'importer arcpy.da.SearchCursor, je constate qu'aucun SearchCursor n'est disponible pour la saisie semi-automatique.

Quel est le problème? Qu'est-ce que j'ai fait de mal ?


RechercheCurseurest une classe dans learcpy.damodule et non un module lui-même, donc si vous vouliez importer uniquement cette classe, vous pouvez utiliser :

depuis arcpy.da importer SearchCursor

Vous pouvez alors le référencer comme simplementRechercheCurseur.

Vous pouvez également importer l'intégralité du module et référencer la classe à l'intérieur, et il convient également de noter queimporter arcpyimporte automatiquementarcpy.daet un tas d'autres choses liées à l'arcpy.


Je ne pense pas que l'affiche originale demandait comment utiliserarcpy.da.SearchCursor(), mais plutôt que learcpy.da.SearchCursor()La classe n'apparaissait pas dans la fenêtre de complétion de code d'Eclipse (parfois appelée intellisense ou complétion de code intelligente).

J'utilise Eclipse+PyDev et/ou LiClipse pour éditer le code des outils de géotraitement depuis la sortie d'ArcGIS 10.1, et j'ai jamais été en mesure d'obtenir l'achèvement du code pour toutarcpy.damodules. Il y a quelques articles à ce sujet sur Esri GeoNet (anciennement les forums Esri), voir un, deux et trois. Dans le premier fil, Dave d'Esri dit (c'est moi qui souligne) :

L'objectif primordial du module d'accès aux données était la vitesse. Comme je suis sûr que vous le savez, l'ancien modèle de curseur n'était pas aussi rapide. Dans le cadre de cela, arcpy.da n'a pas les wrappers Python qui fournissent les listes déroulantes que vous voyez dans la plupart des arcpy. Essentiellement, il s'agissait d'un compromis entre la vitesse et la convivialité IDE, et dans ce cas, le critère dictait l'atout de la vitesse.

Donc, malheureusement, il n'y a aucun moyen d'obtenir la complétion du code d'Eclipse pour ledamodule. Cependant, vous pouvez toujours éviter le rouge ennuyeuxVariable non définie à partir de l'importation : SearchCursorerreur dans Eclipse en mettant#@Variable indéfinieà la fin de la ligne, comme ceci :

MyCursor = arcpy.da.SearchCursor("MyLayer",["*"]) #@UndefinedVariable

J'ai corrigé ce problème en ajoutant 'arcpy' et 'arcpy.da' à mon onglet 'Forced Buitins' pour mon interpréteur Arcpy Python dans eclipse. La complétion de code fonctionne et il ne marque plus des choses comme da.SearchCursor comme une variable indéfinie.


Adéquation d'Emacs en tant qu'IDE de développement Java

Je fais encore une autre tentative de conversion vers Emacs. Je suis un bon utilisateur de Vi, mais j'utilise Eclipse pour la plupart de mes travaux de développement depuis plus de 10 ans (cela fait-il si longtemps).

J'ai donc fait quelques lectures et j'ai pensé que JDEE était la voie à suivre - configurez-le mais j'ai encore quelques questions de base.

Mais, après avoir fait quelques recherches supplémentaires, il semble que JDEE ne soit pas bien entretenu et peut-être que tout ce dont j'ai besoin est CEDET ?

  1. Emacs peut-il remplacer mon Eclipse ? J'organise mon build avec Maven ?
  2. Si « 1 » est oui, par quelle suite d'outils dois-je commencer : CEDET ? JDEE ?


16 réponses 16

Je pense que l'utilisation de l'IDE aide dans le processus d'apprentissage. Les méthodes, propriétés, paramètres, surcharges et autres sont détectables. Avec les bibliothèques extrêmement énormes, Intellisense aide à infiltrer les connaissances JIT. Dans l'environnement de codage d'aujourd'hui, il est impossible de tout apprendre à l'avance, et l'apprentissage JIT est souvent le seul moyen pratique de devenir rapidement productif.

Je comprends que l'utilisation d'un IDE peut être une béquille si vous l'utilisez aveuglément, mais je pense que les avantages dépassent de loin les inconvénients.

En revanche, l'utilisation de modèles sans comprendre ce qui a été pré-construit pour vous est plus un problème. Je pense que ceux-ci peuvent être utilisés comme un outil d'apprentissage si le développeur prend le temps de lire le code modélisé. Mais la plupart des gens ne s'en soucient pas. Cela pourrait être un excellent outil d'apprentissage, cependant.

Comprendre les concepts et mémoriser des dizaines de centaines de classes et de méthodes de bibliothèque stupides sont deux choses complètement différentes. Intellisense aide à éliminer complètement toutes ces connaissances inutiles de votre esprit, et plus tôt vous le faites, mieux c'est. Laissez plus d'espace pour les concepts utiles, ne gaspillez pas vos ressources limitées sur les API.

Pour répondre à une partie mise à jour d'une question : les petits détails de syntaxe, la disposition des fichiers, l'invocation du compilateur et de l'éditeur de liens sont également sans importance par rapport aux concepts de programmation génériques. Une fois qu'ils sont compris, un novice peut approfondir sa compréhension du fonctionnement réel des éléments de bas niveau. Il est préférable de le faire lorsque vous connaissez déjà les bases, sinon vous risquez d'attraper un certain nombre de superstitions magiques dangereuses.

Par exemple, DrScheme IDE a une grande expérience dans l'enseignement de la programmation, et son succès est principalement dû à sa capacité à aider à se concentrer sur ce qui est vraiment important.

L'utilisation de la saisie semi-automatique n'est pas du tout une mauvaise chose.

C'est simplement pour la vitesse, et pour moi ce serait le signe que quelqu'un commence à maîtriser l'IDE et à bien l'utiliser.

Je ne comprends pas comment NE PAS l'utiliser les aiderait à apprendre OO par exemple.

Ayant enseigné et encadré des étudiants novices en programmation, je trouve que la saisie semi-automatique/intellisense cause parfois plus de mal que de bien. Oui, ils peuvent écrire un programme en l'utilisant. Oui, il compile et s'exécute et pourrait même faire ce que nous leur avons demandé de faire. Mais ils ne comprennent pas ce qu'ils font.

Quand ils ne comprennent pas ce qui se passe, cela devient moins de programmation et plus de piratage d'une solution ensemble pour obtenir des notes. J'ai trouvé que cela arrivait souvent avec les étudiants car ce que nous leur demandions de faire devenait plus difficile, ils se contentaient de pirater jusqu'à ce que quelque chose fonctionne. Cela devenait toujours clair lorsque la mi-session arrivait et qu'on demandait aux étudiants d'écrire des méthodes simples à la main. ils ne pouvaient pas.

Oui, la saisie semi-automatique/intellisense nous aide beaucoup (développeurs professionnels) car cela nous accélère. Nous n'avons pas besoin de mémoriser toutes les différentes méthodes et listes de paramètres, mais en même temps, nous pouvons également nous hasarder à deviner quels paramètres une méthode va prendre, car nous avons l'expérience de la programmation à connaître.

Les débutants ne le font pas. Ils attendront que leur IDE affiche une liste de méthodes, ils feront défiler cette liste jusqu'à ce qu'ils en trouvent une qui correspond peut-être à ce dont ils ont besoin, ils examineront les paramètres dont il a besoin et verront s'ils les ont à transmettre. et à la fin, ils auront piraté quelque chose ensemble qu'ils pourront remettre.

Et, à la fin du cours, lorsqu'ils recevaient leur laissez-passer, ils repartaient de leur cours de programmation avec une victoire superficielle, beaucoup ne reprenant jamais un autre cours d'informatique parce qu'ils ne comprenaient rien de ce qu'ils faisaient ou pourquoi ils l'avaient fait. il.

Le problème avec les IDE et les environnements de développement en général n'est pas tant des choses comme la saisie semi-automatique que l'utilisation de solutions basées sur des modèles (fichier|nouveau|projet) où beaucoup de choses "intéressantes" ont déjà été faites pour vous et sont, à des degrés divers, cachées .

Pour quelqu'un qui, globalement, comprend ce qui se passe sous le capot, cela est utile - mais pour quelqu'un qui apprend ce dont il a besoin, c'est plutôt moins.

Il y a aussi la question du temps nécessaire pour lancer un IDE lourd.

Je pense donc qu'utiliser quelque chose de plus léger et pouvoir exécuter des applications dans lesquelles vous avez écrit chaque ligne de code vous-même a un mérite considérable - d'autant plus que l'utilisation d'un éditeur de texte et d'un compilateur démontre le point important que vous n'avez pas besoin d'un IDE etc pour écrire des logiciels mais cela ne veut pas dire que je veux utiliser un éditeur de texte pendant longtemps et cela présente des défis en termes de débogage - vous voulez pouvoir faire des points d'arrêt et vous voulez pouvoir parcourir le code pas à pas car cela le rendra plus facile pour comprendre ce qui se passe.

Bien sûr, nous pouvons encore embrouiller le problème en considérant des choses comme Python où vous avez une ligne de commande "live".

Bonne question, pas une seule bonne réponse - sauf que vous voulez faire de l'apprentissage une progression et commencer avec un éditeur de texte et un compilateur (ou un interpréteur en ligne de commande) vous permettra de vous concentrer sur les bases de la syntaxe et de la logique avant de passer à plus des choses complexes qui seront plus faciles à faire avec un environnement de développement plus puissant.

Apprendre à la dure reste généralement avec vous.

En tant que débutant, veuillez NE PAS utiliser IDE. Utilisez la ligne de commande, apprenez de vos erreurs. Cela vous aiderait également à mieux comprendre les options du compilateur et de l'éditeur de liens.

Alors, quand utilisez-vous IDE ? Lorsque vous concevez quelque chose d'énorme ou que vous travaillez sur une énorme base de code avec des tas de classes, de méthodes et de variables.

Je serais le premier à dire que les IDE sont une aubaine pour la productivité, même si je me plains souvent de leurs bizarreries. Cependant, j'ai appris BASIC, C, C++, Java, Python, Perl, PHP et plusieurs autres langages sans rien de plus qu'un éditeur de surbrillance de texte et le compilateur/interprète pour le langage. J'ai en fait appris Java dans le Bloc-notes !

Apprendre un IDE favorise la "magie" - l'idée que "ça marche peu importe comment". L'abstraction est bonne, la magie est mauvaise. Un programmeur doit savoir ou être capable de découvrir tout ce qui se passe dans un projet. Un bon IDE est conçu pour s'occuper de la comptabilité et non pour contrôler le projet. Bien utilisé, c'est un excellent outil. Mais quel artisan commence à utiliser un routeur CNC ?

Je pense que la façon dont j'ai appris (devoir tout taper et bien connaître le compilateur pour construire un projet) m'a énormément aidé lorsque j'ai finalement commencé à utiliser les IDE. Par exemple, un projet Java n'est pas un petit dossier dans le projet Eclipse, mais une collection de classes dans une structure de package avec des fichiers XML pour les chemins, la configuration et le déploiement. Je ne voudrais pas créer une grande application d'entreprise sans IDE, mais je peux en créer de petites. Cela facilite la compréhension de la structure des gros, et quand je veux un comportement spécifique dans la construction, disons, je sais comment fonctionne javac, donc je peux modifier l'invite de construction réelle plutôt que d'essayer de trouver cette combinaison magique qui ne ' t existe dans la configuration de construction. Je pense également avoir une meilleure compréhension des messages d'erreur et de la façon de les trouver et de les corriger. Les IDE promeuvent le sentiment que, puisqu'il n'y a pas de soulignement rouge, le code est tout à fait correct.

Je n'enseignerais pas en utilisant un IDE. Je pense que les projets débutants sont suffisamment petits pour que les arguments en faveur de la gestion de la complexité soient discutables. Si vous enseignez Java, par exemple, vous pouvez placer toutes vos classes dans le même dossier et javac *.java . Vous n'avez pas besoin d'un IDE pour cela ! Cela plaide pour garder les projets petits, un peu plus que des preuves de concept. Minimisez les frais généraux et concentrez-vous sur l'enseignement du concept dont les élèves ont besoin. Les projets plus importants dans lesquels un IDE serait utile appartiennent soit à des classes SE plus avancées, soit à des projets dédiés.

En ce qui concerne l'aide à la recherche de classes et à la recherche d'API, encore une fois, je pense que cela est discutable si les projets restent petits. Toujours en Java, javadoc est très facile à lire. Personne ne peut garder toute l'API en tête de toute façon, et puis sera être un moment où vous devrez rechercher une API sans bénéficier d'un IDE. Comme, dans d'autres langues, ou si vous êtes à distance sur un serveur où vous ne pouvez pas ouvrir l'IDE. Enseignez comment trouver de la documentation, pas "appuyez sur '.' et vous pouvez voir quelles sont les méthodes d'un objet."

N'importe quel programmeur peut apprendre un IDE, mais connaître un IDE ne fait pas de vous un bon programmeur. L'humour noir mis à part, « magie » n'est jamais un bon mot à utiliser pour un programmeur.


Curseur de recherche ArcPy

Un curseur de recherche n'est-il qu'une requête de définition itérative ? J'ai lu l'aide maintes et maintes fois, et je sais que vous pouvez utiliser des jetons pour obtenir différentes choses. Je dois parcourir une couche d'entités et lui appliquer une fonction individuellement. En le faisant à la main, je définirais une requête de définition pour la fonctionnalité spécifique, je ferais la chose, puis j'ajouterais la couche de sortie à la couche finale et je répéterais ad nauseam.

Donc, logiquement, je penserais à le faire en définissant la requête de définition pour faire défiler une liste de numéros d'identification d'objet que j'obtiendrais avec un curseur de recherche, puis en branchant une autre boucle for pour la requête de définition, mais puis-je simplement faire la fonction à l'intérieur la boucle du curseur de recherche à la place ? Puis-je simplement mettre la couche d'entrée en tant que couche sur laquelle le curseur de recherche passe et l'appliquer uniquement à la ligne sur laquelle se trouve le curseur à ce moment-là ?

Je pense que si vous pouviez être un peu plus précis sur ce que vous essayez d'accomplir, cela pourrait nous être utile de comprendre ! En termes d'entrées, ce que vous entendez par "fonction" et sorties.

Les curseurs vous permettent de parcourir vos données et de les lire (rechercher), de les ajouter (insérer) ou de les modifier (mettre à jour) au fur et à mesure. Je ne peux penser à aucune situation dans laquelle je voudrais appliquer des requêtes de définition dans un curseur, donc je penche pour "faire la fonction à l'intérieur du curseur de recherche" comme étant la solution appropriée.

Si vous pensez à itérer une table de manière séquentielle, le curseur est la description de votre emplacement à un point donné. Pensez à un curseur se déplaçant sur un document texte lorsque vous appuyez sur la touche fléchée.

Lorsque vous créez un curseur, vous définissez précisément sur quoi vous allez itérer. Ensuite, vous écrivez votre énumération pour définir comment vous déplacez votre curseur dans la table et placez votre bloc de code dans cette énumération. EG : pour la ligne dans search_cursor.rows : faites la chose.

Je ne suis pas ce que vous dites que vous voulez vraiment sortir de ce code, mais je vous conseillerais d'examiner attentivement si vous pouvez obtenir ce dont vous avez besoin sans boucles d'imbrication. Les boucles imbriquées tuent les performances, utilisez-les donc uniquement lorsque cela est nécessaire.

1er : utilisez arcpy.da.SearchCursor et non l'ancien arcpy.SearchCursor. Le ⟚' est une amélioration monumentale par rapport à l'ancien.

Passons à votre question.
Une requête de définition n'est qu'un filtre pour votre couche d'entités. (par exemple, Status = ➬tive' limitera votre couche aux seules entités ➬tive'.) Cela ne vous permet pas de travailler sur une seule entité, à moins que votre requête de définition n'aboutisse à un seul enregistrement.
Pour le faire dans arcpy : arcpy.MakeFeatureLayer(<feature class>, <layer name>, <SQL definition query>)
Ensuite, exécutez votre curseur sur <layer name> (vous pouvez également simplement déposer votre requête de définition <sql> directement dans le curseur de recherche).

Un curseur de recherche vous permet d'opérer sur un seul enregistrement (d'une table, d'une vue ou d'une couche) à la fois. Les curseurs da vous obligent à répertorier les champs avec lesquels vous souhaitez travailler. Pour continuer l'exemple ci-dessus.

en utilisant le 'with' ci-dessus, le curseur et les objets de ligne seront automatiquement nettoyés à la fin du curseur.


Vous recherchez des suggestions sur la façon de transmettre une itération da.SearchCursor lorsqu'un champ peut exister ou non.

Disons que j'ai un outil ArcToolBox avec le premier paramètre étant la classe d'entités ponctuelles et le second étant un paramètre facultatif pour spécifier un champ d'altitude s'il existe. Ensuite, le script aura quelque chose comme suit :

Maintenant, cela fonctionnera correctement si un champ d'élévation est spécifié, mais sinon, il renverra RuntimeError : une colonne a été spécifiée qui n'existe pas. comme prévu. Quelle est une façon propre de contourner ce problème ? Auparavant, j'avais fait un essai/sauf . Quelque chose comme ça:

Existe-t-il un moyen plus propre/plus propre de gérer ce champ d'élévation facultatif ?

Donc, en fonction de votre modification et de la façon dont j'implémente la fonction, mon interprétation est-elle correcte selon laquelle cela ne raccourcit pas exactement le code, mais dans cette situation, un if/else est préféré à try/except ? Je ne vois peut-être pas cela comme prévu, mais en utilisant votre fonction, je fais quelque chose comme :

Je réserve habituellement try and except (au moins d'après mon expérience) pour la gestion des erreurs.

Si je comprends correctement votre problème (pourriez utiliser un peu plus de contexte ici), je pense que votre meilleur pari serait de générer une liste de champs qui se trouvent dans la classe d'entités avant vous exécutez le curseur. À partir de là, vous pouvez faire une instruction if aussi simple que celle-ci :

Et puis exécutez votre curseur après cela. Ensuite, placez simplement une instruction else pour exécuter le code comme s'il n'y avait pas de champ d'élévation.

Cela suppose que vous souhaitez que le code s'exécute de deux manières distinctes en fonction de l'existence ou non d'un champ d'élévation.

EDIT : Je n'ai même pas vu la réponse /u/K7MFC (problèmes de reddit ?), mais c'est probablement plus efficace et flexible que de générer une liste de noms de champs.

Les autres donnent de bonnes suggestions pour gérer cela uniquement dans le code, mais je recommanderais de faire remonter le choix jusqu'à l'interface utilisateur, afin qu'il soit clair pour l'utilisateur qu'une opération différente est effectuée si aucun champ d'élévation n'est spécifié.

Pour ce faire, ajoutez un paramètre supplémentaire à votre boîte à outils appelé "Champ d'élévation". Lors de la configuration du paramètre, définissez-le sur Facultatif au lieu de Requis pour le type. Pour "Obtenu de", sélectionnez votre paramètre de classe d'entités. Cela remplira la liste déroulante avec tous les champs de la classe d'entités dans laquelle vous déposez. Comme il s'agit d'un paramètre facultatif, les utilisateurs peuvent le laisser vide ou sélectionner le champ d'altitude approprié.

Ensuite, dans le code, cela ressemblerait à ce qui suit. Ici, vous avez une logique de branchement basée sur si un champ d'élévation est fourni. Aucun essai/sauf étranger. L'autre avantage de cette approche est que vous n'aurez pas à valider que le champ existe dans le code puisque les utilisateurs devront sélectionner un champ dans la liste déroulante fournie par l'interface utilisateur. Votre paramètre de champ sera soit vide, soit un champ valide.


Le cadre du robot ne récupère pas l'implémentation des mots clés

J'essaie de configurer un robot au-dessus d'un projet java Eclipse Maven-Selenium-TestNG que j'ai créé, mais il ne semble pas récupérer les mots-clés par défaut (je n'ai même pas encore essayé d'ajouter les miens). J'ai installé python 3.4.3 sur ma machine Win 10 et j'utilise le maven intégré fourni avec Eclipse.

J'ai commencé par créer un projet maven et ajouter à pom.xml les dépendances pour selenium 3.4, testNG 6.8 et robot 3.0.2, puis j'ai également ajouté le plugin robot 1.4.7. Enfin, mis à jour le projet afin que maven télécharge tous les éléments nécessaires afin que je n'aie rien à installer en externe.

Pour tester le sélénium (sans robot), j'ai créé une classe textNG dans src>test>java, ajouté une propriété système pointant vers le fichier chromedriver.exe dans mon système et ajouté un test simple qui ouvre le navigateur et navigue vers google. Cela a fonctionné, alors maintenant je veux ajouter un cadre de robot.

J'ai créé un fichier dans src/test/robotframework/acceptance, avec le contenu suivant (bien que j'aie lu quelque part qu'après sélénium 2 les mots-clés "start/stop selenium server" ne sont pas nécessaires, mais rien ne change si je les supprime) :

Lorsque je lance en tant qu'installation maven, j'obtiens:

Échec de l'installation : aucun mot-clé portant le nom "Démarrer le serveur Selenium" n'a été trouvé.

Le démontage a également échoué : aucun mot-clé portant le nom « Stop Selenium Server » n'a été trouvé.

Alors pourquoi ce robot ne trouve-t-il pas la mise en œuvre des mots-clés ? Et comment ajouter des implémentations de mes propres mots clés ?


2 réponses 2

Pour récupérer les objets du package géré avec vos métadonnées personnalisées, vous devez ajouter manuellement les objets que vous souhaitez récupérer dans votre fichier package.xml. Par exemple, pour récupérer un objet personnalisé, vous récupérez peut-être déjà l'objet Compte comme ceci :

Il vous suffit d'ajouter le nom de l'objet avec espace de noms à cette liste. Il s'agit du « Nom de l'API » visible sur la page de l'objet dans l'interface utilisateur de Salesforce

Si vous souhaitez simplement récupérer les champs que vous ajoutez à cet objet pour un déploiement ultérieur, vous pouvez les spécifier dans un type CustomField

N'oubliez pas que les règles CRUD/FLS pour tous les profils que vous récupérez incluront cet objet/champ.

Veuillez également consulter ma réponse à cette question similaire sur les mises en page Comment récupérer les mises en page des objets douaniers appartenant à un package géré ?.

Cette technique s'applique généralement à la plupart (tous ?) des objets de l'API de métadonnées.


Oui, im et les autres utilisateurs utilisent toujours Aptana pour le développement WP et fonctionnent très bien. Vous devez uniquement inclure votre installation de WP for Dev ou Stable au projet de votre plugin, c'est tout. Vous pouvez maintenant utiliser toutes les fonctions, vars, class . à l'intérieur de votre plugin de l'installation WP référencée.

Si vous démarrez un nouveau projet, peut-être un plugin, ajoutez le répertoire ou le projet externel dans l'onglet PHP Buildpath des propriétés. Alternativement, vous pouvez modifier les propriétés via le menu contextuel, le bouton droit de la souris sur le projet et ajouter le chemin ou le projet dans le PHP Buildpath.

pour les utilisateurs de Linux avec Ubuntu Natty

Si vous n'avez pas le menu de commande sur votre installation Linux (si vous utilisez Linux, utilisez ce hack.

via le menu de commande

Vous pouvez également utiliser le menu de commande pour ajouter un bundle, WordPress est également à l'intérieur via Core d'Aptana Studio 3. Cliquez Commandes --> Développement d'offres groupées --> Installer l'ensemble --> Cliquez WordPress et que d'accord c'est tout.

Après cela, vous avez toutes les fonctions, etc.


6 réponses 6

Je ne suis d'accord avec aucune des deux propositions.

Les constantes doivent être dans leur cours pertinents, pas dans une classe tout-constante dans l'une ou l'autre des deux formes proposé.

Il ne devrait pas y avoir de classes/interfaces uniquement constantes.

Une classe CreditCard (pas une classe interne) doit exister. Cette classe/interface possède des méthodes relatives aux cartes de crédit ainsi que les constantes UI_EXPIRY_MONTH et UI_ACCOUNT_ID .

Il doit exister une classe/interface BankAccount (pas une classe interne). Cette classe/interface a des méthodes relatives aux comptes bancaires ainsi qu'une constante UI_ACCOUNT_ID .

Par exemple, dans l'API Java, chaque classe/interface a ses constantes. Ils ne sont pas dans une classe/interface Constants avec des centaines de constantes, regroupées ou non dans des classes internes.

Par exemple, ces constantes pertinentes pour les jeux de résultats se trouvent dans l'interface ResultSet :

Cette interface a des signatures de méthode relatives aux ensembles de résultats, et les classes d'implémentation implémentent ce comportement. Ce ne sont pas de simples détenteurs de constantes.

Ces constantes pertinentes pour les actions de l'interface utilisateur se trouvent dans l'interface javax.swing.Action :

Les classes d'implémentation ont un comportement relatif aux actions de l'interface utilisateur, elles ne sont pas de simples détenteurs constants.

Je connais au moins une interface "constantes" ( SwingConstants ) sans méthode mais elle n'a pas des centaines de constantes, juste quelques-unes, et elles sont toutes liées aux directions et aux positions des éléments de l'interface utilisateur :

Je pense que les classes constantes uniquement ne sont pas une bonne conception OO.

il s'est avéré que les constantes sont trop dispersées et devraient toutes être organisées dans un seul fichier de constantes "maître".

C'est le 100% mauvaise solution au problème des constantes "difficiles à trouver". C'est une erreur fondamentale (malheureusement trop souvent perpétrée par les programmeurs) de regrouper les choses selon des critères techniques comme les constantes, les énumérations ou les interfaces.

Sauf pour les architectures de couches, les choses doivent être regroupées par leur domaine, et des constantes d'autant plus que ce sont des éléments de très bas niveau. Les constantes doivent faire partie des classes ou des interfaces qui les utilisent dans le cadre de leur API. Si vous ne pouvez pas leur trouver un endroit naturel pour vivre, vous devez nettoyer la conception de votre API.

Aditionellement, un seul énorme fichier de constantes tue la vitesse de développement en Java car les constantes sont intégrées dans les classes qui les utilisent au moment de la compilation, donc tout changement force une recompilation de tous ces fichiers et de tout ce qui en dépend. Si vous avez un fichier avec des constantes qui sont utilisées partout, vous perdez en grande partie le bénéfice de la compilation incrémentielle : regardez Eclipse se verrouiller pendant 15 minutes car il recompile l'intégralité de votre projet pour chaque modification apportée à ce fichier. Et comme ce fichier contient toutes les constantes utilisées n'importe où, vous le modifierez assez souvent. Oui, je parle par expérience personnelle.


picocli est différent des autres bibliothèques Java CLI :

  • Il est conçu pour être inclus sous forme de source. Cela permet aux utilisateurs d'exécuter des applications basées sur picocli sans nécessiter picocli comme dépendance externe.
  • Génère une aide à l'utilisation polie et facilement personnalisable, en utilisant les couleurs ANSI lorsque la plate-forme sous-jacente la prend en charge. pour vos applications en ligne de commande Java sur les plateformes prises en charge

Exemple de message d'aide à l'utilisation :

  • Analyse de ligne de commande sans effort - il suffit d'annoter les champs
  • Tout fortement typé - options de ligne de commande ainsi que paramètres de position
  • prise en charge complète du style GNU et des options courtes en cluster POSIX (il gère donc <command> -xvfInputFile ainsi que <command> -x -v -f InputFile )
  • Un modèle d'arité qui permet un nombre minimum, maximum et variable de paramètres, par exemple, "1..*" , "3..5"
  • Sous-commandes
  • Fonctionne avec Java 5 et supérieur
  • Manuel d'utilisation bien structuré

L'aide à l'utilisation est le visage de votre application, alors soyez créatif et amusez-vous !

Picocli est également activement entretenu. Depuis la publication d'origine, de nombreuses nouvelles fonctionnalités ont été ajoutées, par exemple :