Dart: Een Taal Die Je Al Kent

Dit is een vervolg op het eerste deel

We gaan nu in op de daadwerkelijke taal, die dit blijkbaar allemaal mogelijk maakt.

Dart is een zogenaamde conservatieve programmeer taal. Niet ontwikkeld om allerlei nieuwe zaken te tonen, maar meer om een voorspelbaar en stabiele programmeer omgeving te maken. Komt van Google uit 2011, met als doel om JavaScript als de taal van het web van de troon af te stoten.

Dit cookbook doet een aanname dat je bekend bent met C-style talen, maar dat ben ik niet. Zal misschien wat extra achtergrond informatie nodig hebben, maar de uitleg die ze overslaan zoals If statements, loops en switches zijn natuurlijk heel erg bekend en niet alleen maar in de C wereld bekend.

In het boek wordt gezegd dat je via een online dart platform kunt gaan, of dat je een VS of IntelliJ IDE moet gebruiken. Omdat ik het meeste werk verricht met Atom, heb ik natuurlijk gezocht of er een Dart plugin voor Flutter / Dart aanwezig is. Deze heb ik gevonden. Met de meeste downloads heb ik opgehaald en daarbij werd ook een toolbar geinstalleerd. De plugin herkende zelf al de SDK installatie met Flutter die ik op de schijf had staan, dus dat leek goed te gaan:

Variabelen declareren – var vs final vs const

variabelen zijn nodig om input op te slaan, iets aan te passen of met deze input te doen en dan later als output mee terug te geven. Zonder variablen is dit dus niet mogelijk.

Een nieuwe trend, is blijkbaar niet-wijzigbare-variabelen. Dus eenmaal geset: that is it! Dit is veiliger, hebben geen side effects en leiden tot minder bugs als gevolg.

In het volgend stuk gaan we een klein programma maken, dat variabelen declareert in de 3 verschillende manieren dat Dart toestaat:

1. var
2. final
3. const

ga naar DartPad

Hoe dan?

Haal alles weg uit de main.dart die automatisch is gemaakt.

Een main function toevoegen, wat voor elk Dart programma het beginpunt is:

main() {
 variablePlayground();
}

Deze code kan niet uitgevoerd worden, omdat de functie variablePlayground() nog niet gedefinieerd is. Deze functie is een hub(?) voor alle andere voorbeelden in dit playbook recept.

void variablePlayground() {
 basicTypes();
 untypedVariables();
 typeInterpolation();
 immutableVariables();
}

void geeft aan dat er niets terugkomt uit deze functie. Dit is bij andere talen volgens mij ook al zo.

Daarna moet je deze basisTypes definiëren en het mooie van deze variabelen is dat je ze kunt wijzigen:

void basicTypes() {
 int four = 4;
 double pi = 3.14;
 num someNumber = 24601;
 bool yes = true;
 bool no = false;
 int nothing; 

 print(four);
 print(pi);
 print(someNumber);
 print(yes);
 print(no);
 print(nothing == null);
}

Nog steeds kan dit niet uitgevoerd worden, aangezien de 3 andere methodes nog niet bekend zijn.

Zelf heb ik om te testen even wat zaken als comments uitgesloten. Daarmee kon ik iig de uitvoer zien van de print statements:

De syntax voor een mutable variable is hetzelfde als in vele andere talen. Eerst het type (int, double etc.) dan de naam en na de = de waarde. Als je geen waarde toekent, dan is het automatisch null.

Blijkbaar was er in de oudere versie dat je gewoon een variabele zonder instantiatie kon doen, maar daar kan Dart nu niet meer tegen blijkt. Daarom heb ik de onderste print statement er ook uit moeten halen. Deze had ik weer terug gedaan en ik kreeg een warning in DartPad:

Bij view docs stond in ieder geval het volgende vermeld:

not_assigned_potentially_non_nullable_local_variable

dat kwam dus doordat hij niet null mocht zijn. Als je dat wel wilt kunnen laten gebeuren, dan moet je achter het type een ‘?’ zetten:

Dart heeft een speciaal type: dynamic, die eigenlijk staat voor de gratis uit de gevangenis komen kaart staat (Monopoly?) maar dan van het types systeem. Je kunt dit type voor je variabele zetten om ervoor te zorgen dat je eigenlijk alles erin kan plaatsen!

void untypedVariables() {
 dynamic something = 14.2;
 print(something.runtimeType); //outputs 'double'
}

Dart var keyword is net anders dan dynamic. Zodra er een waarde aan de variabele is toegekend, zal Dart het type onthouden! De waarde mag nog steeds gewijzigd worden, maar de type niet meer!

void typeInterpolation() {
 var anInteger = 15;
 var aDouble = 27.6;
 var aBoolean = false;

 print(anInteger.runtimeType);
 print(anInteger);

 print(aDouble.runtimeType);
 print(aDouble);

 print(aBoolean.runtimeType);
 print(aBoolean);
}

Er zijn nog 2 keywords, voor niet wijzigbare variabelen: final en const.

void immutableVariables() {
 final int immutableInteger = 5;
 final double immutableDouble = 0.015;

print(immutableInteger);
print(immutableDouble);
 
 // Type annotation is optional
 final interpolatedInteger = 10;
 final interpolatedDouble = 72.8;

 print(interpolatedInteger);
 print(interpolatedDouble);

 const aFullySealedVariable = true;
 print(aFullySealedVariable);
}

Maar dat moet je natuurlijk niet zomaar geloven, vandaar dat ik gewoon zelf toch nog de interpolatedDouble heb geprobeerd aan te passen:

var, final en const kunnen op deze wijze gedeclareerd worden:

var animal = 'Duck';
final numValue = 42;
const isBoring = true;

var kan dus gewijzigd worden. final kunnen slechts eenmaal geassigned worden, maar door gebruik van objecten kun je de velden van de objecten wel wijzigen. Const zijn compile time constanten en totaal niet wijzigbaar. Een type toekennen kan alleen bij de final modifier:

final intnumValue = 42; // this is ok // NOT OK: const int or var int.

Waarom variabelen die niet kunnen wijzigen?

1. het is sneller
2. geen side effecten. De meeste bugs in programmeren komt doordat waardes worden gewijzigd en onvoorzien ergens anders ook weer wijzigingen teweeg brengen.

2 linkjes die ze geven:

Meer over Dart en de ingebouwde type variabelen:
https://dart.dev/guides/language/language-tour

Meer aspecten over de Dart taal en hoe te gebruiken voor web en server applicaties:
https://www.packtpub.com/web-development/dart-essentials