Share
Gjennom hele denne artikkelen har vi snakket om tvangstypen, hvordan den er forskjellig fra typekonvertering, og hvordan den fungerer i dynamisk skrivede språk.
Hvis du bare går med i serien, kan du sjekke ut de tidligere artiklene for å være sikker på at du er i ferd med å fange med hvor vi er akkurat nå:
Mens den andre artikkelen fokuserte på svakt skrevet språk og datatyper på høyt nivå, skal vi se på noen konkrete eksempler på type tvang på et svakt skrevet språk og fallgruvene som vi kan oppleve uten å vite hvordan type tvang fungerer og hvordan det kan komme tilbake.
Spesielt skal vi se på flere eksempler ved hjelp av JavaScript, og selv om resultatene du kanskje ser gjennom bruk av eksemplene, ikke nødvendigvis oversetter 1: 1 på andre språk, vil det fortsatt gi et sett med tester som du kan utføre i hva du bruker i din daglige eller i din side prosjekter og evaluere resultatene du ser.
Det er uten tvil et av de vanligste problemene som oppstår i svakt skrevet språk, når vi lager sammenligninger. Visst, det er andre tider som forventer at en variabel er en type når det virkelig er en annen, kan negativt påvirke oss, men de vanligste problemene oppstår når vi utfører noen form for sammenligning.
Disse sammenligningene kan komme i form av likestillingsoperasjoner, betingede operasjoner, bitvis operasjoner eller under bryter / case operasjoner.
Som nevnt i tidligere artikler i denne serien, har forskjellige språk forskjellige måter de går på med tvingende datatyper, slik at eksemplene vi ser på i denne artikkelen, kan avvike litt i det arbeidet du gjør.
Det vil si at vi skal se på disse eksemplene ved å bruke JavaScript siden det er så mye brukt språk, men reglene er fortsatt gjeldende på andre språk - det er bare at andre språk kan sette en annen prioritet på en datatype over en annen så Resultatene av tvang kan være litt annerledes.
Så med det sagt, la oss komme i gang ved å se på hvordan JavaScript håndterer sammenligninger mellom datatyper ved hjelp av likestillingsoperatøren (==), den strenge likestillingsoperatøren (===), og når du bruker verdier som udefinert og null.
Før vi ser på sammenligninger mellom ulike datatyper, la oss ta et øyeblikk til å merke det, i JavaScript, udefinert og null er to forskjellige typer verdier. Som om det ikke er nok, kan det bli enda mer forvirrende når man sammenligner de to verdiene.
Merk først følgende:
Accentsconagua
typeof (undefined) i konsollen vil resultatet bli udefinert.typeof (null) i konsollen vil resultatet bli gjenstand.Deretter, hvis du skulle erklære en variabel uten å faktisk gi den en verdi, og du skulle vurdere sin type, så ville du se udefinert.
/ ** * Erklære et variabelt navn, men ikke tilordne det en verdi. * Utfør resultatet av 'typeof' på en konsoll, og du vil * bli gitt 'undefined'. * / var navn; typeof (navn);
La oss da si at vi velger å initialisere variabelen med en null verdi. Hvis du skulle evaluere variabelen ved hjelp av typeof du vil bli gitt en gjenstand resultat.
// Først vil vi deklarere variabelen var nummeret; / ** * På dette tidspunktet, hvis vi skulle evaluere variabelen * ved hjelp av typeof, ville vi bli gitt "undefined." * / // Nå tilordne variabelen en verdi av 'null' tall = null; / ** * Og vurder variabelen. På dette punktet vil vi * bli returnert verdien av 'objekt'. * / typeof (tall);
Forvirrende? Husk fra tidligere at det i JavaScript, null er en gjenstand hvor udefinert er sin egen type - udefinert.
Med det sagt, nå kan vi faktisk se på hvorfor sammenligninger kan bli vanskelige når vi utfører sammenligninger på verdier uten å eksplisitt kjenne deres type.
Gjennom hele denne delen skal vi se på resultatene av å sammenligne verdier som er av forskjellige typer, men se hvordan de vurderes mot hverandre ved å bruke både likestillingsjämförelser og strenge likestillingsjämförelser.
Vær oppmerksom på at alle eksemplene vi lister under, bør kunne utføres i en nettleserens konsoll, for eksempel Firebug eller Chrome's Developer Tools.
For det første begynner vi med udefinert og null.
// Returnerer sant undefined == null; null == undefined; // Returnerer false undefined === null; null === undefined;
Legg merke til at likestillingsoperatøren i det første tilfellet returnerer en verdi av sammenligningen etter utfører type tvang. Det er, tolken gjør sitt beste gjetning om hva vi mener når du utfører denne sammenligningen.
I andre tilfelle bruker vi den strenge likestillingsoperatøren. I dette tilfellet oppstår ingen type tvang. I stedet tar det verdiene nøyaktig slik de er og sammenligner dem.
Deretter kan vi ta en titt på å erklære en variabel, ikke tildele den en verdi, og deretter kjøre en sammenligning.
// Deklar variabelen, ikke tilordne det et verdi var eksempel; // Når sammenlignet med udefinert, returnerer sant i begge tilfeller eksempel == undefined; eksempel === undefined // Når sammenlignet med null, returnerer sant eller falskt eksempel == null; // ekte eksempel === null; // false // Tilordne en verdi til variabel eksempelet = null; // Gjør et strengt sammenligningseksempel === null; // Returnerer sant
Som du kan se, begynner ting å bli litt mer komplisert når vi begynner å erklære og sammenligne variabler med eller uten verdier.
Når vi begynner å introdusere strenger, tall og boolske verdier, kan det bli enda mer komplisert. Først, la oss starte med strenge og tall. Vi begynner med å erklære en variabel med en strengverdi på 42 og et nummer med 42 og så skal vi utføre våre sammenligninger.
var sNumber, iNumber; sNumber = '42'; iNumber = 42; // Likestillingsjämförelser gir ekte sNumber == iNumber; // Streng sammenligning gir falsk sNumber === iNumber;
Igjen, legg merke til i det første tilfellet, forsøker tolken å tvinge verdiene fra variablene og sammenligne dem deretter. I det første tilfellet fungerer det - vi sammenligner en strengverdi av 42 til en tallverdi på 42, men når vi bruker den strenge likestillings-sammenligningen og får falsk.
Det andre tilfellet er teknisk mer nøyaktig fordi den første verdien er en streng og den andre er et tall. Sammenligning av to verdier av forskjellige typer bør alltid gi falsk.
Selv om vi har tatt en titt på dette i en tidligere artikkel, hva med tallene og booleans?
var iNumber, bBoolean; iNumber = 0; bBoolean = false; // Returnerer ekte iNumber == bBoolean; // Returnerer falsk iNumber === bBoolean; // Returnerer ekte iNumber = 1; bBoolean = true; iNumber == bBoolean; // Returnerer falsk iNumber === bBoolean;
På dette tidspunktet bør du begynne å merke et mønster: Når du sammenligner verdier av forskjellige typer, kan JavaScript riktig tvinge verdier, men det gir det mest nøyaktige resultatet når du bruker strenge likestillingsoperatøren.
Til slutt, la oss se på et eksempel som kombinerer strenge, tall og booleaner.
var s Eksempel, i Eksempel, b Eksempel; sExample = '1'; i Eksempel = 1; bExample = true; // Returnerer ekte sExample == iExample; // Returnerer false sExample === iExample; // Returnerer ekte iExample == bExample; // Returnerer false iExample === bExample; // Returnerer ekte sExample == bExample; // Returnerer false sExample === bExample;
Merk at disse er grunnleggende sammenligninger; men når det er gjort i sammenheng med en hvis / annet eller hvis / annet hvis / annet du ser hvordan det kan forstyrre kontrollflyten gjennom betingelsene.
Legg merke til at når du utfører logiske operasjoner, for eksempel && og || så vel som bitwise operatører som & og | at tvangsregler fortsatt gjelder. Til det formål vil du være sikker på at når du utfører disse operasjonene, bruk verdier av nøyaktig samme type for å få de mest nøyaktige resultatene.
Ellers kan tvang resultere i en falsk positiv eller en falsk negativ.
Dette fullfører vår oversiktlige, nybegynneres titt på datatyper og skriver tvang i dynamisk skrevet språk. Til tross for at tommelfingerreglene alltid skal brukes til strenge likestillingsoperatører, og for å sikre at variablene du arbeider med er av samme type. Hvis du ikke er sikker, kan du alltid eksplisitt konvertere dem ved hjelp av strategier som vi skisserte tidligere i serien.
Gjennom hele denne serien har vi tatt en titt på hvordan typer varierer og oppfører seg fra sterkt skrevet språk til svakt skrevet språk. Vi har sett på hvordan avstøpning og tvang er forskjellig, og vi har sett noen av de potensielle fallgruvene som dette kan føre til å stole for mye på tolken eller kompilatoren når de utfører sammenligninger.
Til slutt tok vi en titt på noen strategier for hvordan du skriver mer defensiv kode ved å sørge for at vi har datatypen vi trenger, og hvordan du bruker strenge sammenligningsoperatører for å sikre at vi får de resultatene vi trenger.
Som nevnt tidligere har vi brukt JavaScript til hensikten med eksemplene våre i denne seriøse artikkelen, men andre svake skrevet språk er underlagt de samme fallgruvene. Hvordan de prioriterer deres tvang varierer, men strategiene som er skissert i denne serien, bør bidra til å skrive mer motstandsdyktig kode når de arbeider på svakt skrevet språk.
