Les tuples ont une signification particulière dans le domaine de l’informatique, ce nom peut sembler un peu inconnu, et il n’existe pratiquement pas de scénarios d’application dans l’écriture de code, cependant, étonnamment, les uplets sont étroitement liés à la programmation ; certains étudiants ne savent peut-être pas qu’un autre nom académique pour « records » dans les bases de données relationnelles est « uplets », un enregistrement est un tuple, une table est une relation, les enregistrements sont composés de tableaux, les uplets génèrent des relations, c’est le concept central des bases de données relationnelles.
Les tuples sont une partie indissociable d’une base de données relationnelle, mais ils ne sont pas si indispensables en programmation. Certains langages de programmation ont leur propre syntaxe de tupilles, comme Python, F#, Haskell, Scala, etc., tandis que d’autres sont plus populaires mais n’ont pas de syntaxe de tupilles, comme Java, JavaScript, C++, C#, etc.
Les tuples ne sont pas des éléments de programmation indispensables comme les tableaux et les objets, mais leur utilisation peut être très pratique pour écrire du code, surtout lorsqu’une fonction doit retourner plusieurs valeurs. Dans ce cas, la pratique courante consiste à définir un objet, à définir la valeur que la fonction doit retourner comme attribut de l’objet, puis à définir le type de valeur de retour de la fonction au type de l’objet. Ou bien cette fonction peut retourner une structure de données de carte dans laquelle les données spécifiques existent. Cependant, les deux approches ont leurs défauts, et la première méthode est fiable, mais le code est exceptionnellement chargé. Les exigences elles-mêmes sont très simples, tant que la fonction renvoie plusieurs valeurs, mais cette méthode nécessite de définir un type à l’avance, puis de l’instanciar, de définir les propriétés d’instance, et enfin de revenir, ce qui est trop inefficace. Bien que la seconde méthode soit rapide, mais pas suffisamment sécurisée, à l’intérieur de la fonction peut savoir quel type de valeur est stockée dans la carte, mais en dehors de la fonction, savoir seulement que la valeur de retour de cette fonction est une carte, c’est-à-dire quelles valeurs sont stockées dans la carte, quel type n’est pas connu dans les projets de développement multi-personnes. Ce désavantage est particulièrement évident, malheureusement cette pratique est la solution privilégiée dans certains langages typés dynamiquement, ce qui est aussi l’une des raisons fondamentales pour lesquelles les langages typés dynamiquement sont critiqués pour leur faible sécurité et lisibilité. Par conséquent, la meilleure solution à ce type de problème est d’utiliser des tuples.
Dans les langages où la syntaxe elle-même supporte les tuples, les uplets sont représentés par des parenthèses, telles que (int, bool, string) est un triple type, et sa valeur peut être (1, true, « abc »). Il convient de noter que chaque type de tuplet est unique, (int, bool), (bool, int), (chaîne, double) sont tous des binaires, mais ce sont des uplets différents, si l’on prend ici un certain uplet comme valeur de retour de la fonction, bien que ce ne soit pas aussi efficace que la première solution utilisant des types personnalisés mentionnés précédemment en termes de lisibilité et de sécurité, c’est bien mieux que la seconde solution utilisant map, au moins avec des tuples on peut savoir combien de valeurs la fonction va retourner, Quel type de valeur sont ces valeurs, et il a l’avantage d’être simple et rapide de coder un second schéma en utilisant map.
Heureusement, ces langages de programmation prennent désormais en charge les génériques, et l’implémentation de tuples non intégrés est devenue extrêmement simple, mais après tout, c’est un élément de syntaxe intégré hors langage, et il n’est certainement pas aussi pratique à utiliser que les tuples natifs.
Ce qui suit introduit une bibliothèque tierce de tuples Java, appelée Javatuples, avec sa propre page d’accueil officielle et des centaines d’étoiles sur github, qui joue presque une position de monopole dans le domaine des uplets Java.
Les javatuples définissent un uplet d’une longueur maximale de 10, mais je pense que le nombre d’éléments dans un uplet 10 est déjà trop élevé, et il n’y a pratiquement aucune lisibilité. Les classes de tuples sont définies comme suit :
Unité<A> (1 élément)
Paire<A, B> (2 éléments)
Triolet<A, B, C> (3 éléments)
Quatuor<A,B,C,D> (4 éléments)
Quintette<A,B,C,D,E> (5 éléments)
Sextuor<A,B,C,D,E,F> (6 éléments)
Septuor<A,B,C,D,E,F,G> (7 éléments)
Octuor<A,B,C,D,E,F,G,H> (8 éléments)
Ennéade<A,B,C,D,E,F,G,H,I> (9 éléments)
Década<A,B,C,D,E,F,G,H,I,J> (10 éléments)
Ces classes archétypales sont des classes génériques, de sorte que les lettres entre crochets peuvent être remplacées par des types arbitraires. Voici un exemple de code binaire
En tirant des inférences, les autres types de tuples sont utilisés de la même manière.
Comme les tuples de Java ne sont pas pris en charge par le langage lui-même, le code a un aspect javanais et moins élégant. Cependant, lorsqu’on écrit du code, en plus de la commodité d’écrire qui peut améliorer l’efficacité, il est plus important de prêter plus d’attention au sens exprimé par le code lui-même, qui consiste à utiliser le sens (fonction) du tuple lui-même pour enrichir le code, et la manière de l’écrire n’est en réalité que secondaire.
Enfin, il convient de noter que le type dans les crochets d’angle génériques ne peut pas être le type de base de Java ; si vous souhaitez utiliser le type de base, il doit aussi être le type de base qui a été encaissé, par exemple le type int doit être converti en entier, et le type bool correspond au type booléen. |
Publié sur 31/08/2021 11:22:41
|
|
|
|
Propriétaire|
Publié sur 15/09/2021 10:55:08
|
