Funksjoner


Hva er function:

Funksjoner kan brukes til flere ting:

Ved at instruksjonene i en funksjon er samlet ett sted, men kan brukes mange ganger, oppnår vi disse fordelene:

Underprogram/prosedyrer:

Hvis vi skal utføre en samling med instruksjoner mange forskjellige steder i et program, er det lurt å samle disse i et underprogram eller en prosedyre ved å deklarere:

function underprogram():void {     // void (=intet) betyr at ingenting skal returneres

   instruksjon1;

   instruksjon2;

   ...

}//underprogram()

Hver gang vi ellers i programme skal ha utført denne samlingen av instruksjoner, kan vi utføre underprogrammet med en instruktjson:

underprogram();

Funksjoner:

Hvis vi skal lage en utregning eller gjøre operasjoner som skal gi et resultat, deklarerer vi en funksjon:

Eksempel:

Regneoperasjon som regner om fra Fahrenheitgrader til Celcius grader, formel: c = (f-32)*5/9

f -->
f2c
--> c

 

function f2c( f:Number): Number {

 return (f-32)*5/9;

}//f2c()
Her deklarerer vi datatypen Number for det som skal returneres,

og vi må også angi hva som skal returneres med return.
Etter å ha deklarert denne funksjonen, kan vi bruke den eksempelvis slik:
trace( "80 grader Fahrenheit er " + f2c(80) + "grader Celcius.");

Eksempel:

Beregning av BMI (Body Mass Index) etter formelen: BMI = vekt/høyde2, der der vekt regnes i kg. og høyde i meter:

hoyde --->
vekt --->
beregnBMI
---> bmi

 

function beregnBMI(hoyde: Number, vekt: Number): Number {

   return vekt/(hoyde*hoyde);

}//beregnBMI()

Etter å ha deklarert denne funksjonen, med parameterene hoyde og vekt, kan vi bruke den eksempelvis slik:

trace( "En person som veier 120 kg og er 1.7 m høy har BMI " + beregnBMI(1.7,120) +".");

 


Eksempler på hvordan vi kan lage funksjoner for tabelloperasjoner på Array:

La oss lage funksjoner for noen av tabell-operasjonene vi har snakket om i forbindelse med Array og Assosiative Array:

Sum, gjennomsnitt, maksimum og minimum i en-dimensjonale tall-tabeller:

tabell --->
sum
---> Number

 

function sum(tabell: Array): Number {

   var s: Number = 0.0;

   for(var i: int = 0; i < tabell.length; i++) {

      if( !isNaN(tabell[i]) ) {	//Sjekker om vi har et tall

         s += Number(tabell[i]);	//Number() for å takle tall som String 

      }//if

   }//for

   return s;

}//sum()

 

function gjennomsnitt(tabell:Array): Number {

	return sum(tabell)/tabell.length;	//Bruker sum-funksjonen over! 

}//gjennomnsitt()

 

function maksimum(tabell: Array): Number {

   var maks: Number = Number.MIN_VALUE;

   for(var i: int = 0; i < tabell.length; i++) { 

      if( !isNaN(tabell[i]) ) {

         if( tabell[i]>maks) {

            maks = tabell[i];

         }//if ny maks

      }//if tall

   }//for

   return maks;

}//maksimum()

 

function minimum(tabell: Array): Number {

   var min: Number = Number.MAX_VALUE;

   for(var i: int = 0; i < tabell.length; i++) { 

      if( !isNaN(tabell[i]) ) {

         if( tabell[i]<min) {

            min = tabell[i];

         }//if ny min

      }//if tall

   }//for

   return min;

}//minimum()

 

Eksempler på bruk av funksjonene sum, gjennomsnitt, maksimum og minimum på en tall- og en tekst-tabell:

var tall: Array = [5,4,33,22,57,89,44,99];

var tekst: Array = ["Olsen", "Hansen","22", "Ferkenberg","33", "Jensen"];

Instruksjonene:

trace("sum av tall: "+sum(tall));
trace("gj.snitt av tall: "+gjennomsnitt(tall));
trace("sum av tekst: "+sum(tekst));
trace("gj.snitt av tekst: "+gjennomsnitt(tekst));
trace("maks av tall: "+maksimum(tall));
trace("maks av tekst: "+maksimum(tekst));
trace("min av tall: "+minimum(tall));
trace("min av tekst: "+minimum(tekst));

gir resultatet:

sum av tall: 353

gj.snitt av tall: 44.125

sum av tekst: 55

gj.snitt av tekst: 9.166666666666666

maks av tall: 99

maks av tekst: 33

min av tall: 4

min av tekst: 22

(Egentlig skal disse funksjonene bare brukes på tabeller med tall, men greit at funksjonene er laget slik at programmet
ikke krasjer når funksjonene blir brukt på tekst-tabeller, og at de i så fall også gir tolkbare resultater.)

 


Eksempler på funksjoner for tilsvarende operasjoner i eksemplet fra Assosiative Array:

Volvo
Blå
110
Fiat
Rød
150
Lada
Rustrød
68
Renault
Hvit
100
 
var bruktbiler: Array =

    [ { merke: "Volvo", farve: "Blå", pris: 110},

      { merke: "Fiat" , farve: "Rød", pris: 160},

      { merke: "Lada" , farve: "Rustrød", pris: 68 },

      { merke: "Renault", farve: "Hvit", pris: 100} ];

Eksempel fra boken side 101 (utvidet med alder fra eksemplet side 100):

Lege
37
Hansen
Politi
51
Lia
Ingeniør
62
Jensen
Flyger
44
 
var personer: Array = 

   [ { etternavn: "Bø",     yrke: "Lege",     alder: 37},

     { etternavn: "Hansen", yrke: "Politi",   alder: 51},

     { etternavn: "Lia",    yrke: "Ingeniør", alder: 62},

     { etternavn: "Jensen", yrke: "Flyger",   alder: 44} ];

Traversering av tabellene:

 

tabell --->
tabell2String
---> String

 

function tabell2String(tabell: Array): String {

	var resultat: String = "";

	for(var i: int = 0; i < tabell.length; i++) {

		for(var egenskap: String in tabell[i]) {

			resultat += tabell[i][egenskap]+"\t";

		}//for objekt

		resultat += "\n";

	}//for tabell

	return resultat;

}//tabell2String()

Instruksjonene:

trace( tabell2String( bruktbiler ) );

trace( tabell2String( personer ) );

vil gi output lik:

Volvo	110	Blå	

Fiat	160	Rød	

Lada	68	Rustrød	

Renault	100	Hvit	
37	Lege	Bø	

51	Politi	Hansen	

62	Ingeniør	Lia	

44	Flyger	Jensen	

Finne sum for en av egenskapene i objektene:

tabell --->
egenskap
--->
sum
---> Number

 

function sum(tabell: Array, egenskap: String): Number{

   var resultat: Number = 0.0;

   for(var i: int = 0; i < tabell.length; i++) {

      if( !isNaN(tabell[i][egenskap]) ) {	

         resultat += Number(tabell[i][egenskap]);

      }//if

   }//for

   return resultat;

}//sum()

Instruksjonene:

trace("Verdi av bilene: "+sum(bruktbiler,"pris"));

trace("Verdi av merkene: "+sum(bruktbiler,"merke"));

trace("Total alder: "+sum(personer,"alder"));

vil gi output lik:

Verdi av bilene: 438

Verdi av merkene: 0

Total alder: 194

Søke opp verdier:

tabell --->
egenskap --->
sokeord --->
finn
---> int

 

function finn(tabell: Array, egenskap: String, sokeord: String): int { 

   var resultat: int = -1;	

      for (var i: int = 0; i < tabell.length; i++) {

      if(tabell[i][egenskap]==sokeord) {

         resultat = i;

      }//if

   }//for

   return resultat;

}//finn()

Instruksjonene:

trace("Fant Lada med indeks: " + finn(bruktbiler,"merke","Lada"));

trace("Fant Lia med indeks: " + finn(personer,"etternavn","Lia"));

trace("Fant Voxholt med indeks: " + finn(personer,"etternavn","Voxholt"));

vil gi output lik:

Fant Lada med indeks: 2

Fant Lia med indeks: 2

Fant Voxholt med indeks: -1

 


Eksempel på funksjon som regner ut avstander i avstandstabell.
(Eksempel side 110 i læreboken. Også brukt i eksamensoppgaven om flystevne våren 2010.)

 

frasted --->
tilsted --->
beregnAvstand
---> int

 

var avstander: Array =[

					    [  0, 22, 41, 71,113],

					    [ 22,  0, 21, 51, 93],

					    [ 41, 21,  0, 30, 72],

					    [ 71, 51, 30,  0, 43],

					    [113, 93, 72, 43,  0]

					  ];

var sted: Array = ["arendal", "grimstad", "lillesand", "kristiansand", "mandal"]; 

function beregnAvstand(frasted:String,tilsted:String):int {

	var fra: int = sted.indexOf( frasted.toLowerCase() );

	var til: int = sted.indexOf( tilsted.toLowerCase() );

	if( fra >= 0 && 

	    fra < avstander.length &&

	    til >= 0 &&

		til < avstander.length

	  ) {

		return avstander[fra][til];

	}else{

		return -1;			//Feilkode

	}//if

}//beregnAvstand()

 

 


Metoder (funksjoner i klasser / objekter):

Funksjoner som deklareres inne i en klasse, kalles metoder. (Klasser, egenskaper og metoder er objektorientert programmering.)

Eksempel:

En klasse med metodene over (sum, gjennomsnitt, maksimum og minimum), kan lages slik:

package {



	/* Klasse med interface:

		maximum(tabell:Array):Number

		minimum(tabell:Array):Number

		um(tabell:Array):Number

		gjennomsnitt(tabell:Array):Number

	*/



	public class Tabelloperasjoner {



   	private var n:int	= 0;

   	private var i:int = 0;



   	public function sum(tabell: Array): Number {

           var s: Number = 0.0;

           for(var i: int = 0; i < tabell.length; i++) {

              if( !isNaN(tabell[i]) ) {				//Sjekker om vi har et tall 

                s += Number(tabell[i]);		//Number() for å takle String

              }//if

           }//for

           return s;

        }//sum()
        ... tilsvarende deklarasjoner med gjennomsnitt(), maksimum() og minimum()...
	}//class



}//package

Med denne klassen deklarert og lagt i egen fil med navnet Tabelloperasjoner.as), kan vi i et program gjøre eksempelvis slik:

var temperaturer: array = [13,13,14,14,14,15,15,16,16,17,16,15];
var tabop: tabelloperasjoner = new Tabelloperasjoner(); 
trace( "summen ble: "+tabop.sum(temperaturer) ); 
trace( "makstemperaturen var: "+tabop.maksimum(temperaturer)