Share
I denne serien tar vi en nybegynneres titt på dynamisk skrevet (eller svakt skrevet) språk, og hvordan deres mangel på sterk skriving kan både positivt og negativt påvirke vår programmering.
Som nevnt i første innlegg, er denne serien spesielt rettet mot nybegynnere eller mot de som ikke har mye erfaring med svakt skrevet språk. Det vil si at hvis du har programmert både sterkt skrevet og / eller svakt skrevet språk og er kjent med type tvang og fallgruvene som kan oppstå når du utfører bestemte operasjoner, kan denne serien ikke være av stor interesse for deg.
På den annen side, hvis du er noen som nettopp har begynt å skrive kode eller du er noen som kommer inn i et dynamisk skrevet språk fra et annet språk, er denne serien rettet mot deg. Til slutt er målet å definere type tvang, vise hvordan det fungerer, og undersøke deretter fallgruvene av det.
Ifølge Wikipedia er tvang definert som følger:
I datavitenskap er type konvertering, typekasting og tvang forskjellige måter å, implisitt eller eksplisitt, endre en enhet av en datatype til en annen.
Eller kanskje på en enklere måte, kan du definere dette som hvordan du tar en datatype og konverterer den til en annen. Saken er, det er en fin linje mellom konvertering og tvang.
Som en generell tommelfingerregel har jeg en tendens til å tenke på tvang som hvordan en tolk eller kompilator jobber for å finne ut hvilken type sammenligning som gjøres, mens omdannelse er en eksplisitt endring i type som vi som programmerer skriver i vår kode.
La oss se nærmere på dette.
La oss for eksempel si at du har en streng som heter eksempel og dens verdi er '5'. I statisk typede språk kan du skrive cast denne grab verdien av strengen og konvertere den til en int gjennom en rekke forskjellige metoder.
Anta at vi har en Integer gjenstand med a parseInt metode. Metoden aksepterer en streng og returnerer verdien av strengen i heltalldatatypen. Koden for å gjøre det kan se slik ut:
strengeksempel = '5'; Integer myInt = nytt heltall (); int intExample = myInt.parseInt (eksempel); / * intExample har nå verdien av 5 (ikke '5') * og eksempel refererer fortsatt til strengen '5' * /
Selvfølgelig vil syntaksen variere fra språk til språk, og der er andre måter å gå på å gi en verdi, men dette gir deg en ide om hvordan du eksplisitt konverterer en type til en annen.
En annen måte å gå om å gjøre dette på er å bruke en type casting operatør. Selv om implementeringen av operasjonen varierer fra språk til språk, vil de fleste programmører som har jobbet med C-stil språk trolig anerkjenne det som noe som ligner på dette:
int myInt = (int) eksempel;
Vanligvis gjøres type avstøpning vanligvis ved å plassere typen som du vil konvertere variablen i parentes før selve variabelen. I eksemplet ovenfor, Myint vil nå inneholde 5, heller enn '5' og eksempel vil fortsatt holde '5'.
Som nevnt, er dette noe som vanligvis gjøres innenfor rammen av kompilerte språk
Dette stiller fortsatt spørsmålet om hvordan type tvang er forskjellig fra type konvertering. Selv tvang kan skjer innen kompilerte språk, er det mer sannsynlig at du vil se at det skjer innenfor tolkede språk eller på dynamisk skrevet språk.
Videre er det mer enn sannsynlig at du vil se type tvang skjer når det blir gjort en sammenligning mellom objekter av forskjellige typer, eller når en operasjon eller evaluering gjøres med variabler som har forskjellige typer.
Som et enkelt eksempel, la oss si at i JavaScript har vi to variabler - sName, iAge - hvor sName refererer til en persons navn og iAge refererer til en persons alder. Variablene bruker, for eksempel, ungarsk notasjon bare for å betegne at man lagrer en streng og man lagrer et heltall.
Merk at dette er ikke et argument for eller mot ungarsk notering - det er et emne for et annet innlegg. Det blir brukt her for å gjøre det klart hvilken type verdi hver variabel lagres, slik at det er lettere å følge koden.
Så vi går videre og definerer våre variabler og deres verdier:
var sName = 'John Doe'; var iAge = 32;
Nå kan vi se på noen få eksempler på hvordan type tvang virker i sammenheng med et tolket språk. To eksempler på hvordan type tvang fungerer, er som følger:
La oss ta en titt på et eksempel på hver:
/ ** * Sammenligning av et tall til en boolesk * vil resultere i den boolske verdien * av 'false'. * / var resultat = iAge == true; / ** * Sammenkallingsstrenger og tall vil * tvinge tallet til en streng. * * "John Doe er 32 år gammel." * / var bio = sName + 'er' + iAge + 'år gammel.';
Disse eksemplene er relativt enkle. Den første er fornuftig fordi det ikke er noen måte at et tall kan sammenlignes med en boolsk verdi.
I det andre eksempelet merker vi at vi tar en streng, sammenkaller den med et annet sett med strenge, og bruker også tallet i sammenkoblingsoperasjonen. I dette tilfellet blir tallet omgjort til en streng og deretter sammenkalt sammen med resten av ordene.
Dette er type tvang: Når du tar en variabel av en type og konverterer den verdien til en annen type når du utfører en operasjon eller evaluering.
Saken er, begge disse eksemplene er veldig enkle. La oss se på noen få flere for å demonstrere hvordan tvang fungerer, i hvert fall i JavaScript, når du utfører sammenkoblingsoperasjoner:
var en, to, resultat; // en og to refererer til strengverdier av '1' og '2' one = '1'; to = '2'; // Resultatet vil inneholde strengen '12'; resultat = en + to; // omdefinere to til lik tallet '2' to = 2; // concatenating en streng og et tall resulterer i en streng // resultat vil inneholde '12'; resultat = en + to; // omdefinere en som nummer ett = 1; // da concatenate (eller sum) de to verdiene // resultatet blir 3 resultat = ett + to;
Det er to viktige ting å merke seg:
Accentsconagua
+ operatøren er overbelastet. Det betyr at når det arbeider med strenger, slår det sammen dem, men når det fungerer med tall tilføyer de dem sammen.For å ta eksemplet ett skritt videre, la oss legge til en ny variabel, et prioritert sett med operasjoner, og undersøk deretter resultatet:
var ett, to, tre, resultat; en = '1'; to = 2; tre = 3; // resultat er '123' resultat = en + to + tre; // resultat er '15' resultat = en + (to + tre);
Legg merke til i det andre eksemplet, to og tre er la til sammen fordi de begge er tall og da er resultatet sammensatt med en fordi det er en streng.
Tidligere nevnte vi at det er ett spesielt tilfelle for tall og boolske verdier, i hvert fall i JavaScript. Og siden det er språket vi har brukt til å undersøke type tvang, og siden det er et språk som ofte brukes i moderne webutvikling, la oss ta en titt.
Når det gjelder JavaScript, merk det 1 anses å være en "sannferdig" verdi og 0 er opptatt av å være en "falsey" verdi. Disse ordene er valgt som sådan fordi verdiene kan tjene som tall, men vil også bli vurdert til ekte eller falsk når du utfører en sammenligning.
La oss ta en titt på noen grunnleggende eksempler:
var bTrue, bFalse, iZero, iOne, resultat; bTrue = true; bFalse = false; iZero = 0; iOne = 1; // resultatet holder boolsk verdien av falskt resultat = bTrue == iZero; // resultatet holder boolsk verdien av ekte resultat = bTrue == iOne; // Resultatet inneholder den boolske verdien av falskt resultat = bFalse == iOne; // Resultatet inneholder den boolske verdien av ekte resultat = bFalse == iZero;
Merk at i tallene ovenfor er tallverdiene tvunget inn i heltallverdier av naturen av sammenligningen som blir gjort.
Men hva skjer hvis vi skal sammenligne en boolsk verdi av ekte eller falsk til en strengverdi på en eller null?
var bTrue, bFalse, sTrue, sFalse, resultat; bTrue = true; bFalse = false; sTrue = '1'; sFalse = '0'; // Resultatet holder sant resultat = bTrue == sTrue; // Resultat holder feil resultat = bTrue == sFalse; // Resultat holder false; resultat = bFalse == sTrue; // resultat holder sant resultat = bFalse == sFalse;
På dette tidspunktet kan ting begynne å bli veldig forvirrende fordi vi sammenligner en strengverdi av et nummer som er 1 til en boolsk verdi av ekte og vi får et booleskt resultat, og den boolske er ekte.
Gir mening? Vi vil ta en titt på dette i litt mer detalj i neste artikkel, men jeg ønsket å gå videre og introdusere grunnleggende om det først.
Dette er når dynamisk skrevet språk kan begynne å forårsake hodepine for utviklere. Heldigvis finnes det måter vi kan skrive kode på som er strengere enn hva vi har ovenfor, og som gir nøyaktige resultater.
I tillegg inneholder noen dynamisk typede språk også verdier for udefinert og for null. Disse opprettholder også "truthy" og "falsey" verdier som i sin tur påvirker hvordan vi håndterer sammenligninger.
I den endelige artikkelen i serien skal vi se på hvordan verdier som udefinert og null sammenligne med andre verdier så vel som med hverandre, og ta en titt på noen strategier som vi kan implementere som vil gjøre koden mer motstandsdyktig mot feil type tvang, og det gjør det mer lesbart.
Hvis dette er din første forgang til dynamisk skrevne språk eller skriv inn tvang, og du har spørsmål, kommentarer eller tilbakemelding, vennligst ikke nøl med å legge igjen en kommentar i feedet under!
