Drucken
Hauptkategorie: Entwicklung
Kategorie: yab
Zugriffe: 3515

 
Datei Zeilenweise auslesen
CSV Dateien auslesen
Dateiname des laufenden Programms ermitteln
Ermittlung des Standortes Ihres Programmverzeichnisses im System

People Datei erstellen

Vorhandensein eines Ordners oder Datei ermitteln
Vorhandensein eines Ordners oder Datei ermitteln (Variante 2) 


 Datei Zeilenweise auslesen

Die Einträge in der Datei, die ausgelesen werden soll, müssen untereinander geschrieben sein.

Der Code zum zeilenweise Auslesen einer Datei sieht wie folgt aus:

fileload$="/boot/home/auslesen.txt" 
 auslesen=open(fileload$, "r") 
 while (not EOF(auslesen)) 
      x=x+1 
      dim d$(x) 
      line input #auslesen b$ 
      d$(x)=b$ 
 wend 
 close(auslesen) 

 draw text 5, 38, "Eintrag 1: "+d$(1), "View1" 
 draw text 5, 58, "Eintrag 2: "+d$(2), "View1" 
 draw text 5, 78, "Eintrag 3: "+d$(3), "View1"


Als erstes wird eine Variable fileload$ erzeugt, welche den Standort der auszulesenden Datei beinhaltet.

Da das Programm momentan nicht weiß, wie die auszulesende Datei heißt, müssen wir für diese eine weitere Variable vergeben. Diese wird hier als auslesen bezeichnet. Diese Datei wird dann über den Befehl open(fileload$, "r") geöffnet. Dabei geben wir die Variable an in der die auszulesende Datei gespeichert ist. Mit der der Angabe "r", sagen wir dem Open- Befehl, das diese Datei zum "lesen" (read) geöffnet wird.

Hiernach wird eine while Schleife geöffnet mit dem Zusatz, das in der Datei vom Anfang bis zum Ende gelesen werden soll (EOF = End of File).

Über x=x+1 wird die Größe des Arrays ermittelt. Hierbei wird bei jedem Durchlauf der Schleife, der Werk x um einen erhöht. Man kann es so verstehen, dass hier ermittelt wird, wie viele Zeilen die Datei hat.

Mit dim d$(x) erstellen wir ein Array, in dem die vorher ermittelten Daten gespeichert werden.

Durch line input #auslesen b$ lesen wir nun die Einträge der Datei aus und speichern diese in die Variable b$.

Nun werden die Variable b$ in den Array d$(x) eingebunden. Das bedeutet, das wir nun in dem Array d$ nicht nur die Zeilennummer, sondern auch den Zeileneintrag gespeichert haben.

Mit wend gehen wir an den Anfang der Schleife zurück.

Jetzt könne wir die Ausgelesenen Daten ausgeben, indem wir zum Beispiel einen draw text erstellen und in diese Textausgabe den Array mit einbinden. Mit "Eintrag 1: "+d$(1) fügen wir hinter der Textausgabe "Eintrag 1: ", das ausgelesene Wort aus der ersten Zeile des Array d$ ein.

zurück zur Übersicht 


 CSV Dateien auslesen

Die Einträge in der Datei, die ausgelesen werden sollen, müssen mit dem ";" getrennt sein. Hinter dem letzten Eintrag braucht kein Semikolon stehen.

Der Code zum Auslesen einer CSV-Datei sieht wie folgt aus:

d=0
sub laden(d)
       fileload$="taballe.csv"
       auslesen=open(fileload$, "r")
       x=0
       while (not EOF(auslesen))
               line input #auslesen b$ 
               dim elements$(1)
               numElements = split(b$, elements$(),";")
               for i = 1 to numElements
                    x=x+1
                   dim d$(x)
                   d$(x) = elements$(i)
              next i
       wend
 close(auslesen)

 draw text 5, 38, "Eintrag 1: "+d$(1), "View1" 
 draw text 5, 58, "Eintrag 2: "+d$(2), "View1" 
draw text 5, 78, "Eintrag 3: "+d$(3), "View1" 
 end sub


Wir rufen eine Subroutine (laden) auf und übergeben ihr die Variable d mit dem Wert 0. Das übergeben dieser Variablen ist wichtig, da sonst die Subroutine die Werte bei jedem neuen Aufruf der Subroutine an das Ausgabearray anhängen und es nicht aktualisieren würde.

Nachdem wir die Subroutine aufgerufen haben wird eine Variable fileload$ erzeugt, welche den Standort der auszulesenden Datei beinhaltet.

Da das Programm momentan nicht weiß wie die auszulesende Datei heißt, müssen wir für diese eine weitere Variable (Die Variable ist der Filehandle) vergeben. Diese wird hier als auslesen bezeichnet. Diese Datei wird dann über den Befehl open(fileload$, "r") geöffnet. Dabei geben wir die Variable an in der die auszulesende Datei gespeichert ist. Mit der der Angabe "r", sagen wir dem Open- Befehl, das diese Datei zum "lesen" (read) geöffnet wird.

Dann wird eine Zählervariable (x) erstellt. Diese hat den Wert 0.

Hiernach wird eine while Schleife geöffnet mit dem Zusatz, das in der Datei vom Anfang bis zum Ende gelesen werden soll (EOF = End of File).

Durch line input #auslesen b$ lesen wir nun die Einträge der Datei aus und speichern diese in die Variable b$. Wir erzeugen danach ein Array elements$ mit der Größe 1. 

Mit numElements = split(b$, elements$();";") wird nun jeder Eintrag in dem Array elements$ und die Anzahl der Einträge in der Variablen numElements gespeichert.

Die nächste Schleife dient dazu, die Werte in ein Array d$ für die Ausgabe zu speichern. Die Schleife läuft solange bis sie den Wert von numElements erreicht hat. In der Schleife wird über x=x+1 die Größe des Arrays ermittelt. Hierbei wird bei jedem Durchlauf der Schleife, der Werk x um einen erhöht

Mit dim d$(x) erstellen wir ein Array, in dem die vorher ermittelten Daten gespeichert werden.

Nun wird aus dem Array elements$ jeder Eintrag in das Array d$(x) gespeichert.

Mit wend gehen wir an den Anfang der Schleife zurück

Jetzt können wir die ausgelesenen Daten ausgeben, indem wir zum Beispiel einen draw text erstellen und in diese Textausgabe den Array mit einbinden. Mit "Eintrag 1: "+d$(1) fügen wir hinter der Textausgabe "Eintrag 1: ", das ausgelesene Wort aus der ersten Zeile des Array d$ ein. Zu guter letzt wird nun noch die Subroutine beendet.

zurück zur Übersicht 


 Dateiname des laufenden Programms ermitteln
Beitrag von Rene Passier Oktober 2010

Manchmal kann es notwendig und hilfreich sein, den Namen des eigenen Programms zur Laufzeit herauszufinden. Leider bietet yab dafür keine Funktion an. Dennoch ist es möglich dies mit yab zu lösen. In folgende, kleine Routine übernimmt diese Arbeit für uns.

Der Befehl "ps" gibt uns, richtig benutzt, alle Informationen die wir benötigen um den Namen des Programms herauszufinden. Ruft man nun im Terminal den Befehl "ps -a" auf erscheint eine mehr oder weniger lange Liste mit allen laufenden Programmen und Tasks. Aus diesem Wust an Informationen müssen wir nun die gewünschte Information herausfiltern. Die Liste sieht dabei so, oder ähnlich, aus:

Der Code zum Auslesen einer CSV-Datei sieht wie folgt aus:

...
 ---------------------------------------------------------------------------
 Team Id #Threads Gid Uid
 /boot/system/apps/Terminal 184 4 0 0

 Thread Id State Prio UTime KTime
 Terminal 184 wait 10 40 529 
 PtyReader 189 wait 10 1 22 
 EscParse 190 wait 15 3 11 
 w>Terminal 1 191 wait 15 154 753 
 ---------------------------------------------------------------------------
 Team Id #Threads Gid Uid
 /bin/bash --login 188 1 0 0

 Thread Id State Prio UTime KTime
 bash 188 wait 10 139 837 
 ---------------------------------------------------------------------------
 ...

Zuerst suchen wir uns aus der Liste den Namen unseres Fenster (z.B. "Terminal 1"). Fenster- Titel sind dabei immer mit "w>" am Anfang gekennzeichnet. Haben wir nun diese Zeile gefunden, lesen wir in der Liste rückwärts bis zur Zeile "Thread". Ist auch diese gefunden, steht unmittelbar in der nächsten Zeile der Name der Applikation, in diesem Fall "Terminal". Dieser muß nun noch ausgelesen werden und fertig.

Ein paar Einschränkungen gibt es bei dieser Vorgehensweise allerdings doch. Ein Programm- Name darf nicht länger als 31 Zeichen sein, da er sonst, an dieser Stelle in der Liste abgeschnitten wird, sprich, der "ps"- Befehl gibt nur die ersten 31 Zeichen eines Programm- Namens aus.

Folgende Sub- Routine übernimmt die beschrieben Arbeit und wird folgendermaßen aufgerufen, als Parameter muß der Titel des Fensters übergeben werden:

_GetApplicationFilename($FenterTitel) 

REM---------------------------------------------------------------------------------------------------
REM Autor: René Passier
REM Datum: August 2010

REM Name: _GetApplicationFilename$

REM Funktion: Ermittelt den Dateinamen des laufenden Programms durch Übergabe des Fenster- Titels.

REM Parameter: WindowTitle$

REM ----------------------------------------------------------------------------------------------------

 export sub _GetApplicationFilename$(WindowTitle$)

     REM variablen definieren
     REM ------------------------------------------------------------------------------------------------

     local SystemInput$ // speichert die Ausgabe von system$
    local NumberOfTokens // enthält die Anzahl gefilterter Zeilen aus SystemInput$
     local Counter // Hilfsvariable für die FOR- Schleifen
     local LineFound // speichert die Zeile in der der Fenster- Titel gefunden wurde
     local AppFilename$ // speichert den Datei- Name des laufenden Programms

     dim SystemLines$(1) // speichert die einzelnen, gefilterten Zeilen aus system$

     REM Liste aller Threads mit Hilfe des Befehls "ps -a " einlesen.

     REM ------------------------------------------------------------------------------------------------

     SystemInput$ = system$("ps -a")

     REM Den Inhalt aus SystemInput$ in einzelne Zeilen zerlegen (chr$(10) = Line Feed)
     REM und die Anzahl der erhaltenen Zeilen in NumberOfTokens speichern.

     REM ------------------------------------------------------------------------------------------------

     NumberOfTokens = token(SystemInput$, SystemLines$(), chr$(10))

     REM Alle, in SystemLines$() gespeicherten Zeilen nach dem Fenster- Titel durchsuchen.
     REM Vor dem Fenster- Titel muß "w>" angehängt werden, da "ps" dies so zurückliefert.

     REM ------------------------------------------------------------------------------------------------

     for Counter = 0 to NumberOfTokens

         if instr(SystemLines$(Counter), "w>" + WindowTitle$) then 

             REM Fenster- Titel gefunden
             REM ----------------------------------------------------------------------------------------

             LineFound = Counter
             break // Schleife beenden und nicht mehr weiter suchen

         endif

     next Counter


     REM Jetzt von der ermittelten Position rückwärts den Eintrag "Thread" suchen.
     REM ------------------------------------------------------------------------------------------------

     for Counter = LineFound to 0 step - 1

         if instr(SystemLines$(Counter), "Thread") then

             REM "Thread" gefunden
             REM ----------------------------------------------------------------------------------------

             AppFilename$ = SystemLines$(Counter + 1) // in der Zeile nach "Thread" steht der
                 //zu suchende Datei- Name

             AppFilename$ = left$(AppFilename$, 32) // nur die ersten 32 Zeichen lesen, da der 
                 // nicht benötigt wird und "ps" nur maximal
                 // 31 Zeichen zurückliefert

             AppFilename$ = ltrim$(AppFilename$) // alle eventuellen Leerzeichen links ent-
                // fernen

             AppFilename$ = rtrim$(AppFilename$) // alle eventuellen Leerzeichen rechts ent-
                // fernen
             break // Schleife abbrechen

         endif

     next Counter

     REM Den ermittelten Datei- Namen zurückgeben.
     REM ------------------------------------------------------------------------------------------------

     return AppFilename$

 end sub



Zusätzlich kann mit dem Beispiel "Ermittlung des Standortes Ihres Programmverzeichnisses im System", aus der "yab Programmierhilfe" noch der Pfad zur Applikation ermittelt werden. Kombiniert man Beides, bekommt man sowohl den Pfad als auch den Namen der Applikation und kann diese Informationen beliebig weiter verwenden.

zurück zur Übersicht 


 Ermittlung des Standortes Ihres Programmverzeichnisses im System

Um zu ermitteln, an welchen Standort im System der Benutzer Ihr Programm installiert hat, ermitteln wir Über den Befehl "pwd" (Print working directory) wo sich Ihr Programmordner befindet. Diesen Dateipfad speichern wir in eine Variable mit dem Namen "WorkDir$". Diese Variable lässt sich dann einfach an den Stellen einbinden, an welchen der Dateipfad zu einer Datei oder Standort wichtig ist (z.B. eine Grafik).

Fügen Sie dazu folgenden Code am Anfang Ihres Programmcodes ein:

if (peek("isbound")) then 
     WorkDir$ = peek$("directory") 
    else 
      WorkDir$ = system$("pwd") 
      WorkDir$ = left$(ThisDir$, len(ThisDir$)-1) 
fi


Beispiel zur Verwendung der Variablen.

Wir nehmen mal an Sie haben ein Verzeichnis für Grafiken in Ihrem Programmordner mit dem Namen "Grafik", aus diesem Ordner möchten Sie gerne die Grafik "Logo.png" bestimmen und anzeigen. Erstellen Sie den Code so wie sie es gewohnt sind eine Grafik einzubinden und geben Sie beim Dateipfad für die Grafik das oder die Verzeichnisse an, ausgehend von dem Programmordner, zu der anzuzeigenden Grafik. Dies wäre also "/grafik/Logo.png". Nun fügen Sie vor diesen Pfad die Variable WorkDir$ein und schreiben zwischen Variable und dem Pfad ein "+", damit der gespeicherte Pfad aus der Variablen mit dem dahinterstehenden Pfad verbunden wird.

err = draw image 90,35, WorkDir$+"/grafik/Logo.png", "MainView"

Wichtig!
Diese Angabe sollten Sie erst am Ende ihrer Arbeit an ihrem Programm einfügen, da diese nur im Gebundenen Zustand funktioniert.

zurück zur Übersicht 


  People Datei erstellen

Wie man eine People Datei über den Terminal erstellt, haben wir bereits auf der BeSly unter Sonstiges/ People Datei über Terminal erstellen beschrieben. Das erstellen einer People Datei über yab ist im Grunde genommen derselbe Vorgang, denn auch hier muss eine Datei erstellt und dann die zugehörigen Attribute vergeben werden.

Wir gehen davon aus, dass die nötigen Informationen der Person bereits in Variablen$ enthalten sind:

Name$ = Vor und Zuname der Person 
Nickname$ = Spitzname der Person 
Geburtsdatum$ = Geburtsdatum der Person 
Strasse$ = Adresse der Person 
Stadt$ = Wohnort der Person 
Bundesland$ = Bundesland in welchen die Person wohnt. 
Land$ = Das Land in welchen die Person lebt. 
Postleitzahl$ = Die Postleitzahl des Wohnortes 
Email$ = E- Mail Adresse der Person 
Telefonummer$ = Telefonnummer der Person 
Handynummer$ = Handynummer der Person 
Gruppe$ = Definition einer Kontaktgruppe (Familie, Freunde...)



Zuerst erstellen wir eine Roh- Datei, welche wir dann durch die Vergabe von Attributen zu einer People Datei umwandeln. Um der Datei den Namen der Person zu geben, definieren wir den Dateinamen mit der Variablen Name$.

anlegen=open("/boot/home/people/"+Name$, "w") 
close(anlegen)

Nun sollte eine Datei mit dem Namen Name$ in Ihrem People Verzeichnis liegen.

Als nächstes machen wir aus der Roh- Datei eine People Datei.

Output$=system$("addattr -t string BEOS:TYPE application/x-person /boot/home/people/"+"\""+Name$+"\"")

Wir verwenden das Shell Tool addattr um einen String BeOS:TYPE mit dem Mimetype application/x-person als Attribut der Datei zu definieren.

Da die Namen der People Dateien oftmals mit einem Leerzeichen versehen sind, muss der Name der Datei in Anführungszeichen gesetzt sein, dies bewirkt man in yab mit den Zeichen "\""+Dateiname$+"\"".

Jetzt besitzt die Datei in People Verzeichnis das People Symbol.

Nun müssen noch die Person- Informationen in der Datei gespeichert werden. Auch hier verwenden wir das Shell Tool addattr:

Output$=system$("addattr -t string META:name "+"\""+Name$+"\""+" /boot/home/people/"+"\""+Name$+"\"")


Im Beispiel vergeben wir den Namen der Person mit dem String META:name und dem Namen der Person in Form der dafür erstellten Variable Name$.

Lassen Sie sich jetzt nicht irritieren, weil die Variable Name$ gleich zweimal vorkommt. Einmal definieren Sie über den String META:name den Name$ der Person und dann geben Sie den Name$ der Datei an, welcher den Namen der Person trägt.


Nun folgen die anderen vorher definierten Person- Informationen, die auf dieselbe Weise der Datei zugefügt werden. Verändern Sie dazu nur die META:Angabe und die Variable für die Information.

META Angaben: 

 META:name = Name und Nachname der Person (Name$) 
 META:nickname = Spitzname der Person (Nickname$) 
 META:birthday = Geburtsdatum der Person (Geburtsdatum$) 
 META:address = Adresse der Person (Strasse$) 
 META:city = Wohnort der Person (Stadt$) 
 META:country = Bundesland in welchen die Person wohnt (Bundesland$) 
 META:state = Das Land in welchen die Person lebt (Land$) 
 META:zip = Postleitzahl des Wohnortes der Person (Postleitzahl$) 
 META:email = E- Mail Adresse der Person (Email$) 
 META:hphone = Telefonnummer der Person (Telefonummer$) 
 META:cphone = Handynummer der Person (Handynummer$) 
 META:group = Definition einer Kontaktgruppe (Familie, Freunde...) (Gruppe$)


Es gibt noch mehr Informationen, die in einer People Datei definiert werden können, dies liegt an der Software, welche diese Informationen vergibt, bzw. verwendet.

Sollte eine der Informationen, welche Sie gerne einer People Datei anfügen möchten, nicht hier beschrieben sein, öffnen Sie eine People Datei, bei der diese Information vergeben wurde mit dem Programm QuickRes (ZETA unter ZETA Menü/Entwicklung/QuickRes) und sehen nach mit welchen META:Name diese definiert wird.

QuickRes sollte auch über das rechte Maustasten Menü auswählbar sein.

zurück zur Übersicht 


 Verwenden von Shell Tools

Bei der YAB Programmierung wird für die Ausführung von Aktionen in den meisten Fällen auf die Shell Tools (Terminal Anwendungen) zurückgegriffen. Die Shell Tools liefern alle möglichen Funktionen um gewünschte Aktionen durchzuführen. Dies kann zum Beispiel das kopieren von Dateien, das ermitteln von Informationen oder das öffnen einer Datei sein. Wer also schon mal mit der Shell gearbeitet hat wird mit YAB leichter an sein Ziel kommen.

Ein Shell Programm führt man wie folgt aus:

Output$=System$("open /boot/home")


Über die YAB- internen Variablen Output$ und System$ wird der Shell Befehl open ausgeführt. Hier wird genau dieselbe Befehlsgebung verwendet wie im Terminal. Die Befehle werden in Klammern und Ausrufezeichen gesetzt.

("open /boot/home")

Es können aber nicht nur Shell Programme ausgeführt werden. Genauso gut können Sie hier zum Beispiel den Browser NetPositive mit einer speziellen Html Seite aufrufen (z.B. eine Anleitung).

Output$=System$("/boot/beos/apps/NetPositive Anleitung.html")

Sicherlich werden Sie irgendwann an den Punkt gelangen, an dem Sie eine vorher definierte Variable mit in eine Befehlskette einbinden möchten. Dies wird zum Beispiel dann der Fall sein, wenn Sie immer wiederkehrende Dateipfade angeben möchten oder zuvor ermittelte Daten mit einbringen müssen.

Dateipfad$="/boot/home/myprogram/" 

 Output$=System$("/boot/beos/apps/NetPositive "+Dateipfad$ + "Dokumentation/Anleitung.html")


In unseren Beispiel füllen wir die Variable Dateipfad$ mit dem Standort unseres Programms: /boot/home/myprogram/.

Danach wurde das Beispiel mit dem öffnen einer Html Seite mit dem NetPositve mit dieser Variablen erweitert. Hierzu wurde die Befehlskette für den Terminalbefehl unterbrochen und die Variable durch ein + eingefügt. Wichtig ist, dass die Befehlskette vor dem + Zeichen mit einem Ausrufezeichen versehen wird. Wird ein Leerzeichen benötigt, muss dieses noch vor dem Ausrufezeichen gesetzt werden. Nach dem + Zeichen folgt die Variable und dann ein weiteres + Zeichen, da die Befehlskette fortgesetzt wird (Endet die Befehlskette mit der Variablen, entfällt dieses Zeichen). Hier ist wiederum zu beachten, dass die Befehlskette nach der Variablen wieder mit einem Ausrufezeichen beginnt.

zurück zur Übersicht 


 Subroutine - Programmcodes an mehren Stellen verwenden

Mit Hilfe von Subroutinen, ist es möglich, bestimmte Programmcodes an mehreren Stellen einzubinden. Ein gutes Beispiel dafür ist das schließen von "Views". Jedes Mal wenn sie Views öffnen und dann zum Beispiel nach einer Auswahl (Button, Menü usw.) einen neuen View laden, müssen Sie den vorherigen schließen um Überlagerungen zu vermeiden. Hier kann eine Subroutine eine große Hilfe sein, denn diese können Sie vor dem öffnen eines neuen Views einbinden um alle im Programm möglichen Views zu schließen, ohne darauf achten zu müssen ob alle dort eingetragenen Views derzeit in Verwendung sind.

Eine Subroutine fügen Sie wie folgt außerhalb der Mainloop ein:

sub Name der Subroutine() 

Programmcode 

end sub


Mit sub Name der Subroutine(), erstellen Sie eine Subroutine mit einem Namen Ihrer Wahl. Dies könnte zum Beispiel RemoveViews() sein. Mit end sub beenden Sie den Subroutinenbereich. Zwischen diese beiden Befehle, schreiben Sie den Programmcode, welchen Sie durchführen möchten.

Bei dem Beispiel mit den Views würde der Programmcode dann zum Beispiel so aussehen:

sub RemoveViews() 

view remove "View1" 
view remove "View2" 
 view remove "View3" 

end sub


Nachdem Sie die Subroutine erstellt haben, müssen Sie diese noch an der Stelle im Programmcode einbinden, an welcher Sie diese ausführen möchten.

Dies erfolgt mit der einfachen Angabe der Subroutine:

Name der Subroutine()


Sie werden schnell feststellen, dass dies nicht nur eine Erleichterung beim schreiben von wiederkehrenden Abfragen oder Aktionen darstellt, sondern auch den Programmcode ordentlicher und übersichtlicher macht. Es kann auch hilfreich sein, einfach ausgeführte Aufgabenstellungen in Subroutinen zu verlagern, da so der Mainloop leichter zu überblicken ist.

zurück zur Übersicht 


  Vorhandensein eines Ordners oder Datei ermitteln

Oftmals ist es sinnvoll, das vorhanden sein eines Ordners oder einer Datei zu ermitteln, da diese für die einwandfreie Funktion der Anwendung notwendig sind. Sollte dieser wichtige Ordner oder die Datei nicht vorhanden sein, könnte man nach deren Überprüfung, diese erstellen.

Für dieses Beispiel verwenden wir die Shell Programme find und basename:

Ordnername$="MeinApp\n"
OrdnernameCheck$=system$("find /boot/apps/Programmkategorie/MeinApp\n")
OrdnernameReady$=system$("basename "+OrdnernameCheck$+"\n")


Wir erstellen eine Variable Ordnername$ mit dem Inhalt "MeinApp" (Hierbei ist es egal ob dieser Name nun ein Ordner oder eine Datei ist).

Danach erstellen wir eine Variable OrdnernameCheck$, in welcher wir die Ausgabe des Shell Programms find speichern. Der Befehl arbeitet auf eine recht einfache Weise, es werden einfach nur der Befehl und dahinter das zu findende Ziel angegeben. Sollte dieses gefunden werden, wird dieses mit dessen Programmpfad ausgegeben und in diesem Fall in der Variablen gespeichert.

Sollten Sie einen Ordner suchen, in dem andere Ordner oder Dateien liegen, müssen Sie angeben, wie tief der Befehl find suchen soll. Dazu müssen Sie den Sourcecode wie folgt anpassen: 

OrdnernameCheck$=system$ ("find /boot/apps/Programmkategorie/MeinApp\n -maxdepth 0") 

Hiermit geben Sie an das find nicht tiefer als zu dem Angegebenen Ornder suchen soll.


Da wir bei Ordnername$ nur den Namen des gesuchten Ziels angegeben haben, müssen wir noch die Ausgabe in Variable OrdnernameCheck$ so beschneiden, dass wir nur den Namen des gefundenen Ziels erhalten. Dazu verwenden wir den Shell Befehl basename.

Wir erstellen eine weitere Variable OrdnernameReady$, in welcher wir die Ausgabe des Befehls basename speichern und erhalten wenn das Ziel gefunden wurde, den gleichen Eintrag wie wir in der Variablen Ordnername$ angegeben haben.

Das ganze kann man dann wie folgt mit einer if- Abfrage überprüfen:

if(Ordnername$=OrdnernameReady$)then
         Programmablauf wird fortgesetzt
else
         Datei oder Ordner wird erstellt
 endif​

 

Die verwendeten \n sind deshalb nötig, da viele Ausgaben von Shell Programmen, einen automatischen Zeilenumbruch durchführen. Verwenden Sie also ein Shell Programm, welches bei der Ausgabe einen Zeilenumbruch durchführt, so müssen Sie diesen auch bei dem Suchnamen (Ordnername$) mit berücksichtigen.


zurück zur Übersicht 


 Vorhandensein eines Ordners oder Datei ermitteln (Variante 2)

Wer sich mal den Sourcecode der yabIDE angesehen hat, hat vielleicht schon diese Variante gesehen. Hier wird eine if Abfrage dazu verwendet, das gesuchte Objekt zu suchen und eine sub Routine dazu verwendet, über das Shell Tool test, dieses zu prüfen.

if(IfExists(filename$)) then
     print "ja existiert"
else
      print "exisitiert nicht"
 fi


Und die dazugehörige Sub Routine:

sub IfExists(filename$)
      return not system("test -e "+filename$)
 end sub


Im Grunde genommen wird das gesuchte Objekt in der Variablen filename$ gespeichert und eine Abfrage gemacht, bei der gefragt wird ob die Sub Routine IfExists() mit der dazu angegebenen, vorher definierten, Variablen filename$ möglich ist. Da beides vorhanden ist, wird die Sub Routine aufgerufen und in ihr über das Shell Tool Test geprüft ob die Angabe in der Variablen filename$ existiert.

zurück zur Übersicht 


   Import / Export verwenden

Die Import- / Export-Funktion in yab soll ihnen das Programmierleben erleichtern, indem Sie Subroutinen aus ihrem Programmcode in andere Dateien auslagern und so später besser bearbeiten können.

Importieren von Subroutinen:

import ausgelagerte_sub
    Variable=10
    Variable2=20
 ausgelagerte_sub()


Der Dateiname der zu importieren Datei muss gleich dem Dateinamen sein, d.h. die Datei für die obengenannte Subroutine muss wir folgt lauten:

ausgelagerte_sub.yab


In der Datei ausgelagerte_sub.yab können Sie jetzt die Subroutine beschreiben.

export sub ausgelagerte_sub()
    print "Hallo zusammen"
 end sub


Damit yab weiß das Sie die Subroutine exportieren und in einem anderen yab Programm importieren und ausführen möchten müssen Sie vor der Subroutine noch export, wie im obigen Beispiel, vorschreiben. Der zuvor gezeigte Quellcode gibt nach dem Import Hallo zusammen aus.
Wenn Sie jetzt Variable in der ausgelagerten Subroutine verwenden möchten, so müssen Sie die Variablen bekannt machen und aus dem Hauptprogramm übergeben. 

Hauptprogramm.yab

import ausgelagerte_sub
    Variable=10
    Variable2=20
ausgelagerte_sub(Variable, Variable2)

ausgelagerte_sub.yab

export sub ausgelagerte_sub(Variable, Variable2)
    print Variable
    print Variable2
 end sub

 


Erst jetzt kann die Subroutine mit den Variablen umgehen. Sie können jetzt Berechnungen oder sonstige Dinge mit den Variablen machen. Sie können auch in der Datei ausgelagerte_sub.yab auch noch weitere Subroutinen erstellen und verwenden. Die weiteren Subroutinen müssen dann aber von der ersten Subroutine, die Exportiert worden ist, aufgerufen werden.

zurück zur Übersicht 


 

yab Hilfestellungen by Christian Albrecht (Lelldorin) and Lorenz Glaser 2005-2017
Made available by BeSly the Haiku, BeOS and Zeta knowledge base.