La version 2 d'AutoHotkey, le langage de script gratuit et open source pour Windows, est disponible

1 pièce(s) jointe(s)

La version 2 d'AutoHotkey, le langage de script gratuit et open source pour Windows, est disponible,
elle améliore la convivialité et la commodité du langage en sacrifiant la rétrocompatibilité

AutoHotkey v2 vise à améliorer la convivialité et la commodité du langage et de l'ensemble des commandes en sacrifiant la rétrocompatibilité. Ainsi, les scripts écrits pour la v1 ne fonctionneront généralement pas sans modifications sur la v2. La syntaxe est globalement plus cohérente, avec beaucoup moins de bizarreries et de pièges, et de nombreuses autres améliorations ont été apportées.

AutoHotkey est un langage de script gratuit et open source pour Windows qui permet aux utilisateurs de créer facilement des scripts, petits ou complexes, pour toutes sortes de tâches telles que : remplissage de formulaires, clics automatiques, macros. L'objectif initial est de fournir des raccourcis clavier faciles ou hotkeys, une macro-création rapide et une automatisation logicielle permettant aux utilisateurs de tous niveaux de compétences informatiques d'automatiser des tâches répétitives dans n'importe quelle application Windows. Les interfaces utilisateur peuvent facilement être étendues ou modifiées par AutoHotkey.

Pièce jointe 631970

AutoHotkey ne fait rien par lui-même ; il a besoin d'un script pour lui dire quoi faire. Un script est simplement un fichier de texte brut avec l'extension .ahk contenant des instructions pour le programme, comme un fichier de configuration, mais beaucoup plus puissant. Un script peut se contenter d'exécuter une seule action et de quitter le programme, mais la plupart des scripts définissent un certain nombre de touches de raccourci, chacune d'entre elles étant suivie d'une ou plusieurs actions à exécuter lorsque la touche de raccourci est enfoncée.
#z::Run "https://www.autohotkey.com" ; Win+Z
Code:

1 2 3 4 5 6 7 ^!n:: ; Ctrl+Alt+N { if WinExist("Untitled - Notepad") WinActivate else Run "Notepad" }
Voici, ci-dessous, quelques améliorations qu’apporte la version 2 d’AutoHotkey

Suppression de la syntaxe héritée

Suppression des affectations littérales : var = valeurSuppression de toutes les instructions If héritées, ne laissant que l'expression if, qui ne nécessite jamais de parenthèses (mais les autorise, comme dans toute expression).

Suppression de la « syntaxe de commande ». Il n'y a pas de « commandes », seulement des instructions d'appel de fonction, qui sont juste des appels de fonction ou de méthode sans parenthèses. Cela signifie que :

Toutes les anciennes commandes sont désormais des fonctions (à l'exception des instructions de flux de contrôle) ;
Toutes les fonctions peuvent être appelées sans parenthèses si la valeur de retour n'est pas nécessaire (mais comme auparavant, les parenthèses ne peuvent pas être omises pour les appels dans une expression) ;
Tous les paramètres sont des expressions, donc tout le texte est "cité" et les virgules ne doivent jamais être échappées. Actuellement, cela exclut quelques directives (qui ne sont ni des commandes ni des fonctions) ;
Les paramètres sont les mêmes indépendamment des parenthèses ; c'est-à-dire qu'il n'y a pas de variable de sortie pour la valeur de retour, elle est donc rejetée si les parenthèses sont omises ;
Les références normales à des variables ne sont jamais entourées de signes de pourcentage (sauf avec #Include et #DllLoad). Utilisez la concaténation ou le format pour inclure les variables dans le texte ;
Il n'y a pas de virgule entre le nom de la fonction et les paramètres, donc MouseGetPos(, y) = MouseGetPos, y (x est omis). Un espace ou une tabulation est nécessaire pour plus de clarté. Par souci de cohérence, les directives suivent également la nouvelle convention (il ne doit pas y avoir de virgule entre le nom de la directive et le paramètre) ;
Les déclarations d'appel de méthode (appels de méthode qui omettent les parenthèses) sont limitées à une simple variable suivie d'un ou plusieurs identifiants séparés par des points, comme par exemple MaVar.MaPropriété.MaMéthode "Chaîne à passer".

Étiquettes des touches de raccourci et des chaînes de raccourci

Les touches de raccourci et les chaînes de raccourci non automatiques ne sont plus des étiquettes ; elles définissent (automatiquement) une fonction. Pour les raccourcis de plusieurs lignes, utilisez des accolades pour entourer le corps du raccourci au lieu de le terminer par return (qui est impliqué par l'accolade de fin). Pour permettre à un raccourci d'être appelé explicitement, spécifiez funcName(ThisHotkey) entre les : : et { - cela peut également être fait dans la v1.1.20+, mais il y a maintenant un paramètre. Lorsque la définition de la fonction n'est pas explicite, le paramètre est nommé ThisHotkey.

Noms

Les noms de fonctions et de variables sont maintenant placés dans un espace de noms partagé. Chaque définition de fonction crée une constante (variable en lecture seule) dans la portée actuelle.

Pour appeler une fonction lorsque tout ce que vous avez est un nom de fonction (chaîne de caractères), utilisez d'abord un double-deref pour résoudre le nom en une variable et récupérer sa valeur (l'objet fonction). %myVar%() effectue maintenant un double déréférencement, puis appelle le résultat, ce qui équivaut à f := %myVar%, f().

Évitez autant que possible de manipuler les fonctions par leur nom (chaîne de caractères) ; utilisez plutôt des références. Les noms ne peuvent pas commencer par un chiffre et ne peuvent pas contenir les caractères suivants qui étaient auparavant autorisés : @ # $. Seuls les lettres, les chiffres, les traits de soulignement et les caractères non ASCII sont autorisés.

Utilisez MaFunc à la place de Func("MaFunc").
Utilisez MyFunc à la place de "MyFunc" lorsque vous passez la fonction à une fonction intégrée telle que SetTimer ou Hotkey. Le passage d'un nom (chaîne de caractères) n'est plus pris en charge.

Utilisez myVar() à la place de %myVar%() lorsque vous appelez une fonction par valeur.
Mots réservés : Les mots-clés de déclaration et les noms des instructions de flux de contrôle ne peuvent pas être utilisés comme noms de variables, de fonctions ou de classes. Cela inclut :

local, global, static, if, else, loop, for, while, until, break, continue, goto, return, switch, case, try, catch, finally et throw.
Mots réservés : as, and, contains, false, in, is, IsSet, not, or, super, true, unset

Ces mots sont réservés à une utilisation future ou à d'autres fins spécifiques, et ne sont pas autorisés comme noms de variables ou de fonctions, même s'ils ne sont pas ambigus. Il s'agit principalement d'un souci de cohérence : dans la v1, and := 1 était autorisé sur sa propre ligne, mais (and := 1) ne fonctionnait pas.

Les mots listés ci-dessus sont autorisés comme noms de propriétés. Les noms de propriétés sont généralement précédés de ., ce qui empêche le mot d'être interprété comme un opérateur. En revanche, les mots-clés ne sont jamais interprétés comme des noms de variables ou de fonctions dans une expression. Par exemple, not(x) est équivalent à not (x) ou (not x).

Un certain nombre de classes sont prédéfinies, réservant effectivement ces noms de variables globales de la même manière qu'une classe définie par l'utilisateur. (Toutefois, les modifications de la portée décrites ci-dessous atténuent la plupart des problèmes qui en découlent).

Portée

Les variables super-globales ont été supprimées (à l'exception des variables intégrées, qui ne sont pas tout à fait les mêmes puisqu'elles ne peuvent pas être redéclarées. Dans une fonction assumée-locale, si un nom donné n'est pas utilisé dans une déclaration ou comme cible d'une affectation non dynamique ou de l'opérateur de référence (&), il peut être résolu vers une variable globale existante.

En d'autres termes :

Les fonctions peuvent désormais lire les variables globales sans les déclarer ;
Les fonctions qui n'ont pas de déclaration globale ne peuvent pas modifier directement les variables globales (éliminant ainsi une source d'effets secondaires involontaires) ;
L'ajout d'une nouvelle classe au script est beaucoup moins susceptible d'affecter le comportement d'une fonction existante, car les classes ne sont pas super-globales ;
Le mot-clé global est actuellement redondant lorsqu'il est utilisé dans une portée globale, mais il peut être utilisé pour plus de clarté. Les variables déclarées de cette façon sont maintenant beaucoup moins susceptibles d'entrer en conflit avec les variables locales (comme lors de la combinaison de scripts manuellement ou avec #Include), car elles ne sont pas super-globales. D'un autre côté, une certaine commodité est perdue ;
Les déclarations ne sont généralement pas aussi nécessaires.

Variables

Les variables statiques locales sont initialisées si et quand l'exécution les atteint, au lieu d'être exécutées dans un ordre linéaire avant le début de la section d'auto-exécution. Chaque initialisation n'a aucun effet la deuxième fois qu'elle est atteinte. Les déclarations multiples sont autorisées et peuvent s'exécuter pour la même variable à des moments différents. Les avantages sont multiples :

Lorsqu'un initialisateur statique appelle d'autres fonctions avec des variables statiques, il y a moins de risque que les initialisateurs n'aient pas encore été exécutés en raison de l'ordre des définitions de fonction ;
Comme la fonction a été appelée, les paramètres, A_ThisFunc et les fermetures sont disponibles (ils ne l'étaient pas auparavant) ;
Une variable statique peut être initialisée de manière conditionnelle, ce qui ajoute de la flexibilité, tout en ne s'exécutant qu'une seule fois sans avoir besoin de if IsSet() ;
Comme il peut y avoir plusieurs initialisateurs pour une seule variable statique, les affectations composées telles que static x += 1 sont autorisées. (Cette modification a permis de réduire marginalement la taille du code, car elle était déjà autorisée par local et global).
Remarque : static init := somefunction() ne peut plus être utilisé pour exécuter automatiquement une fonction. Cependant, puisque les sous-routines basées sur les étiquettes et les retours peuvent maintenant être complètement évitées, la section d'auto-exécution peut couvrir tout le script.
Déclarer une variable avec local ne fait plus que la fonction assume-global.

Les doubles-références sont maintenant plus cohérentes avec les variables résolues au moment du chargement, et ne sont plus capables de créer de nouvelles variables. Cela permet d'éviter certaines incohérences et des points de confusion courants.
Les doubles déréférencements qui échouent pour une raison quelconque provoquent maintenant une erreur. Auparavant, les cas avec un nom invalide produisaient silencieusement une chaîne vide, tandis que les autres cas créaient et retournaient une variable vide.

Expressions

Les chaînes littérales citées peuvent être écrites avec des guillemets "doubles" ou "simples", mais doivent commencer et se terminer par la même marque. Les guillemets littéraux sont écrits en faisant précéder la marque d'un caractère d'échappement - `" ou `' - ou en utilisant le type de guillemet opposé : '"42" est la réponse'. Doubler les guillemets n'a pas de signification particulière, et provoque une erreur puisque l'auto-concat requiert un espace.

Les opérateurs &&, ||, et et ou donnent la valeur qui a déterminé le résultat, de manière similaire à JavaScript et Lua. Par exemple, "" ou default donne default au lieu de 1. Les scripts qui nécessitent une valeur booléenne pure (0 ou 1) peuvent utiliser quelque chose comme ! !(x ou y) ou (x ou y) ? 1 : 0.

L'auto-concat requiert maintenant au moins un espace ou une tabulation dans tous les cas (la documentation de la v1 dit qu'il "devrait" y avoir un espace).
Le résultat d'une expression à plusieurs énoncés telle que x(), [C=AutoHotkey]y()[C=AutoHotkey] est la dernière sous-expression (la plus à droite) au lieu de la première sous-expression (la plus à gauche). Dans les versions v1 et v2, les sous-expressions sont évaluées dans l'ordre de gauche à droite.
Les égaux après une virgule ne sont plus des affectations : y=z dans x:=y, y=z est une comparaison inefficace au lieu d'une affectation.

:= += -= *= /= ++ -- ont un comportement cohérent, qu'ils soient utilisés seuls ou combinés avec d'autres opérateurs, comme avec x := y, y += 2. Auparavant, il y avait des différences de comportement lorsqu'une erreur se produisait dans l'expression ou qu'une valeur vide était utilisée dans une opération mathématique.

!= est maintenant toujours insensible à la casse, comme =, tandis que !== a été ajouté comme contrepartie de ==.
<> a été supprimé.
// lève maintenant une exception si on lui donne un nombre à virgule flottante. Auparavant, les résultats étaient incohérents entre les flottants négatifs et les entiers négatifs.
|, ^, &, << et >> lèvent maintenant une exception si on leur donne un nombre à virgule flottante, au lieu de les tronquer en entier. La notation scientifique peut être utilisée sans point décimal (mais produit tout de même un nombre à virgule flottante). La notation scientifique est également supportée lorsque les chaînes numériques sont converties en nombres entiers (par exemple, "1e3" est interprété comme 1000 au lieu de 1).

Les appels de fonction permettent maintenant pratiquement n'importe quelle sous-expression pour spécifier la fonction à appeler, à condition qu'il n'y ait pas d'espace ou de tabulation avant la parenthèse ouverte de la liste des paramètres. Par exemple, MyFunc() appelle la valeur MyFunc, qu'il s'agisse du nom réel de la fonction ou d'une variable contenant un objet fonction, et (a?b:c)() appelle soit b, soit c, en fonction de a. Notez que x.y() est toujours un appel de méthode équivalent à (x.y)(x), mais que a[i]() est maintenant équivalent à (a[i])().

Les double-derefs autorisent maintenant presque toutes les expressions (pas seulement les variables) comme source du nom de la variable. La syntaxe double déréférence est désormais également utilisée pour déréférencer les VarRefs, comme ref := &var, value := %ref%.

Les expressions funcName[""]() et funcName.() n'appellent plus une fonction par son nom. L'omission du nom de la méthode comme dans .() provoque désormais un message d'erreur au moment du chargement. Les fonctions doivent être appelées ou manipulées par référence, et non par nom.

[C=AutoHotkey]var :=[C=AutoHotkey] sans valeur rest traité comme une erreur au moment du chargement. Dans la v1, il était équivalent à var := "", mais échouait silencieusement s'il était combiné à une autre expression - par exemple : x :=, y :=.

Lorsqu'une chaîne littérale est suivie d'un opérateur unaire/binaire ambigu, une erreur est signalée au moment du chargement. Par exemple, new counter: ++counter est probablement censé incrémenter et afficher le compteur, mais techniquement, il s'agit d'une addition invalide et d'un plus unaire.

word++ et word-- ne sont plus des expressions, puisque wordpeut être une fonction définie par l'utilisateur (et ++/- peut être suivi d'une expression qui produit une référence à une variable). Pour écrire une expression autonome de post-incrémentation ou de post-décrémentation, il faut soit omettre l'espace entre la variable et l'opérateur, soit mettre la variable ou l'expression entre parenthèses.

word ? x : y est toujours une expression ternaire, mais les cas plus complexes commençant par un mot, comme word1 word2 ? x : y, sont toujours interprétés comme des appels de fonction à word1 (même si une telle fonction n'existe pas). Pour écrire une expression ternaire autonome avec une condition complexe, mettez la condition entre parenthèses.

Le nouvel opérateur is, tel que dans x is y, peut être utilisé pour vérifier si la valeur x est une instance de la classe y, où y doit être un Objet avec une propriété prototype (c'est-à-dire une Classe). Cela inclut les valeurs primitives, comme dans x is Integer (qui est strictement une vérification de type, alors que IsInteger(x) vérifie une conversion potentielle).

Les mots-clés contains et in sont réservés pour une utilisation future

[C=AutoHotkey]&var[C=AutoHotkey] (address-of) a été remplacé par StrPtr(var) et ObjPtr(obj) pour montrer plus clairement l'intention et améliorer la vérification des erreurs. Dans la v1, address-of retournait l'adresse du tampon interne de la chaîne de caractères de var, même s'il contenait un nombre (mais pas un objet). Il était également utilisé pour récupérer l'adresse d'un objet, et obtenir une adresse de mauvais type peut avoir des conséquences désastreuses.

&var est maintenant l'opérateur de référence, qui est utilisé avec tous les paramètres ByRef et OutputVar pour améliorer la clarté et la flexibilité (et permettre d'autres changements de langage).

Créer un script

Il y a quelques façons courantes de créer un fichier script :

Dans Notepad (ou un éditeur de texte de votre choix), enregistrez un fichier avec l'extension .ahk. Sur certains systèmes, vous devrez peut-être mettre le nom entre guillemets pour vous assurer que l'éditeur n'ajoute pas une autre extension (comme .txt) ;
Dans l'Explorateur, cliquez avec le bouton droit de la souris dans un espace vide du dossier où vous souhaitez enregistrer le script, puis sélectionnez Nouveau et Script AutoHotkey. Vous pouvez alors saisir un nom pour le script (en veillant à ne pas effacer l'extension .ahk si elle est visible) ;
Sélectionnez Nouveau script, tapez un nom pour le script (sans l'extension .ahk) et cliquez sur Créer ou Modifier. Le modèle utilisé pour créer le script et l'emplacement où il sera enregistré peuvent être configurés dans cette fenêtre, et définis par défaut si vous le souhaitez.

Modifier un script

Pour ouvrir un script afin de le modifier, cliquez avec le bouton droit de la souris sur le fichier du script et sélectionnez Modifier le script. Si le script est déjà en cours d'exécution, vous pouvez utiliser la fonction Modifier ou cliquer avec le bouton droit de la souris sur l'icône de la barre d'état système du script et sélectionner Modifier le script. Si vous n'avez pas encore choisi d'éditeur par défaut, vous devriez être invité à en sélectionner un.

Sinon, vous pouvez modifier votre éditeur par défaut via les paramètres de l'éditeur dans le tableau de bord. Bien entendu, vous pouvez toujours commencer par ouvrir un éditeur de texte, puis ouvrir le script comme n'importe quel autre fichier texte.

Après avoir modifié un script, vous devez l'exécuter ou le recharger pour que les modifications soient prises en compte. Un script en cours d'exécution peut généralement être rechargé via son menu de plateau.

Exécuter un script

Une fois AutoHotkey installé, il existe plusieurs façons d'exécuter un script :
Double-cliquez sur un fichier de script (ou un raccourci vers un fichier de script) dans l'Explorateur ;
Appelez AutoHotkey.exe sur la ligne de commande et passez le nom de fichier du script comme paramètre de ligne de commande ;
Après avoir créé le script par défaut, lancez AutoHotkey via le raccourci dans le menu Démarrer pour l'exécuter ;
Si AutoHotkey est épinglé à la barre des tâches ou au menu Démarrer de Windows 7 ou d'une version ultérieure, les scripts récents ou épinglés peuvent être lancés via la liste de raccourcis du programme.

La plupart des scripts n'ont d'effet que lorsqu'ils sont en cours d'exécution. Utilisez le menu de la barre d'état système ou la fonction ExitApp pour quitter un script. Les scripts sont également forcés de se terminer lorsque Windows s'éteint. Pour configurer un script afin qu'il démarre automatiquement après la connexion de l'utilisateur, le plus simple est de placer un raccourci vers le fichier du script dans le dossier Démarrage.

Les scripts peuvent également être compilés, c'est-à-dire combinés avec un fichier binaire AutoHotkey pour former un fichier exécutable (.exe) autonome.

Fonctions

Les fonctions ne peuvent plus être appelées dynamiquement avec plus de paramètres qu'elles n'en acceptent formellement.

Les fonctions variadiques ne sont pas affectées par la restriction ci-dessus, mais elles créent normalement un tableau à chaque fois qu'elles sont appelées pour contenir les paramètres excédentaires. Si ce tableau n'est pas nécessaire, le nom du paramètre peut maintenant être omis pour empêcher sa création :
Code:

1 2 3 AcceptsOneOrMoreArgs(first, *) { ... }
Ceci peut être utilisé pour les callbacks où les paramètres supplémentaires ne sont pas nécessaires.

Les appels de fonction variadique permettent maintenant d'utiliser n'importe quel objet énumérable, alors qu'auparavant ils nécessitaient un objet standard avec des clés numériques séquentielles. Si l'énumérateur renvoie plus d'une valeur par itération, seule la première valeur est utilisée. Par exemple, Array(mymap*) crée un tableau contenant les clés de mymap.

Les appels de fonctions variadiques avaient auparavant un support partiel pour les paramètres nommés. Cette fonction a été désactivée, afin de supprimer un obstacle possible à la mise en œuvre correcte des paramètres nommés.

Les fonctions définies par l'utilisateur peuvent utiliser le nouveau mot-clé unset comme valeur par défaut d'un paramètre pour rendre le paramètre unset lorsqu'aucune valeur n'a été fournie. La fonction peut alors utiliser IsSet() pour déterminer si une valeur a été fournie. unset n'est actuellement pas autorisé dans tout autre contexte.

Les scripts ne sont plus automatiquement inclus à partir des dossiers de la bibliothèque de fonctions (Lib) lorsqu'un appel de fonction est présent sans définition, en raison de la complexité accrue et du potentiel d'accidents (maintenant que le MyFunc dans MyFunc() peut être n'importe quelle variable). #Include <LibName> fonctionne comme avant. Il peut être remplacé par le support des modules dans une future version.

Les fonctions intégrées variadiques ont maintenant une valeur MaxParams égale à MinParams, plutôt qu'un nombre arbitraire (comme 255 ou 10000). Utilisez IsVariadic pour détecter quand il n'y a pas de limite supérieure.

Source : Autohotkey

Et vous ?

:fleche: Quel est votre avis sur le sujet ?

:fleche: Utilisez-vous des Scripts pour automatiser vos taches sur Windows ? Quelle est votre préférence ?

:fleche: Que pensez-vous d'AutoHotkey, langage de script gratuit et open source pour Microsoft Windows ?

Voir aussi :

:fleche: Windows 11 : un script d'Universal MediaCreationTool vous permet d'installer l'OS avec du matériel incompatible, comme des dispositifs sans TPM 2.0 ou Secure Boot

:fleche: Windows10Debloater : un script pour supprimer les bloatwares et les applications préinstallées sur Windows 10, ainsi que pour désactiver certaines fonctions de télémétrie du système d'exploitation

Citation:

Utilisez-vous des Scripts pour automatiser vos taches sur Windows ? Quelle est votre préférence ?

Autohotkey est le meilleur langage pour scripter des macro clavier sous windows que je connaisse. C'est simple, portable (interpréteur de 270ko en un fichier qui peut inclure le script), rapide. Pour les fonctions autres, j'ai toujours été rebuté par la syntaxe (je n'utilise que la version 1).

Autoit est un très bon langage sous windows pour scripter les interactions GUI (clic sur un contrôle, donner et verrouiller le focus sur une fenêtre, redimensionner une fenêtre...) et peut générer des .exe de petite taille comme son cousin Autohotkey , créer des GUI simples en WYSIWYG, donner un accès simple a pas mal d'API windows et la lib standard est assez complète et documentée avec une clarté inégalée en hors ligne. Le langage est un basic moderne lisible qui ne nécessite pas d'apprentissage. On peut importer sa librairie depuis python et sans doute n'importe quel langage.

Python : ça marche, mais j'ai rencontré des problèmes bizarres d'angles mal dégrossis (j'ai fait l'erreur d'utiliser os.system qui parfois échoue étrangement entre les versions 32 ou 64 bits, parfois avec des chemins longs mais ça marche en chemin court -GetShortPathName-, avant de comprendre sur stackoverflow que cette fonction est dépréciée pour subprocess, ce qui est vaguement suggéré dans la doc, mais en tous cas ne lève pas un warning de dépréciation et n'arrange pas la productivité...

Les tests via virustotal ne donnent pas envie de l'installer... :
https://www.virustotal.com/gui/file/...c7d1774d1438f8

Citation:

Les tests via virustotal ne donnent pas envie de l'installer... :
https://www.virustotal.com/gui/file/...c7d1774d1438f8

Détrompez-vous 7 sur 59 c'est un très bon score pour un exécutable, personnellement je n'ai jamais réussi à produire un exe avec une note inférieure à 4

Peut-être qu'avec un exe signé on pourrait descendre plus bas.

VBScript réinventé !

AutoHotKey réinvente le VBScript, en plus complexe, en reprenant (et en maltraitant au passage) des syntaxes intéressantes du Javascript. Je lui prédis un très grand avenir dans le musée des langages oubliés !

Citation:

Envoyé par alexvb6

AutoHotKey réinvente le VBScript, en plus complexe, en reprenant (et en maltraitant au passage) des syntaxes intéressantes du Javascript. Je lui prédis un très grand avenir dans le musée des langages oubliés !

Pour ma part, je partage cet avis sur la syntaxe du langage, mais ce qui est intéressant, ce sont les macro clavier.
(bon, je poste du code de la version 1)
ex :
Code:

1 2 3 ::/=:: SendInputU( "22600020" ) return
Permet de taper au clavier /= et d'avoir ≠

Citation:

::slm::seulement

Permet de taper au clavier slm et d'avoir seulement

Citation:

::cmdlea::
SendInput Le %A_DD%/%A_MM%/%A_YYYY% à %A_Hour%h%A_Min%
return

Permet d'insérer la date.

Les substitutions passent par un hook clavier global (ou un truc du genre), avec une syntaxe enfantine (quoiqu'affreuse) et fonctionnent sur tous les programmes, tous les windows et tous les PC grâce à la portabilité. La nature de script permet de le modifier rapidement.

ça me permet d'écrire au clavier dans un charabia de centaines d'abréviations et d'avoir une transposition en français normal.

Sous linux, il existe Autokey en python qui couvre une partie des fonctions d'Autohotkey. La syntaxe très simple d'autohotkey permet d'écrire assez facilement un script de conversion des macro clavier vers linux vers leur système unixien une fonction un fichier.

1 pièce(s) jointe(s)

AutoHotkey annonce la version officielle d'AutoHotkey v2, offrant de nombreuses améliorations

AutoHotkey annonce la version officielle d'AutoHotkey v2, offrant de nombreuses améliorations : il est recommandé aux utilisateurs de commencer à passer à la v2 pour les nouveaux scripts

AutoHotkey v2 est maintenant la version officielle principale, offrant de nombreuses améliorations par rapport aux versions précédentes. À l'avenir, la v2 sera activement développée et la v1 sera considérée comme dépréciée.

Il est recommandé aux utilisateurs de commencer à passer à la v2 pour les nouveaux scripts. Cependant, les scripts v1 continueront à fonctionner tant que la v1 est installée, même si la v2 est également installée. L'installation de la v2 comporte plusieurs composants et fonctionnalités utiles qui permettent aux deux versions de coexister et de fonctionner de manière transparente. Voir ces instructions pour installer la v2 à côté de la v1.

La communauté AHK sera là pour aider à la transition et répondre aux questions concernant toute version pour laquelle vous pourriez avoir besoin d'aide. Le résumé ci-dessous présente quelques points clés concernant la transition, y compris les changements apportés au forum. Toutes les autres questions que vous pourriez avoir concernant la v1 et la v2 sont très probablement couvertes dans cet article approfondi par Lexikos, le principal développeur de AHK. Ceux qui ont déjà adopté la v2 pensent que vous trouverez la nouvelle version comme une mise à niveau significative, et qu'elle aidera à consolider AHK comme le langage de script le plus puissant et le plus facile à utiliser disponible.

Pourquoi la transition vers la v2 est-elle nécessaire ?

Les mises à jour précédentes de AHK étaient contraintes d'être rétrocompatibles avec les versions précédentes, ce qui limitait les améliorations qui pouvaient être apportées. En supprimant cette contrainte, la v2 incorpore de nombreuses améliorations significatives par rapport à la v1, y compris l'élimination des bizarreries qui rendaient de nombreux aspects de la v1 confus pour beaucoup, en particulier les utilisateurs débutants. Cette rupture des liens avec la syntaxe et les structures de la v1 est ce qui permet à AHK de continuer à progresser en tant que langage de script moderne et facile à utiliser.

L'attention des développeurs, en particulier le développeur principal Lexikos, sera portée sur cette dernière version, car elle représente le présent et le futur du langage AHK. Il n'est pas possible de maintenir le développement de deux bases de code distinctes. De même, le forum se concentrera et s'organisera autour de la version principale tout en incluant des zones de support de la v1.

Avantages et caractéristiques clés de la v2

Élimination de la double syntaxe de la v1. La présence à la fois de la syntaxe héritée (commande) et des expressions dans la v1 cause beaucoup de frustration pour ceux qui apprennent le langage. AHK v2 est cohérent dans son utilisation des expressions, ce qui laisse une seule syntaxe à apprendre et élimine le besoin de se rappeler comment et quand utiliser chacune.

Une détection et un rapport d'erreurs plus complets. Il en résulte un dépannage plus facile et un code plus fiable.

Application Launcher. L'installation de la v2 comprend l'application Launcher qui permet de gérer à la fois la transition de la v1 à la v2 et l'utilisation continue des deux, si nécessaire. Le Launcher lancera la version appropriée de AHK basée sur sa tentative de détection automatique et vos paramètres.

Application Dash. L'application Dash est une nouvelle interface utilisateur graphique pour AHK qui peut être utilisée comme point de départ pour créer de nouveaux scripts, compiler des scripts, afficher les fichiers d'aide (v2 ou v1), exécuter l'outil Window Spy, configurer les paramètres de lancement et spécifier l'éditeur par défaut pour les fichiers de script AHK.

Changements sur le forum

Au cours de plusieurs semaines après cette annonce, le forum sera modifié pour refléter l'accent mis sur la v2 comme version principale.
Les sections principales du forum seront consacrées aux sujets liés à la v2. Des sous-forums spécifiquement désignés pour la v1 et les versions antérieures seront créés pour les sujets concernant ces versions. Les fils de discussion existants dans les anciens forums non v2 seront déplacés vers ces sous-forums.
La coloration syntaxique dans les boîtes de code AHK sera modifiée pour utiliser les règles syntaxiques de la version 2.

Pièce jointe 633378

Statut et avenir de la v1

La sortie officielle de la v2 ne signifie pas que la v1 est supprimée du site. Comme toujours, les anciennes versions peuvent être téléchargées et les zones du forum réservées à la v1 seront disponibles, notamment "Demander de l'aide" et "Scripts et fonctions".
Vos scripts v1 actuels continueront à fonctionner même si la v2 est installée, comme décrit ci-dessus concernant l'application Launcher.
Aucune nouvelle fonctionnalité ne sera implémentée dans la v1, bien que les modifications apportées au code via les "pull requests" puissent être évaluées et implémentées, mais avec une priorité moindre.
Toute personne souhaitant bifurquer une version de la v1 pour continuer son développement est la bienvenue, car toutes les versions de AHK continuent d'être open source.

Source : AutoHotkey

Et vous ?

:fleche: Qu'en pensez-vous ?

Voir aussi :

:fleche: La version 2 d'AutoHotkey, le langage de script gratuit et open source pour Windows, est disponible,, elle améliore la convivialité et la commodité du langage en sacrifiant la rétrocompatibilité

:fleche: GitHub annonce que 100 millions de développeurs utilisent désormais sa plateforme d'hébergement de code, la plateforme appartenant à Microsoft avait prévu atteindre ce palier à l'horizon 2025

:fleche: Pourquoi le langage de programmation Fortran serait une puissance scientifique ? une observation de Michael Wirth, enseignant à la School of Computer Science de l'Université de Guelph