Posts tonen met het label array. Alle posts tonen
Posts tonen met het label array. Alle posts tonen

woensdag 1 augustus 2012

JavaScript voor mensen, hobbits en elven - Deel 21: Lijstjes in lijstjes; Bomen te hulp!


Het eerste slagveld

“Objecten worden pas praktisch wanneer ze overerven.”
                                                                                    - Sam Rain
Wie als dappere elf de pijlen richt op Olifaunts, zal de magische krachten van ‘arrays’ waarderen. Deze structuur is in JavaScript een machtig wapen, terwijl tovenaars van andere talen soms moeten tandenknarsen. Arrays in JavaScript kunnen, naast oneindig genummerd zijn (dynamisch), geen verplichte volgorde (sparse) van elementen, een mix bevatten van allerlei soorten elementen (multi-porpose), een mogelijkheid tot ‘tekst’-labels (associatieve arrays), óók andere arrays bevatten. Jazeker, lijstjes van lijstjes; multi-dimensionale arrays.
Een array met ‘meerdere dimensies’ kan even vraagtekens oproepen bij de onervaren hobbit. Eén van de meest praktische structuren in elvenmagie is (hoe kan het ook anders) de boomstructuur. Een boomstructuur begint bij de stam (‘root’) om vervolgens takken te vormen (‘Child/branch/dimensie) die weer uitmonden in andere takken of bladeren (nodes). Wie begint bij de stam kan zo bij ieder blad komen.
 
Midden-Aarde staat voor bomen van allerlei soorten (webpagina’s, pdf-jes, mp3 en zelfs de gegevens die van en naar het Internet gestuurd worden). Wie bomen respecteert, zal weinig moeite hebben ze te begrijpen.
Een tabel is beter te zien als een boom met takken van rijen en kolommen als bladeren. Iedere tak is een ‘nieuwe’ array! Hoewel het in het eerste opzicht aanvoelt als Orcisch is het een kwestie van spelen voor hobbits en ijverige elven. Mensen weten als geen ander hoe ze van bomen wapens moeten maken, zoals speren en katapulten!
Met een beetje JavaScript elvenmagie, maken we zo een boom waar onze vrienden kunnen uitrusten:
var fellowship = new Array(); /*dit is onze stam*/
fellowship[“tovenaars”]=new Array(); /*een tak voor tovenaars*/
fellowship[“tovenaars”][0]=”Gandalf”; /*0 is het eerste nummer in een genummerd lijstje*/
fellowship[“mensen”]=new Array(); /*een tweede tak, maar voor mensen*/
fellowship[“mensen”][0]=”Aragon”;
fellowship[“mensen”][1]=”Faramir”;
var hobbits = new Array (“Frodo”, “Sam”, “Merrin”, “Peppin”); /*de lijst van hobbits wat makkelijker aangemaakt*/
fellowship[“hobbits”]=hobbits; /*alle hobbits hangen nu aan deze boom!*/
...etc...
Met een boomstructuur kunnen we gerelateerde objecten veel gemakkelijker gebruiken in elvenmagie. Wanneer we alle hobbits willen laten dansen uit de ‘fellowship’, dan hoeven we maar:
Function latenDansen(wezen) { var d; /*een dans-functie*/
 d=wezen+”danst blij in het rond!”;
 return d;
}
var i; var feest;
for (i=0; i<fellowship[“hobbits”].length; i++) /*fellowship [“hobbits”] is een ‘array’, dus kan zo gebruikt worden*/
{
 feest+=latenDansen(fellowship[“hobbits”][i];
}
/*feest bevat nu “Frodo danst blij in het rond! Sam danst... etc”*/
Je mag zoveel takken maken als je wilt – vergeet alleen niet dat je de ‘knoop’ maakt met de spreuk ‘new Array’! Teveel takken? Of toch liever snoeien en knippen? Met ‘delete’ tover je ze zo naar de vergetelheid:
delete fellowship[“mensen”][1]; /*faramir verwijderd*/
delete fellowship[“tovenaars]; /*hele tak tovenaars verwijderd*/

Meer lezen over Programmeren? Klik hier voor de inhoudsopgave van alle artikelen!

dinsdag 6 december 2011

Programma's begrijpen: Speciale data structuren


“Gegevens zijn een verzameling van informatie; een lijst van gegevens een informatiebron”
                                                                                                            - Sam Rain
Buiten ‘primitieve datatypes’ en volledige datamodellen zijn er ook speciale structuren voor programma mechaniek, waarvan de ‘lijst’ en het ‘object’ de meest praktische van allen.
De ‘lijst’ of ‘Array’ is een structuur die nodig is om een collectie te maken van gegevens. Deze structuur lijkt zeer complex wanneer deze wordt uitgelegd door een techneut, maar valt eigenlijk reuze mee. Stel we nemen een boek van 1000 pagina’s. Elke pagina bevat een gedicht en een nummer. Om een gedicht snel te kunnen vinden, is het hele boek afzoeken niet een vruchtbare optie. Een inhoudsopgave kost maar een paar pagina’s en bespaart veel tijd, vooral wanneer we veel gedichten gaan selecteren. Een ‘array’ is precies zo’n inhoudsopgave: het gebruikt een ‘index’ om de plaats in het geheugen aan te duiden en een ‘element’ als referentie voor het type gegevens.
Het voordeel van een ‘lijst’ is dat het eenvoudiger werkt bij grote verzamelingen van gegevens; mechaniek zoals sorteren is zelfs zonder lijst een zeer inefficiënt proces. Lijsten in programma’s kunnen op zichzelf weer lijsten bevatten; ze zijn multi-dimensioneel. Ze kan een verzameling van gegevens als element fungeren in een andere lijst. Een data structuur is in feite een lijst van datatypes, daarom valt de ‘array’ ook onder de ‘primitieven’.
Omdat computers altijd tellen vanaf ‘Æ’ is ook het eerste element de 0e referentie in de index; veel talen gebruiken de [ ] vierkante haakjes om de index aan te duiden. Vaak zijn deze daarom numeriek, echter kennen ‘dynamische’ talen ook associatieve indexen, zodat ze ook ‘labels’ kunnen bevatten.
Ter illustratie (in pseudocode) wordt zo een ‘array’ in broncode geschreven:
                        Dynamische Talen                                    Old School                     
Declaratie        Array MijnLijst [ ]                                   String [10] MijnLijst
Toewijzing      MijnLijst [0] = “hallo”                             MijnLijst [ 0 ] = “hallo”
                        MijnLijst [1] = “Sam”                              MijnLijst [ 1 ] = “Sam”

De flexibiliteit van lijsten verschillen wel vaak in diverse talen: ‘nieuwere’ talen nemen veel werk uit handen, terwijl sommige talen precies willen weten hoeveel elementen er maximaal in de lijst mogen staan. De ‘lijsten’ zijn daarom het eerste waar men naar zou moeten kijken in de documentatie bij het leren van een nieuwe programmeertaal.
Het ‘object’ is een speciale lijst: het is een verzameling ‘broncode’, als het ware een data model voor uitvoerbare code. Hoewel niet alle talen het ‘object’ type gebruiken, zijn ze wel zeer populair; naast de efficiëntie die ze van nature hebben, maken ze een programma zeer ‘modulair’ en zelfstandig. Ieder object is uniek en een verzameling van objecten hebben toch dezelfde procedures tot beschikking. Een taal dat objecten gebruiken als conventie, heet ‘object georiënteerd’.
Objecten worden speciaal gedefinieerd: elk object is een ‘klasse’ (‘class’) en heeft binnen deze klasse toegang tot variabelen die ‘onzichtbaar’ zijn voor alle andere objecten. Ook hebben zij speciale ‘procedures’ die niet verder kunnen ‘kijken’ buiten hun klasse, deze heten ‘methoden’ (‘methods’). Dankzij deze functionaliteit kunnen object klassen vaak opnieuw worden gebruikt, en dus objectgeoriënteerde talen vanwege hun efficiëntie populair zijn in de industriële software.
Ook objectgeoriënteerd ontwerpen begint in ‘pseudo code’. Er is zelfs een standaard voor, namelijk UML (unified modelling language). Echter blijft het een serie ‘eigen’ artikelen waardig, en wordt dat nog even buiten beschouwing gelaten.

Meer lezen over Informatie Technologie? Klik hier voor de inhoudsopgave voor alle artikelen!
©SamRain
Data