Le tuple hanno un significato speciale nel campo dei computer, questo nome può sembrare un po' strano, e praticamente non esistono scenari applicabili nella scrittura di codice; tuttavia, sorprendentemente, le tuple sono strettamente legate alla programmazione; alcuni studenti potrebbero non sapere che un altro nome accademico per "record" nei database relazionali è "tuples", un record è una tuple, una tabella è una relazione, i record sono composti da tabelle, le tuple generano relazioni, questo è il concetto centrale dei database relazionali.
Le tuple sono una parte inseparabile di un database relazionale, ma non sono così indispensabili nella programmazione. Alcuni linguaggi di programmazione hanno la propria sintassi delle tuple, come python, F#, haskell, scala, ecc., mentre altri sono più popolari ma non hanno sintassi delle tuple, come Java, JavaScript, C++, C#, ecc.
Le tuple non sono elementi di programmazione indispensabili come array e oggetti, ma il loro utilizzo può essere molto comodo per scrivere codice, specialmente quando una funzione deve restituire più valori. In questo caso, la pratica comune è definire un oggetto, impostare il valore che la funzione deve restituire come attributo dell'oggetto, e poi impostare il tipo di valore di ritorno della funzione al tipo dell'oggetto. Oppure questa funzione può restituire una struttura dati mappata in cui esistono quei dati specifici. Tuttavia, entrambi gli approcci hanno i loro difetti, e il primo metodo è affidabile, ma il codice è insolitamente pesante. I requisiti stessi sono molto semplici, purché la funzione restituisca più valori, ma questo metodo richiede di definire un tipo in anticipo, poi istanziarlo, poi impostare le proprietà dell'istanza e infine restituire, il che è troppo inefficiente. Sebbene il secondo metodo sia veloce, ma non abbastanza sicuro, all'interno della funzione si può sapere che tipo di valore è memorizzato nella mappa, ma al di fuori della funzione, si sa solo che il valore di ritorno di questa funzione è una mappa, per quanto riguarda quali valori sono memorizzati nella mappa, quale tipo non è noto, nei progetti di sviluppo multi-persona Questo svantaggio è particolarmente evidente, purtroppo questa pratica è la soluzione preferita in alcuni linguaggi tipizzati dinamicamente, che è anche una delle ragioni fondamentali per cui i linguaggi tipizzati dinamicamente sono criticati per scarsa sicurezza e leggibilità. Pertanto, la soluzione migliore a questo tipo di problema è utilizzare le tuple.
Nei linguaggi in cui la sintassi stessa supporta le tuple, le tuple sono rappresentate da parentesi, come (int, bool, string) è un tipo triplo, e il suo valore può essere (1, true, "abc"). Va notato che ogni tipo di tupla è unico, (int, bool), (bool, int), (stringa, double) sono tutti binari, ma sono tuple diverse, se si prende una certa tupla qui come valore di ritorno della funzione, anche se non è buona come la prima soluzione usando tipi personalizzati menzionati prima in termini di leggibilità e sicurezza, è molto meglio della seconda soluzione usando map, almeno usando le tuple si può sapere quanti valori la funzione restituirà, Che tipo di valore sono questi valori, e ha il vantaggio di essere semplice e veloce codificare un secondo schema usando map.
Fortunatamente, questi linguaggi di programmazione ora supportano i generici, e l'implementazione di tuple non integrate è diventata estremamente semplice, ma dopotutto è un elemento sintattico integrato non nel linguaggio, e sicuramente non è così comodo da usare come le tuple native.
Di seguito si introduce una libreria di tuple Java di terze parti, chiamata Javatuples, con una propria homepage ufficiale e centinaia di stelle su Github, che quasi gioca una posizione monopolistica nel campo delle tuple Java.
Le Javatuple definiscono una tupla con una lunghezza massima di 10, ma penso che il numero di elementi in una 10-upla sia già troppo elevato, e praticamente non c'è leggibilità. Le classi di tuple sono definite come segue:
Unità<A> (1 elemento)
Coppia<A,B> (2 elementi)
Triplet<A, B, C> (3 elementi)
Quartetto<A,B,C,D> (4 elementi)
Quintetto<A,B,C,D,E> (5 elementi)
Sestetto<A,B,C,D,E,F> (6 elementi)
Settetto<A,B,C,D,E,F,G> (7 elementi)
Ottetto<A,B,C,D,E,F,G,H> (8 elementi)
Enneade<A,B,C,D,E,F,G,H,I> (9 elementi)
Decenni<A,B,C,D,E,F,G,H,I,J> (10 elementi)
Queste classi archetipiche sono classi generiche, quindi le lettere nei bracket angolari possono essere sostituite con tipi arbitrari. Di seguito è riportato un esempio di codice binario
Traendo inferenze, gli altri tipi di tuple vengono usati allo stesso modo.
Poiché le tuple di Java non sono supportate dal linguaggio stesso, il codice appare giavanese e meno elegante. Tuttavia, quando si scrive codice, oltre alla comodità di scrivere che può migliorare l'efficienza, è più importante prestare maggiore attenzione al significato espresso dal codice stesso, ovvero usare il significato (funzione) della tupla stessa per migliorare il codice, e come scriverla è in realtà solo secondario.
Infine, va notato che il tipo nei bracket angolari generici non può essere il tipo base di Java; se si vuole usare il tipo base, deve essere anche il tipo base che è stato riportato in una scatola, ad esempio il tipo int deve essere convertito in intero, e il tipo bool corrisponde al tipo booleano. |
Pubblicato su 31/08/2021 11:22:41
|
|
|
|
Padrone di casa|
Pubblicato su 15/09/2021 10:55:08
|
