Share
För alla som har programmerat under en lång tid har du än så länge använt ett antal olika programmeringsspråk. Med tanke på programvarolandet idag är det också troligt att du har arbetat med både starkt skrivna språk och svagt typade språk.
Det vill säga att du har arbetat med programmeringsspråk som kräver att du anger datatypen för dina variabler, vilka funktioner du kommer att returnera osv. Och du har arbetat med programmeringsspråk som kräver inte att du uttryckligen anger den informationen.
Om du vet exakt vad jag pratar om, är det här serierna förmodligen inte för dig. Men om du bara går in i programmeringen eller börjar använda ett nytt språk som är typiskt skrivet (eller svagt skrivet), så finns det ett antal saker som är värda att notera när det gäller att arbeta med datatyper.
I den här serien kommer vi att ta en nybörjars titt på dynamiska språk, hur variabler definieras, hur deras datatyper härledas och skiljer sig från deras statiska motsvarigheter och hur man undviker några av de stora fallgroparna som kommer att fungera med dessa språk.
Innan vi faktiskt ser på fallgropar av typen tvång och vi är mest sannolika att uppleva sina fallgropar, är det viktigt att förstå vilka datatyper som är och hur de varierar från starkt skrivna språk och dynamiskt typade språk.
Generellt sett är det troligt att du hittar starkt skrivna språk i familjen av programmeringsspråk som sammanställs. Det inkluderar språk som C och C++.
Men där är undantag.
Det finns några språk som sammanställs till någon form av bytecode eller någon typ av mellanliggande språk och bearbetas sedan av en tolk. Java är ett sådant språk. Dessa språk är starkt skrivna. De sammanställs också. Men de kompenseras inte nödvändigtvis till binära körbara men bytecode som tolkas av en tredjeparts programvara.
Jag vet att det låter lite förvirrande, så kanske en del kod hjälper till att klargöra detta. På starkt skrivna språk deklarerar du alltid vilken typ av data en variabel ska representera.
Till exempel:
strängsexempel = "Den snabba brunräven hoppar över den lata hunden."; int nummer = 42; dubbel kontanter = 99,99; boolean existerar = true;
Även om koden ska vara enkel att vara självklarande, märk att den visar variabler som innehåller strängar, numeriska typer och boolesiska värden.
På starkt skrivna språk måste du också ange vilken typ av information en funktion kommer att returnera. Ta följande exempel:
public string getGreeting () returnera "Hej världen!"; offentliga booleanska isAlive () return true; public void doSomething () for (int i = 0; i < 10; i++ ) // Perform something
Observera att i den ovanstående exemplet har den slutliga funktionen en returtyp av ogiltig. Det betyder att funktionen inte återkommer något. När vi börjar titta på dynamiska språk ser vi hur detta skiljer sig åt.
Självklart är dessa extremt enkla, men det är okej eftersom de ska göra en punkt: De starkt skrivna språken har variabler och funktioner som har sin datatyp uttryckligen inställd.
När det gäller dynamiskt typade språk finns det ett antal lyxer som kommer att kunna definiera variabler och skapa funktioner.
I de tidigare exemplen är variabeln exempel kan bara hålla en sträng. Det betyder att det inte kan hålla ett flytande punktnummer eller ett booleskt värde - det måste håll en sträng. På dynamiskt typade språk är det inte så.
Istället kan variabler hänvisa till en sträng vid en punkt under programmets livstid, ett heltal vid en annan punkt och ett booleskt värde vid en annan punkt. Det kan givetvis bli förvirrande om någon typ av kodningsstandarder inte antas, men det ligger utanför omfånget för denna punkt.
Poängen är att variabler som definieras i dynamiskt typade språk kan referera till olika typer av data genom ett programs körning.
Till exempel:
var exempel exempel = "Den snabba brunräven hoppar över den lata hunden."; exempel = 42; exempel = 99,99; exempel = true;
Observera att dessa variabler saknar datatyp - de är helt enkelt deklarerade som typvar och ställs sedan in efter behov. Vissa språk definierar variabler annorlunda än vad du ser ovan, men poängen är inte att visa hur ett språk gör det över det andra. Det ska visa hur variabler helt enkelt inte refererar till en viss typ av data.
Funktioner fungerar på ett liknande sätt. Det vill säga, snarare än att definiera returtypen för data, definierar du bara funktionen och får den att returnera ett värde.
funktion getGreeting () returnera "Hej världen!"; funktionen ärAlive () return true; funktion doSomething () for (var i = 0; i < 10; i++ ) // Perform something
Återigen kräver olika språk att funktioner definieras på olika sätt (till exempel använder vissa språk inte fungera sökord men istället använda def nyckelord), men kernen är att du inte behöver uttryckligen ange vilken typ av data som kommer att returneras från funktionen.
Detta kan vara ett riktigt kraftfullt verktyg; det kan dock också göra det svårt att läsa koden, svårt att förstå vad funktionen kommer att returnera och / eller svårt att veta hur man ställer in extern kod för att ringa funktionerna (t.ex. vid jämförelser, villkor och så på).
Därför är kodningsstandarder och tydliga namngivningskonventioner viktiga. Men det är ett ämne som ligger utanför ramen för denna serie.
Nu när vi har tagit en kortfattad titt på hur starkt skrivna språk och dynamiskt typade språk hanterar variabler, funktioner och datatyper i allmänhet kan vi uppmärksamma hur typen tvång fungerar inom det större sammanhanget av applikationer som skrivs in dynamiskt typade språk.
Närmare bestämt tittar vi på hur vi kan använda prestanda till vår fördel, och vi kan titta på hur vi kanske kan introducera fel genom att inte vara tydligt tydliga i vår kod. Så börjar vi i nästa artikel, vi ska göra exakt det.
Under tiden lägger du till alla kommentarer, frågor och allmän feedback till foderet nedan!
Accentsconagua