Tuples hebben een speciale betekenis binnen het computerveld; deze naam klinkt misschien wat onbekend, en er zijn eigenlijk geen toepassingsscenario's bij het schrijven van code. Toch zijn tuples verrassend genoeg nauw verwant aan programmeren; sommige studenten weten misschien niet dat een andere academische naam voor "records" in relationele databases "tuples" is, een record een tuple is, een tabel een relatie is, records bestaan uit tabellen, tuples genereren relaties, dit is het kernconcept van relationele databases.
Tuples zijn een onlosmakelijk onderdeel van een relationele database, maar ze zijn minder onmisbaar in programmeren. Sommige programmeertalen hebben hun eigen tuple-syntaxis, zoals Python, F#, haskell, scala, enzovoort, terwijl andere populairder zijn maar geen tuple-syntaxis hebben, zoals Java, JavaScript, C++, C#, enzovoort.
Tuples zijn geen onmisbare programmeerelementen zoals arrays en objecten, maar hun gebruik kan erg handig zijn voor het schrijven van code, vooral wanneer een functie meerdere waarden moet teruggeven. In dit geval is de gebruikelijke praktijk om een object te definiëren, de waarde die de functie moet teruggeven als het attribuut van het object in te stellen, en vervolgens het returnwaardetype van de functie te zetten op het type van het object. Of je kunt deze functie een map-datastructuur laten teruggeven waarin de specifieke data aanwezig is. Beide benaderingen hebben echter hun zwaktes, en de eerste methode is betrouwbaar, maar de code is ongewoon opgeblazen. De eisen zelf zijn heel eenvoudig, zolang de functie meerdere waarden teruggeeft, maar deze methode vereist dat een type vooraf wordt gedefinieerd, vervolgens wordt geïnstantieerd, vervolgens de instantie-eigenschappen wordt ingesteld en uiteindelijk teruggegeven, wat te inefficiënt is. Hoewel de tweede methode snel is, maar niet veilig genoeg, kan binnen de functie weten welk soort waarde er in de map is opgeslagen, maar buiten de functie kun je alleen weten dat de returnwaarde van deze functie een map is, want welke waarden in de map zijn opgeslagen, welk type is niet bekend, in meerpersoonsontwikkelingsprojecten. Dit nadeel is vooral duidelijk, helaas is deze praktijk de voorkeursoplossing in sommige dynamisch getypeerde talen, wat ook een van de fundamentele redenen is waarom dynamisch getypeerde talen worden geklaagd vanwege slechte beveiliging en leesbaarheid. Daarom is de beste oplossing voor dit type probleem het gebruik van tuples.
In talen waar de syntaxis zelf tuples ondersteunt, worden tuples weergegeven door haakjes, zoals (int, bool, string) is een drievoudig type, en de waarde kan zijn (1, waar, "abc"). Het moet worden opgemerkt dat elk tuple-type uniek is, (int, bool), (bool, int), (string, double) allemaal binaire zijn, maar het zijn verschillende tuples, als je hier een bepaalde tuple als retourwaarde van de functie neemt, hoewel deze niet zo goed is als de eerste oplossing met eerder genoemde custom types qua leesbaarheid en beveiliging, maar het is veel beter dan de tweede oplossing met map, tenminste met tuples kan je weten hoeveel waarden de functie zal teruggeven, Wat voor soort waarde zijn deze waarden, en het voordeel is eenvoudig en snel om een tweede schema met map te coderen.
Gelukkig ondersteunen deze programmeertalen nu generieke talen, en is de implementatie van niet-ingebouwde tuples extreem eenvoudig geworden, maar het is tenslotte een niet-taal ingebouwd syntaxiselement, en het is zeker niet zo handig in gebruik als native tuples.
Het volgende introduceert een externe Java-tuplesbibliotheek, genaamd Javatuples, met een eigen officiële homepage en honderden github-sterren, die bijna een monopoliepositie inneemt op het gebied van Java-tuples.
Javatuples definiëren een tuple met een maximale lengte van 10, maar ik denk dat het aantal elementen in een 10-tuple al te groot is, en er is eigenlijk geen leesbaarheid. Tuple-klassen worden als volgt gedefinieerd:
Eenheid<A> (1 element)
Paar<A,B> (2 elementen)
Triool<A,B,C> (3 elementen)
Kwartet<A,B,C,D> (4 elementen)
Kwintet<A,B,C,D,E> (5 elementen)
Sextet<A,B,C,D,E,F> (6 elementen)
Septet<A,B,C,D,E,F,G> (7 elementen)
Octet<A,B,C,D,E,F,G,H> (8 elementen)
Ennead<A,B,C,D,E,F,G,H,I> (9 elementen)
Decade<A,B,C,D,E,F,G,H,I,J> (10 elementen)
Deze archetypische klassen zijn generieke klassen, dus de letters tussen haakjes kunnen worden vervangen door willekeurige types. Hieronder volgt een voorbeeld van een binaire code
Door inferenties te trekken, worden de overige tuple-types op dezelfde manier gebruikt.
Omdat de tupels van Java niet door de taal zelf worden ondersteund, ziet de code er Javaans en minder elegant uit. Maar bij het schrijven van code kan schrijven, naast het gemak van schrijven, de efficiëntie verbeteren, het belangrijker zijn om meer aandacht te besteden aan de betekenis die door de code zelf wordt uitgedrukt, namelijk het gebruik van de betekenis (functie) van de tuple zelf om de code te verbeteren, en hoe je deze schrijft is eigenlijk slechts secundair.
Tot slot moet worden opgemerkt dat het type in de generieke hoekhaakjes niet het basistype van Java kan zijn; als je het basistype wilt gebruiken, moet het ook het basistype zijn dat is ingebokst, bijvoorbeeld dat het int-type moet worden omgezet naar een geheel getal, en het bool-type overeenkomt met het Booleaanse type. |
Geplaatst op 31-08-2021 11:22:41
|
|
|
|
Huisbaas|
Geplaatst op 15-09-2021 10:55:08
|
