Tupler har en särskild betydelse inom datorområdet, detta namn kan låta lite främmande, och det finns i princip inga tillämpningsscenarier för att skriva kod, men överraskande nog är tupler nära relaterade till programmering, vissa studenter kanske inte vet att ett annat akademiskt namn för "poster" i relationsdatabaser är "tuples", en post är en tuple, en tabell är en relation, poster består av tabeller, tupeler genererar relationer, detta är kärnkonceptet för relationsdatabaser.
Tupler är en oskiljaktig del av en relationsdatabas, men de är inte lika oumbärliga i programmering. Vissa programmeringsspråk har sin egen tuplesyntax, såsom python, F#, haskell, scala, etc., medan andra är mer populära men saknar tuplesyntax, såsom Java, JavaScript, C++, C#, etc.
Tupler är inte oumbärliga programmeringselement som arrayer och objekt, men deras användning kan vara mycket praktisk för att skriva kod, särskilt när en funktion behöver returnera flera värden. I detta fall är den vanliga praxisen att definiera ett objekt, sätta det värde som funktionen behöver returnera som objektets attribut, och sedan sätta returvärdestypen för funktionen till objektets typ. Eller så kan du låta denna funktion returnera en kartdatastruktur där den specifika datan finns. Båda metoderna har dock sina brister, och den första metoden är pålitlig, men koden är ovanligt uppblåst. Kraven i sig är mycket enkla, så länge funktionen returnerar flera värden, men denna metod kräver att man definierar en typ i förväg, sedan instansierar den, sätter instansegenskaperna och slutligen returnerar, vilket är för ineffektivt. Även om den andra metoden är snabb men inte tillräckligt säker, kan funktionen veta vilken typ av värde som lagras i kartan, men utanför funktionen vet man bara att returvärdet för denna funktion är en karta, alltså vilka värden som lagras i kartan, vilken typ som inte är känd, i flerpersonersutvecklingsprojekt. Denna nackdel är särskilt uppenbar, tyvärr är denna praxis den föredragna lösningen i vissa dynamiskt typade språk, vilket också är en av de grundläggande anledningarna till att dynamiskt typade språk klagas på för dålig säkerhet och läsbarhet. Därför är den bästa lösningen på denna typ av problem att använda tupler.
I språk där syntaxen själv stödjer tupler representeras tupler med parenteser, såsom (int, bool, string) är en trippeltyp, och dess värde kan vara (1, true, "abc"). Det bör noteras att varje tupletyp är unik, (int, bool), (bool, int), (sträng, dubbel) är alla binärer, men de är olika tupler, om man tar en viss tuple här som returvärdet för funktionen, även om den inte är lika bra som den första lösningen med anpassade typer som nämndes tidigare när det gäller läsbarhet och säkerhet, men den är mycket bättre än den andra lösningen med map, åtminstone med hjälp av tupler kan man veta hur många värden funktionen kommer att returnera, Vilken typ av värde är dessa värden, och det har fördelen att det är enkelt och snabbt att koda ett andra schema med map.
Lyckligtvis stöder dessa programmeringsspråk nu generika, och implementeringen av icke-inbyggda tupler har blivit extremt enkel, men det är trots allt ett icke-språkligt inbyggt syntaxelement, och det är definitivt inte lika bekvämt att använda som native tupler.
Följande introducerar ett tredjepartsbibliotek för Java-tuples, kallat Javatuples, med egen officiell hemsida och hundratals github-stjärnor, som nästan har monopol inom Java-tupl.
Javatupler definierar en tuple med en maximal längd på 10, men jag tycker att antalet element i en 10-tuple redan är för mycket, och det finns i princip ingen läsbarhet. Tupleklasser definieras enligt följande:
Enhet<A> (1 element)
Par<A,B> (2 element)
Triol<A,B,C> (3 element)
Kvartett<A,B,C,D> (4 element)
Kvintett <A,B,C,D,E> (5 element)
Sextett<A,B,C,D,E,F> (6 element)
Septett<A,B,C,D,E,F,G> (7 element)
Oktett<A,B,C,D,E,F,G,H> (8 element)
Ennead<A,B,C,D,E,F,G,H,I> (9 element)
Decade<A,B,C,D,E,F,G,H,I,J> (10 element)
Dessa arketypiska klasser är generiska klasser, så bokstäverna inom hakparenteser kan ersättas med godtyckliga typer. Nedan följer ett exempel på en binär kod
Genom att dra slutsatser används resten av tupletyperna på samma sätt.
Eftersom Javas tupler inte stöds av själva språket ser koden javanesisk och mindre elegant ut. Men när man skriver kod, förutom att skrivas bekvämt, kan förbättra effektiviteten, är det viktigare att lägga större vikt vid den betydelse som uttrycks av koden själv, vilket är att använda tuplens betydelse (funktion) för att förbättra koden, och hur man skriver den är faktiskt bara sekundärt.
Slutligen bör det noteras att typen i de generiska vinkelparenteserna inte kan vara grundtypen för Java, om du vill använda grundtypen måste den också vara den grundtyp som har boxats, till exempel måste int-typen konverteras till heltal och bool-typen motsvarar den booleska typen. |
Publicerad på 2021-08-31 11:22:41
|
|
|
|
Hyresvärd|
Publicerad på 2021-09-15 10:55:08
|
