knowledge base (Haiku only)
How to help us?

Who wants to help this project, can do this writing their own tutorials, descriptions or translations. Also ideas or criticisms are welcome.

To make your own tutorials you have some helpful informtions and opportunities. The easiest way is, you write your tutorial and send it to: webmaster(at)besly.de. It is important that this is really an own tutorial, as there could be legal problems to the original authors otherwise.

Aktuell sind 655 Gäste und keine Mitglieder online

YAB Namespace / Library

Details
Geschrieben von: admin
Kategorie: yab
Auch verfügbar: English (United Kingdom)
Zugriffe: 142

1. Übersicht

YAB ermöglicht die Aufteilung eines Programms auf mehrere externe Libraries.

Eine Library kann enthalten:

  • Variablen
  • Stringvariablen
  • Arrays
  • Subroutinen
  • exportierte Subroutinen

Eine Library wird mit import eingebunden. Ihre von außen verfügbaren Bestandteile werden über den Namespace der Library angesprochen.

import test1
n=test1.test1()
Dabei ist test1 der Namespace und test1() die exportierte Subroutine.

2. Libraries und Namespaces

Eine oder mehrere Libraries können importiert werden:

import test1
import test2
import test3

Jede Library besitzt ihren eigenen Namespace. Dadurch können gleichnamige Variablen und Subroutinen verschiedener Libraries eindeutig unterschieden werden.

a=test1.value
b=test2.value
n=test1.test()
m=test2.test()

Der Namespace wird beim Zugriff vor den Namen des gewünschten Bestandteils gesetzt:

namespace.sub()
namespace.sub$()
namespace.variable
namespace.variable$

3. Exportierte Subroutinen und Rückgabewerte

Eine Subroutine, die außerhalb ihrer Library aufgerufen werden soll, wird mit export definiert:

export sub test1()
return 10
end sub

Der Aufruf erfolgt über den Namespace:

n=test1.test1()
Auch Subroutinen mit $ können exportiert werden:
export sub test2$()
   return "Hallo"
end sub
Aufruf:
text$=test2.test2$()
Das $ ist Bestandteil des Namens der Subroutine und muss beim Aufruf entsprechend angegeben werden.

Eine mit $ benannte Subroutine kann dabei auch einen numerischen Wert zurückgeben. Das $ bestimmt also nicht zwingend den Datentyp des return-Wertes.

Rückgabewerte können direkt zugewiesen oder unmittelbar weiterverarbeitet werden:

n=test.get_number()
text$=test.get_text$()
print arraydim(test.get_array())

4. Parameterübergabe

Exportierte Subroutinen können einen oder mehrere Parameter erhalten.

export sub add(zahl)
   return zahl*2
end sub
Aufruf:
n=test.add(10)
Mehrere Parameter:
export sub add(zahl1,zahl2)
  return zahl1+zahl2
end sub
Aufruf:
n=test.add(10,20)
Die Reihenfolge der übergebenen Werte entspricht der Reihenfolge der Parameterdefinition.

Dabei können auch unterschiedliche Werte übergeben werden:

export sub text$(text$,zahl)
  return text$+str$(zahl)
end sub
Aufruf:
text$=test.text$("Wert: ",10)

5. Zugriff auf Variablen

Variablen einer Library können über den Namespace angesprochen werden.

Numerische Variable:

n=test1.b
Stringvariable:
text$=test1.d$
Allgemeine Formen:
namespace.variable
namespace.variable$
Damit kann eine Library neben ihren exportierten Subroutinen auch Daten für andere Programmteile bereitstellen.

6. local-Variablen

Eine mit local deklarierte Variable gehört zur jeweiligen Subroutine.

counter=100 export
sub test()
  local counter
  counter=counter+1
  return counter
end sub
Hier existieren zwei unterschiedliche Variablen:
counter
→Library-Variable

und:

local counter
→lokale Variable der Subroutine.

Der Zugriff:

test.counter
bezieht sich auf die Library-Variable und nicht auf die lokale Variable.

Die lokale Variable wird bei jedem erneuten Aufruf der Subroutine neu initialisiert.

Beispiel:

export sub test()
  local counter
  counter=counter+1
  return counter
end sub
Mehrere Aufrufe liefern:
test() → 1
test() → 1
test() → 1
Eine local-Variable einer anderen Subroutine ist ebenfalls unabhängig, auch wenn sie denselben Namen besitzt.

7. Zugriff einer Library auf andere Libraries

Eine Library kann auf exportierte Subroutinen und Variablen anderer Libraries zugreifen.

Beispiel:

export sub test5()
  a=test1.test1()
  b$=test2.test2$()
  return a
end sub
Ebenso kann auf Variablen zugegriffen werden:
n=test1.b
text$=test2.d$
Dadurch können Libraries untereinander sowohl Funktionen als auch Daten verwenden.

Eine Library kann somit beispielsweise:

a=test1.test1()
b=test1.b
verwenden.

8. Cross-Namespace-Aufrufe

Mehrere Libraries können miteinander kombiniert werden.

Beispielsweise:

main.yab
¦
+-- test1
+-- test2
+-- test5
test5 kann Funktionen und Variablen von test1 und test2 verwenden:
export sub test5()
  a=test1.test1()
  b$=test2.test2$()
  return a
end sub
Damit können größere Programme aus mehreren spezialisierten Libraries aufgebaut werden.

Eine Library kann dabei sowohl auf Subroutinen:

test1.test1()
als auch auf Variablen:
test1.b
anderer Namespaces zugreifen.

9. Arrays

Libraries können Arrays enthalten und Arrays über exportierte Subroutinen zurückgeben.

Beispiel:

dim numbers(3)
numbers(1)=10
numbers(2)=20
numbers(3)=30
Eine exportierte Subroutine kann das Array zurückgeben:
export sub test_numbers()
  return numbers
end sub
Der Rückgabewert kann über den Namespace direkt weiterverarbeitet werden:
print arraydim(test_array.test_numbers())
print arraysize(test_array.test_numbers(),1)
Das gleiche gilt für String-Arrays:
print arraydim(test_array.test_id$())
print arraysize(test_array.test_id$(),2)
Damit können numerische und String-Arrays über Namespace-Subroutinen zurückgegeben und direkt an Array-Funktionen übergeben werden, ohne sie vorher zwingend einer Variablen zuweisen zu müssen.

Beispielsweise:

arraydim(test_array.test_numbers())
führt zunächst die Namespace-Subroutine aus und übergibt deren Array-Rückgabewert anschließend an arraydim().

Ebenso:

arraysize(test_array.test_numbers(),1)
oder:
arraydim(test_array.test_id$())
arraysize(test_array.test_id$(),2)
Damit eignet sich der Namespace auch für den Austausch komplexerer Datenstrukturen zwischen Libraries.

10. Variablen und Subroutinen als gemeinsamer Namespace

Eine Library stellt über ihren Namespace unterschiedliche Bestandteile zur Verfügung.

Beispiel:

test1
¦
+-- test1()
+-- value
+-- text$
+-- Array
Diese können über denselben Namespace angesprochen werden:
n=test1.test1()
n=test1.value
text$=test1.text$
print arraydim(test1.get_array())
Der Namespace dient somit als gemeinsamer Namensraum für die von der Library bereitgestellten Subroutinen und Variablen.

11. Bestätigte Eigenschaften

Die Namespace-Funktionalität wurde anhand einer Testreihe mit insgesamt 16 Tests überprüft.

Dabei wurden folgende Bereiche getestet

  • Import mehrerer Libraries
  • Namespace-Aufrufe
  • exportierte Subroutinen
  • Subroutinen mit und ohne $
  • numerische Rückgabewerte
  • String-Rückgabewerte
  • Parameterübergabe
  • mehrere Parameter
  • unterschiedliche Parameter
  • Zugriff auf Variablen über den Namespace
  • Zugriff einer Library auf andere Libraries
  • Kombination aus Subroutinen und Variablen verschiedener Namespaces
  • Arrays als Rückgabewerte
  • numerische Arrays
  • String-Arrays
  • direkte Übergabe von Array-Rückgabewerten an arraydim()
  • direkte Übergabe von Array-Rückgabewerten an arraysize()
  • Verhalten von local-Variablen
Insbesondere wurde bestätigt, dass ein Array-Rückgabewert direkt weiterverarbeitet werden kann:
arraydim(test_array.test_numbers())
Arraysize(test_array.test_numbers(),1)
arraydim(test_array.test_id$())
arraysize(test_array.test_id$(),2)

12. Kurzreferenz

FunktionSyntax
Library importieren import name
Sub exportieren export sub name()
$-Sub exportieren export sub name$()
Sub aufrufen name.sub()
$-Sub aufrufen name.sub$()
Variable name.variable
Stringvariable name.variable$
Ein Parameter name.sub(wert)
Mehrere Parameter name.sub(wert1,wert2)
Rückgabewert return wert
Array zurückgeben return array
Arraydimension arraydim(name.sub())
Arraygröße arraysize(name.sub(),dimension)
Library-Variable name.variable
Library-Stringvariable name.variable$

13. Merksatz

import bindet eine Library ein, export stellt eine Subroutine nach außen bereit und der Namespace ermöglicht den eindeutigen Zugriff auf die Variablen und Subroutinen der Library.

import meine_lib
n=meine_lib.berechnen(10)
text$=meine_lib.text$("Hallo")
wert=meine_lib.variable
text$=meine_lib.text$
print arraydim(meine_lib.get_array())

Damit können YAB-Programme in mehrere Libraries aufgeteilt und diese Libraries über Namespaces miteinander verbunden werden.