Entwicklung von HTMLBusiness-Funktionen

Allgemeine Regeln

Zur Unterstützung des Designs von HTML-Templates bei der Implementierung von Internet-Anwendungen können Sie Ihre eigenen HTMLBusiness-Funktionen schreiben, die in syntaktischer Hinsicht den Programmiersprachen ABAP oder C ähnlich sind.

Eine einfache HTMLBusiness-Funktion concatenate_string, die zwei Zeichenketten verbindet, hat beispielsweise folgende Form:

`function concatenate_string (string1,string2)
 result = string1 & string2;
 return (result);
end;`
            

Sie übergeben die beiden zu verbindenden Zeichenketten in den Parametern string1 und string2 und geben dann das Ergebnis ( result) zurück.

Sie können die Funktion concatenate_string folgendermaßen aufrufen:

...
 `write (concatenate_string("A","B"));`
...
            

Dies ergibt folgende Ausgabe: AB.

Der Vorteil der Definition von HTMLBusiness-Funktionen liegt darin, dass Sie sie beliebig oft in anderen Templates wiederverwenden können. Sie brauchen daher nicht jedes Mal den Quelltext neu zu definieren.

SAP liefert keine Standardbibliothek mit wiederverwendbaren HTMLBusiness-Funktionen aus. Es ist Aufgabe Ihres Entwicklungsteams, Funktionen zu definieren, die Ihren anwendungsspezifischen Bedürfnissen genügen.

HTMLBusiness-Funktionsdefinition

Die Funktionsdefinition gibt an:

• Den Namen der Funktion

• Die Zahl und Namen der Parameter, die die Funktion erhalten soll

• Einen Funktionsköper mit den Anweisungen, die festlegen, was die Funktion tun soll

• Einen Rückgabewert

HTMLBusiness-Funktionen müssen vor ihrem Einsatz definiert sein. Sie können eine Funktionsdefinition an einer beliebigen Stelle im Quelltext plazieren, jedoch nicht innerhalb einer anderen HTMLBusiness-Anweisung. So können Sie etwa eine Funktionsdefinition nicht in eine If-Anweisung einbinden.

HTMLBusiness-Funktionssyntax

Die Grundsyntax einer HTMLBusiness-Funktionsdefinition lautet:

function <function name> (<parameter list>)
 <function body>
 return ( <return value> );
end;
            

In der folgenden Tabelle sehen Sie alle Syntaxkomponenten:

HTMLBusiness-Funktionen aufrufen

Sie können HTMLBusiness-Funktionen als Teil einer gültigen HTMLBusiness-Anweisung aufrufen. Die Syntax ist:

`
 ...
  <function name> (<parameter expression>)
 ...
`
            

Der <Parameterausdruck> besteht aus einer Liste mit Parameternamen, die durch Kommata getrennt sind. Die Syntax für einen einzelnen Parameternamen lautet:

<parameter name>=<any valid HTMLBusiness expression>
            

Beim Aufruf einer HTMLBusiness-Funktion wird jeder Parameterausdruck geprüft, und der Ergebniswert wird der passenden Parameterkennung zugeordnet.

• Wenn Parameter mit dem Parameternamen identifiziert werden, wird der passende Parametername in der Funktionsdefinition eingesehen. Wenn kein entsprechender Name gefunden wird, tritt ein Laufzeitfehler auf.

• Wenn Parameter nicht mit dem Parameternamen identifiziert werden, werden sie als positionale Parameter betrachtet und einer nach dem anderen in die entsprechende Parameterkennung kopiert; dies geschieht durch Kopieren des nten Parameters in die nte Parameterkennung.

Sie können die Funktion concatenate_string also auf zwei verschiedene Weisen aufrufen:

• Mit Parameternamen wie in:

  concatenate_string(string1="prefix",string2="suffix") ;

• Mit positionalen Parametern wie in:

  concatenate_string("prefix","suffix") ;

Eine Funktion kann eine andere Funktion aufrufen, vorausgesetzt, die andere Funktion wurde definiert.

Im folgenden Beispiel ruft die Funktion func_1 die Funktion func_2 auf, jedoch ergibt dies einen Kompilierzeitfehler, denn die Funktion func_2 ist zum Zeitpunkt des Aufrufs nicht definiert.

`
 function func_1 (x)
  write(func_2(2*x));   <!-compile error -->
 end;

 function func_2 (y)
  write(y);
end;

 func_1(10);
`
            

HTMLBusiness-Funktionen rekursiv aufrufen

Eine HTMLBusiness-Funktion kann sich selbst aufrufen. Die folgende Beispielfunktion berechnet Fakultäten:

`
 function factorial(f,x=1)
  if (x==f)
   return (x);
  else
   return (x*factorial(f,x+1));
 end;
 end;

 repeat with i from 1 to 10;
  factorial(i);
 end;
`
            

Rückgabewerte in HTMLBusiness-Funktionen

HTMLBusiness-Funktionen können Werte an den Aufrufer zurückgeben.

Wenn die HTMLBusiness-Funktion einen Zeichenkettenwert zurückgibt, der dann in einem Ausdruck verwendet wird, der einen numerischen Wert zum Ergebnis hat, wird eine automatische Typkonvertierung durchgeführt.

Bei der folgenden Funktion dup_string, die Zeichenketten verdoppelt, sind alle unten aufgeführten Anweisungen möglich:

`
 function dup_string (s)
  return (s&s);
 end;

 dup_string("a");                    <-- outputs "aa" -->
 write(dup_string("b"));                    <-- outputs "bb" -->
 dup_string(dup _string("c")); <-- outputs "cccc" -->
 2*dup_string("1");                                       <-- outputs "22" -->
`
            

Umfang der Variablen in HTMLBusiness-Funktionen

Wenn ein Parameter einer HTMLBusiness-Funktion den gleichen Namen hat wie eine globale Variable, enthält dieser Parameter den Wert, der vom Aufrufer innerhalb der Funktion hinterlegt wurde. Der Wert der globalen Variablen wird jedoch wiederhergestellt, wenn die Verarbeitung von der Funktion an den Aufrufer zurückgeht, wie in folgendem Beispiel:

`
...
function write_numbers ( x1,x2,x3 )
 global_variable = x1;
 write("global_variable is ",global_variable,"\n");
 write("x1 is ",x1,"\n");
 write("x2 is ",x2,"\n");
 write("x3 is ",x3,"\n");
end;

global_variable = 1000;
x1 = 100;
x2 = 200;
x3 = 300;
 write("Before the call\n");
 write("global_variable is ",global_variable,"\n");
 write("x1 is ",x1,"\n");
 write("x2 is ",x2,"\n");
 write("x3 is ",x3,"\n");
 write("Calling the function . . .\n");
 write_numbers(10,20,30);
 write("After the call\n");
 write("global_variable is ",global_variable,"\n");
 write("x1 is ",x1,"\n");
 write("x2 is ",x2,"\n");
 write("x3 is ",x3,"\n");
...
`
            

Die Ausgabe sieht so aus:

Vor dem Aufruf

global_variable entspricht 1000

x1 entspricht 100

x2 entspricht 200

x3 entspricht 300

Aufruf der Funktion . .

global_variable entspricht 10

x1 entspricht 10

x2 entspricht 20

x3 entspricht 30

Nach dem Aufruf

global_variable entspricht 10

x1 entspricht 100

x2 entspricht 200

x3 entspricht 300

Standard-HTML in HTMLBusiness-Funktionen

HTMLBusiness-Funktionen können Standard-HTML-Quelltext enthalten.

Im folgenden Beispiel gibt die HTMLBusiness -Funktion write_html_text den HTML-Text <H1> This is standard HTML </H1> zehnmal im Web-Browser aus.

`
 function write_html_text() 
  ` <!--Now entering HTML mode -->
    <H1> This is standard HTML </H1>
  `end;`

`repeat with I from 1 to 10;
  write_html_text();
 end;
`
            

Feldverweise

Sie können keine Parameter an Felder über Verweise übergeben. Betrachten Sie einmal folgendes Beispiel:

`
 ...
  function dump_table(t)   
   `<TABLE>`
   repeat with i from 1 to t.dim;
    `<TR><TD>`t[i]`</TD></TR>`
   end;
   `</TABLE>`
end;

mytable[1] = "Line 1";
mytable[2] = "Line 2";
mytable[3] = "Line 3";
dump_table(mytable);
...
`
            

In diesem Fall gibt HTMLBusiness nur die erste Zeile der Tabelle aus, da mytable, als Parameter an die Funktion dump_tableübergeben, als der Wert der ersten Zeile des mehrwertigen Feldes mytable geprüft wird, der Line 1 heißt.

Um den Namen zur Laufzeit aufzulösen, müssen Sie den Namen der Variablen als Zeichenkette übergeben und den HTMLBusiness-Operator ^ verwenden, wie in folgendem Beispiel:

`
... function dump_table(t)
 `<TABLE>`
 repeat with i from 1 to ^t.dim;
  `<TR><TD>`^t[I]`</TD></TR>`
 end;
 `</TABLE>`
end;

mytable[1] = "Line 1";
mytable[2] = "Line 2";
mytable[3] = "Line 3";
dump_table(mytable); ...
`
            

Anwendungsbeispiel

Eine nützliche Anwendung besteht darin, HTMLBusiness-Funktionen zu schreiben, die HTML-Quelltexte erzeugen. Sie können beispielsweise die Funktion screenfield folgendermaßen definieren:

`
function ( ~screenfield )
 if (^~screenfield.disabled)
  <!--- Screenfield is not ready for input -->
  write(^screenfield.label);
 else
  write("<INPUT TYPE=\"");
   if (^screenfield.type=="RadioButton")
     write("RADIO\"");
     write(" NAME=\"",^screenfield.group,"\"");
     write(" VALUE=\"",^screenfield.name,"\"");
   else
    if (^screenfield.type=="CheckButton")
     html_type = "CHECKBOX";
    else
     html_type = "TEXT";
    end;
    write(html_type,"\"");
    write(" NAME=\"",^screenfield.name,"\"");
    write(" VALUE=\"",^screenfield.value,"\"");
   end;
  end;
 end;
`
            

Sie können die Funktion screenfield auf zwei verschiedene Weisen aufrufen:

• Mit Parameternamen wie in:

  screenfield (~screenfield="VBAK-VBELN");

• Mit positionalen Parametern wie in:

  screenfield ("VBAK-VBELN");

Funktionsaufrufe können Ausdrücke prüfen, daher können Sie immer schreiben:

this_field = "VBAK-VBELN";
dnprofield (this_field);
            

HTMLBusiness-Funktionen einbinden

Sie können HTMLBusiness-Funktionen in einem Template definieren und dann in jedes beliebige andere Template einfügen.

Im folgendem Fall wird davon ausgegangen, dass die Funktion screenfield im Template util.html definiert ist. Um screenfield zu verwenden, muss in einem anderen HTMLBusiness-Template util.html eingefügt sein:

`
include(~service="util",~theme="",~name="util.html");

screenfield(~screenfield="VBAK-VBELN");
screenfield(~screenfield="VBAK-BELNR");
screenfield(~screenfield="VBAK-DATUM");
`
            

Obwohl die Anweisung include den Parametern Standardwerte zuweist und keine Fehlermeldung erzeugt, wenn Parameter fehlen, müssen Sie die Parameter ~service, ~theme und ~name explizit aufführen, da der HTMLBusiness-Interpreter zwischen Kompilierzeit-Includes und Laufzeit-Includes unterscheidet.

Kompilierzeit-Includes werden immer zur Kompilierzeit des entsprechenden Templates eingefügt. Dies ist erforderlich, damit die im eingefügten Template definierten Funktionen bekannt sind.