Améliorer la compilation avec le typage direct dans 4D

Avec 4D 20 R7, vous pouvez dire adieu aux méthodes « Compiler_ » et profiter d’une plus grande liberté dans la manière et l’endroit où vous déclarez vos variables. Gagnez du temps en restant concentré sur votre flux de développement et votre processus de codage grâce au typage direct.

Dans les versions antérieures de 4D, les développeurs disposaient de deux options pour gérer le typage des variables lors de la compilation. Si le paramètre « Chemin de compilation » était défini sur une valeur autre que « Toutes les variables sont typées », le compilateur tentait de déduire le type des variables non typées en se basant sur leur utilisation dans le code. Bien que cela puisse simplifier les déclarations de variables, il y a un compromis à faire :

• une compilation plus lente: L’inférence du type nécessite un passage de compilation supplémentaire, ce qui ralentit le processus global de construction.
• Risque d’erreurs: Le compilateur peut déduire des types incorrects, ce qui risque d’introduire des bogues difficiles à déboguer.

Pour éviter ces problèmes, il a été conseillé aux développeurs d’appliquer un typage strict en utilisant l’option « Toutes les variables sont typées ». Cependant, cela nécessitait de déclarer toutes les variables de processus et inter-processus dans des méthodes « Compiler_ » dédiées.

Introduction du typage direct

Pour relever ces défis, nous avons introduit le typage direct , qui simplifie la manière dont les variables sont déclarées et typées lors de la compilation.

Avec le typage direct, il n’est plus nécessaire d’utiliser les méthodes « Compiler_ » pour déclarer les variables de processus ou interprocessus. Au lieu de cela, vous pouvez désormais les définir là où elles ont logiquement leur place dans votre code, que ce soit dans une méthode, une classe ou tout autre contexte approprié. Cela vous permet de mieux contrôler l’organisation de votre code et d’améliorer l’encapsulation.

Ce changement offre la souplesse nécessaire pour organiser votre code comme vous le souhaitez, tout en garantissant la sécurité des types et une compilation efficace.

Adopter le typage direct dans vos projets

Que vous travailliez sur un nouveau projet ou sur un projet existant, le typage direct peut être facilement intégré à votre flux de travail.

• Lesnouveaux projets utilisent toujours le typage direct. Cela signifie que vous pouvez commencer à profiter des avantages de la déclaration flexible des variables et d’une meilleure organisation du code dès maintenant.

• Pour les projets existants, vous trouverez un nouveau paramètre dans le chemin de compilation qui vous permet d’activer ou de désactiver le typage direct. Cela garantit la compatibilité avec le code existant et vous permet de migrer à votre rythme.

Il vous suffit d’activer ce paramètre pour être libre de déclarer vos variables de processus et inter-processus à l’endroit le plus logique de votre code.

Quelles sont les nouveautés du typage direct ?

La syntaxe #declare est désormais obligatoire pour déclarer les paramètres des méthodes en typage direct, ce qui rend les commandes traditionnelles du compilateur telles que C_TEXT, C_LONGINTet d’autres commandes obsolètes. L’un des principaux avantages est que, en particulier pour les composants, il n’est plus nécessaire de compiler les composants lors de la compilation d’une base hôte. Le compilateur récupère automatiquement les prototypes de méthode directement dans le code du composant, ce qui simplifie et accélère le processus de développement.

Pour vous aider à convertir les commandes du compilateur telles que C_TEXT et C_LONGINT en syntaxe de déclaration var, nous avons créé une macro 4D disponible sur GitHub. Vous pouvez y accéder ici : 4D-Macros sur GitHub.

Comment cela fonctionne-t-il ?

• Lorsque le compilateur rencontre une variable qui n’a pas été explicitement typée, il l’ajoute à une liste de variables « à typer ».
• Le compilateur met alors temporairement en pause la compilation de la méthode en cours et procède à la compilation des autres méthodes.
• Avant de faire une pause, il rassemble toutes les définitions de variables de la méthode.
• Après avoir compilé toutes les méthodes, le compilateur vérifie si toutes les variables de la liste « à typer » ont été trouvées et si un type leur a été attribué.
  • Si c’est le cas, il reprend la compilation des méthodes précédemment interrompues.
  • Si ce n’est pas le cas, des erreurs seront générées pour indiquer les variables non typées.

Conclusion

L’introduction du typage direct marque une amélioration significative de la manière dont les déclarations de variables sont gérées dans 4D. En éliminant le besoin de méthodes « Compiler_ » et en permettant aux déclarations de variables d’être effectuées librement dans le code, les développeurs 4D disposent désormais d’une plus grande flexibilité et d’un meilleur contrôle sur la manière dont ils structurent leurs projets.

Pour en savoir plus sur le typage direct et sur la manière de le mettre en œuvre dans vos projets, consultez notre documentation.