Share
In deze serie nemen we de blik van een beginner op dynamisch getypte (of zwak getypte) talen en hoe hun gebrek aan sterk typen zowel een positieve als een negatieve invloed kan hebben op onze programmering.
Zoals vermeld in het eerste bericht, is deze serie specifiek gericht op beginners of op mensen die niet veel ervaring hebben met zwak getypte talen. Dat wil zeggen dat als u in zowel sterk getypte als / of zwak getypte talen hebt geprogrammeerd en bekend bent met type dwang en de valkuilen die kunnen optreden bij het uitvoeren van bepaalde bewerkingen, deze serie mogelijk niet zo interessant voor u is.
Aan de andere kant, als u iemand bent die net begonnen is met het schrijven van code of als u iemand bent die in een dynamisch getypte taal komt uit een andere taal, dan is deze serie specifiek op u gericht. Uiteindelijk is het doel om type dwang te definiëren, te laten zien hoe het werkt en vervolgens de valkuilen ervan te onderzoeken.
Volgens Wikipedia wordt dwang als volgt gedefinieerd:
In de informatica zijn typeconversie, typecasting en dwang verschillende manieren om, impliciet of expliciet, een entiteit van het ene gegevenstype in een andere te veranderen.
Of, misschien op een eenvoudigere manier, kunt u dit definiëren als hoe u een gegevenstype opneemt en naar een ander datatype converteert. Het punt is, er is een dunne grens tussen bekering en dwang.
Als algemene vuistregel heb ik de neiging om te denken dwang hoe een tolk of compiler werkt om te bepalen wat voor soort vergelijking wordt gemaakt, terwijl conversie is een expliciete verandering in type dat wij, als programmeur, in onze code schrijven.
Laten we dit in meer detail bekijken.
Laten we bijvoorbeeld zeggen dat je een string met de naam hebt voorbeeld en de waarde is '5'. In statisch getypte talen, typ je deze waarde de waarde van de string en converteert deze naar een int via een aantal verschillende methoden.
Stel dat we een hebben Geheel getal object met een parseInt methode. De methode accepteert een tekenreeks en retourneert de waarde van de tekenreeks in het gegevenstype geheel getal. De code om dit te doen kan er ongeveer zo uitzien:
string example = '5'; Integer myInt = new Integer (); int intExample = myInt.parseInt (voorbeeld); / * intExample heeft nu de waarde van 5 (niet '5') * en voorbeeld verwijst nog steeds naar de tekenreeks '5' * /
Natuurlijk zal de syntaxis variëren van taal tot taal en daar zijn andere manieren om een waarde te gieten, maar dit geeft je een idee hoe je het ene type expliciet in het andere kunt omzetten.
Een andere manier om dit te doen is om een operator voor het typen van objecten te gebruiken. Hoewel de uitvoering van de bewerking varieert van taal-tot-taal, zullen de meeste programmeurs die in C-stijl talen hebben gewerkt dit waarschijnlijk als iets soortgelijks herkennen:
int myInt = (int) voorbeeld;
Over het algemeen wordt typen gieten meestal gedaan door het type waarop u de variabele tussen haakjes wilt zetten vóór de variabele zelf te plaatsen. In het bovenstaande voorbeeld, myInt zal nu bevatten 5, liever dan '5' en voorbeeld zal nog steeds vasthouden '5'.
Zoals gezegd, dit is iets dat normaal gesproken wordt gedaan in de context van gecompileerde talen
Dit laat nog de vraag achter hoe type dwang verschilt van typeconversie. Hoewel dwang kan gebeurt binnen gecompileerde talen, het is waarschijnlijker dat u het zult zien gebeuren in geïnterpreteerde talen of in dynamisch getypte talen.
Verder zie je waarschijnlijk dat typedwang optreedt wanneer een vergelijking wordt gemaakt tussen objecten van verschillende typen, of wanneer een bewerking of evaluatie wordt uitgevoerd met variabelen die verschillende typen hebben.
Laten we als voorbeeld stellen dat we in JavaScript twee variabelen hebben - sName, iage - waar sName verwijst naar de naam van een persoon en iage verwijst naar de leeftijd van een persoon. De variabelen gebruiken voor het voorbeeld bijvoorbeeld de Hongaarse notatie om aan te geven dat de ene een string opslaat en de andere een geheel getal opslaat.
Merk op dat dit zo is niet een argument voor of tegen de Hongaarse notatie - dat is een onderwerp voor een andere post. Het wordt hier gebruikt om duidelijk te maken welk type waarde elke variabele wordt opgeslagen, zodat het eenvoudiger is om de code te volgen.
Dus we gaan door en definiëren onze variabelen en hun waarden:
var sName = 'John Doe'; var iAge = 32;
Nu kunnen we een paar voorbeelden bekijken van hoe type dwang werkt in de context van een geïnterpreteerde taal. Twee voorbeelden van hoe type dwang werkt is als volgt:
Laten we een voorbeeld van elk bekijken:
/ ** * Vergelijking van een getal met een boolean * resulteert in de booleaanse waarde * van 'false'. * / var result = iAge == true; / ** * Concatenatiesnaren en -getallen * zullen het aantal naar een string dwingen. * * "John Doe is 32 jaar oud." * / var bio = sName + 'is' + iAge + 'jaar oud.';
Deze voorbeelden zijn relatief eenvoudig. De eerste is logisch omdat er geen manier is om een getal te vergelijken met een booleaanse waarde.
In het tweede voorbeeld, merk op dat we een string nemen, het samenvoegen met een andere reeks tekenreeksen, en ook het nummer gebruiken in de aaneenschakelingsbewerking. In dit geval wordt het nummer geconverteerd naar een tekenreeks en vervolgens samengevoegd met de rest van de woorden.
Dit is type dwang: wanneer u een variabele van één type neemt en de waarde ervan naar een ander type converteert wanneer u een bewerking of evaluatie uitvoert.
Het ding is, beide voorbeelden zijn erg simplistisch. Laten we nog een paar bekijken om aan te tonen hoe dwang werkt, tenminste in JavaScript, bij het uitvoeren van aaneenschakelingsbewerkingen:
var one, two, result; // één en twee verwijzen naar stringwaarden van '1' en '2' one = '1'; twee = '2'; // resultaat zal de string '12' bevatten; resultaat = één + twee; // herdefinieer twee om het aantal '2' twee = 2 te evenaren; // aaneenschakelen van een string en een getal resulteert in een string // resultaat zal '12' bevatten; resultaat = één + twee; // herdefinieer een als een nummer één = 1; // vervolgens de twee waarden samenvoegen (of optellen) // resultaat is 3 resultaat = een + twee;
Er zijn twee belangrijke dingen om op te merken:
Accentsconagua
+ operator is overbelast. Dat betekent dat wanneer het met snaren werkt, het ze samenvoegt, maar wanneer het met getallen werkt, voegt het ze samen toe.Om nog een stap verder te gaan, laten we nog een variabele, een geprioriteerde reeks bewerkingen toevoegen en vervolgens het resultaat bekijken:
var een, twee, boom, resultaat; een = '1'; twee = 2; drie = 3; // resultaat is '123' resultaat = één + twee + drie; // resultaat is '15' resultaat = één + (twee + drie);
Let op in het tweede voorbeeld, twee en drie zijn toegevoegd samen omdat ze beide getallen zijn en dan is het resultaat aaneengeschakelde met een omdat het een string is.
Eerder vermeldden we dat er een speciaal geval is voor getallen en booleaanse waarden, althans in JavaScript. En aangezien dat de taal is die we hebben gebruikt om typedwang te onderzoeken en omdat dat een taal is die vaak wordt gebruikt in moderne webontwikkeling, laten we eens kijken.
Houd in het geval van JavaScript rekening met dit 1 wordt beschouwd als een "waarheidsgetrouwe" waarde en 0 is bezorgd om een "valsey" -waarde. Deze woorden zijn als zodanig gekozen omdat de waarden als getallen kunnen dienen, maar ook worden geëvalueerd waar of vals bij het uitvoeren van een vergelijking.
Laten we een paar basisvoorbeelden bekijken:
var bTrue, bFalse, iZero, iOne, resultaat; bTrue = true; bFalse = false; iZero = 0; iOne = 1; // result bevat de booleaanse waarde van false result = bTrue == iZero; // result houdt de booleaanse waarde van true result = bTrue == iOne; // result houdt de booleaanse waarde van false result = bFalse == iOne; // result houdt de booleaanse waarde van true result = bFalse == iZero;
Merk op dat in de bovenstaande voorbeelden de getalswaarden zijn gedwongen in gehele getallen naar aard van de vergelijking die wordt gemaakt.
Maar wat gebeurt er als we een Booleaanse waarde van moeten vergelijken waar of vals naar een tekenreekswaarde van een of nul?
var bTrue, bFalse, sTrue, sFalse, result; bTrue = true; bFalse = false; sTrue = '1'; sFalse = '0'; // resultaat houdt waar resultaat = bTrue == sTrue; // resultaat houdt fout resultaat = bTrue == sFalse; // resultaat is onwaar; result = bFalse == sTrue; // resultaat houdt waar resultaat = bFalse == sFalse;
Op dit punt kunnen dingen echt verwarrend beginnen te worden, omdat we een tekenreekswaarde van een getal dat is, vergelijken 1 naar een Booleaanse waarde van waar en we krijgen een booleaans resultaat en de boolean is dat waar.
Heb je zin? We zullen dit in het volgende artikel in meer detail bekijken, maar ik wilde doorgaan en eerst de basisbeginselen ervan introduceren.
Dit is het moment waarop dynamisch getypte talen kopzorgen voor ontwikkelaars kunnen worden. Gelukkig zijn er manieren waarop we code kunnen schrijven die strenger is dan wat we hierboven hebben en die nauwkeurige resultaten oplevert.
Bovendien bevatten sommige dynamisch getypte talen ook waarden voor onbepaald en voor nul. Deze houden ook de 'waarheids-' en 'valsey'-waarden bij die van invloed zijn op hoe we omgaan met vergelijkingen.
In het laatste artikel van de serie gaan we kijken hoe waarden zoals onbepaald en nul vergelijken met andere waarden en met elkaar, en een kijkje nemen op enkele strategieën die we kunnen implementeren die onze code veerkrachtig zullen maken tegen dwang van incorrect type, en dat maakt het leesbaarder.
Als dit je eerste poging is om dynamisch getypeerde talen te typen of dwang in te voeren en je hebt vragen, opmerkingen of feedback, aarzel dan niet om een reactie achter te laten in de onderstaande feed!
