Introductie ActionScript

Introductie

ActionScript is een programmeertaal voor het Flash platform. Met ActionScript is het mogelijk om applicaties te ontwikkelen die o.a. binnen een browser met een Flash player kunnen worden uitgevoerd.

Tijdens deze les leer je hoe je ActionScript kunt aanroepen en daarmee een Flash applicatie kunt maken. Daarnaast gaan we onder andere kijken naar het maken en aanroepen van functies, het declareren van variabelen en naar een aantal expressies in ActionScript.

Programmeren in de Flash omgeving

Adobe Flash is een omgeving om flash applicaties mee te ontwikkelen. Deze omgeving is erg geschikt om op een visuele manier eenvoudige applicaties te maken zonder dat de gebruiker zelf (veel) ActionScript code hoeft te schrijven. Toch is deze omgeving ook geschikt om wat complexere applicaties met veel meer ActionScript code te maken.

De basis voor iedere Flash applicatie is een .fla file. Hierin staan een aantal instellingen (zoals het aantal fps en de afmetingen van de applicatie) en kan met een bibliotheek maken met objecten (bijvoorbeeld afbeeldingen en geluiden) die men in de applicatie kan gebruiken. Vanuit deze .fla file roepen we onze ActionScript code aan. Dat doen we met een zogenaamde “document klasse”.

Onze ActionScript code plaatsen we in ActionScript files. Deze bestanden eindigen met .as, bijvoorbeeld SuperMario.as.

Om een flash applicatie uit te voeren maakt Flash van alle bestanden (.fla, .as en eventuele afbeeldingen, lettertypes en geluidsfragmenten), een .swf bestand dat uitgevoerd kan worden in een flash player.

ActionScript

Een flash programma dat gebruikt maakt van ActionScript programmeer je door in Adobe Flash ActionScript bestanden te schrijven. Deze ActionScript code bestaat uit een aantal onderdelen die er samen voor zorgen dat je de juiste functionaliteit in je programma krijgt. Om te beginnen heeft een ActionScript bestand altijd een bepaalde structuur. Omdat ActionScript een Object Georienteerde taal is, hebben we te maken met klasses. Dit zijn templates voor het creeren van objecten. Een klasse zou in een programma bijvoorbeeld een speler van een spel kunnen beschrijven. Bij de meeste wat uitgebreidere programma’s krijg je te maken met veel klasses. Omdat dat snel onoverzochtelijk wordt, kunnen klasses ingedeeld worden in zogenaamde packages. Die zijn vergelijkbaar met mappen op je computer waar je bestanden in opslaat.

Dus in ActionScript maken we klasses in actionscript bestanden die binnen packages worden ingedeeld.

Binnen een klasse hebben we variabelen en functies. Variabelen zijn eigenschappen van een object, bijvoorbeeld de naam van een speler. Functies gebruik je om bepaald akties uit te voeren, een speler kan misschien wel omhoog springen of een voorwerp oprapen.

Commentaar in code

Soms is het handig om commentaar bij code te plaatsen. Bijvoorbeeld met een uitleg over een functie of met een opmerking over een bepaalde bewerking. Commentaar zorgt ervoor dat de code leesbaarder wordt en maakt het vaak makkelijker om te begrijpen wat het doel van iets is.

Er zijn twee manieren om commentaar toe te voegen aan ActionScript code:

/*
Dit is een commentaar dat bestaat uit meerdereregels, een zogenaamd commentaarblok.
Vooral om uitgebreid code toe te lichten is dit geschikt, bijvoorbeeld aan het begin
van een klasse of een functie.
*/
// Dit is commentaar dat op 1 regel staat.
// Voor iedere regel moeten er weer opnieuw
// twee schuine strepen staan.

Algemene informatie over ActionScript

Alle regels code binnen ActionScript sluiten we af met een ; (puntkomma). Dit is niet verplicht binnen ActionScript maar zorgt er voor dat de code leesbaarder wordt.

Over het algemeen wordt alle code van boven naar benden, per regel van links naar rechts uitgevoerd in ActionScript.

Het trace commando wordt vaak gebruikt om de werking van een voorbeeld uit te leggen of om fouten op te sporen in de code. Het trace commando stuurt uitvoer naar het uitvoer scherm binnen de ontwikkelomgeving.

Klassen en objecten

Een klasse kunnen we zien als een blauwdruk van een object. Van een klasse kunnen we meerdere objecten creëren die allemaal dezelfde eigenschappen hebben. Zo zouden we een klasse kunnen definiëren met de naam Persoon en vervolgens meerdere objecten van het type Persoon kunnen instantieren, meerdere personen. Een klasse definiëren we in ActionScript met behulp van het class keyword:

package {
	class HelloWorld {
	}
}

Het voorgaande stukje code definieert de klasse HelloWorld. Deze klasse mag alleen in een bestand worden opgeslagen dat de naam HelloWorld.as heeft.

Binnen een klasse kunnen functies worden gedefinieerd en variabelen worden gedeclareerd. In het volgende voorbeeld is de klasse uitgebreid met een declaratie van een variabele, namelijk “begroeting”, en de definitie van twee functies, “HelloWorld” en “nogEenFunctie”.

“HelloWorld” is in dit geval een speciale functie die altijd aangeroepen wordt bij het aanmaken van een object van het type HelloWorld. Deze speciale functie noemen we de constructor en moet altijd dezelfde naam hebben als de klasse.

package {
	class HelloWorld {
 
		var begroeting:String = “Hello World”;
 
		function HelloWorld() {
			trace(begroeting);
		}
 
		function nogEenFunctie() {
			 // hier doen we iets slims...
		}
	}
}

Functies

Binnen een klasse kunnen we verschillende functies definiëren. Een functie kan vanuit een ander stuk code aangeroepen worden om een bepaalde operatie uit te voeren en eventueel een resultaat terug te geven. Om bijvoorbeeld te bepalen hoeveel letters er in een woord voorkomen zouden we een functie kunnen declareren. Deze functie zou dan een woord als argument mee moeten krijgen en zou dan een getal terug moeten geven.

Onderstaande code roept een functie aan die iets naar het uitvoerscherm schrijft:

package {
	class HelloWorld {
		// dit is een hello world constructor
		function HelloWorld() {
			trace("hello world");
			zegIets();
		}        
 
		function zegIets() {
			trace("wat wil je zeggen?");
		}
	}
}

De nieuwe functie zegIets toont net als de constructor een stukje tekst in het uitvoerscherm. Hiervoor gebruiken we het trace commando. Dit commando is ook een functie, een van de ingebouwde functies in ActionScript.

Met behulp van het return statement kunnen we vanuit een functie iets teruggeven aan degene die ons heeft aangeroepen. Bijvoorbeeld het resultaat van een berekening. Of zoals in de volgende code, een String object:

package {
	class HelloWorld {        // dit is een hello world constructor
		function HelloWorld() {
			trace("hello world");
			trace(zegIets());
		}
 
		function zegIets():String {
			trace("wat wil je zeggen?");
			return "iets!";
		}
	}
}

We kunnen aan een functie ook waardes meegeven. Dit zijn zogenaamde argumenten. We kunnen met deze argumenten in de functie iets doen, bijvoorbeeld twee getallen bij elkaar optellen of bepalen hoeveel letters een woord heeft. Argumenten definiëren we in de functie tussen de twee haakjes, bijvoorbeeld:

function vermenigvuldig(a, b):Number {
	return a * b;
}

Een functiedeclaratie ziet er zo uit:

function naam(var1, ...., var n):returnType {
	// hier staat de code die daadwerkelijk iets doet..
}

Het aanroepen van een functie

var rekenmachine = new Rekenmachine();
var resultaat = rekenmachine.vermenigvuldig(10,10);
trace("10 x 10 = "+resultaat);

Variabelen en datatypes

Buiten functies kunnen we ook variabelen declareren binnen een klasse. Variabelen en functie argumenten kunnen we met en zonder datatype declareren. Datatypes geven aan wat voor soort gegevens er in een variabele of in een argument gebruikt kunnen worden.

Een variabele wordt op de volgende manier gedeclareerd:

var naam:Datatype = new Datatype(Param1, ... , ParamN);

Bijvoorbeeld:

var voornaam:String = new String(“Tom”);
var sally:Persoon = new Persoon(“Sally”);
var afstandTotDeZon:Number = new Number(149597870691);
var tekst:Array = new Array("dit", "is", "tekst");

Maar ook:

var leeftijd:Number = 18;

En zelfs:

var leeftijd = 18;
var voornaam = “Harry”;

Afspraken

Als afspraak voor het declareren van variabelen en functies gebruiken we de zogenaamde “CamelCase” conventie. Namen die uit meerdere woorden bestaan schrijven we aan elkaar en ieder woord begint met een hoofdletter. We beginnen altijd met een kleine letter bij variabelen en functies. Klasse namen beginnen we altijd met een hoofdletter. Hetzelfde geldt voor bestandsnamen, die beginnen we ook altijd met een hoofdletter. Dit is balangrijk, want de docent let daar erg op!