Eigene Funktion erstellen

[-lx-]

Hallo.

Und zwar bin ich gerade dran mir eien kleinen eigenen HTML Konvertierer zu bastlen.

Also ich gebe eien Text ein und dann wird mir der konvertierte Tet inklusive Quellcode usw. ausgegeben.

Soweit sogut. Jedoch würde ich gerne die Eingabe, die später innerhalb des bodys stehen und im Titel der Seite, überprüfen lassen, ob sie Umlaute oder SOnderzeichen enthalten und die dann gegebenfals umwandeln.

Code:

laenge:= Length(MText.Text);
Satz:='' ;
For i:= 1 To laenge Do
  begin
    Buchstabe:= ord(MText.Text[i]);
    Case Buchstabe of
      228: Satz:= Satz + 'ä' ;
      196: Satz:= Satz + 'Ä' ;
      246: Satz:= Satz + 'ö' ;
      214: Satz:= Satz + 'Ö' ;
      252: Satz:= Satz + 'ü' ;
      220: Satz:= Satz + 'Ü' ;
      223: Satz:= Satz + 'ß' ;
       10: Satz:= Satz + '
' + chr(10) ;
       13: Satz:= Satz + '' ;
      Else Satz:= Satz + chr(Buchstabe);
    end;

so, dies wäre der Teil, indme die Eingaben überprüft werden. Jedoch würde ich gerne auch den Titel überprüfen lassen und da müsste ich ja das Gleiche nocheinmal schreiben.

Gibt es die Möglichkeit diesen ganzen oberen Ablauf/Folge mit Hilfe einer "Funktionsvariable" aufzurufen?

also z.b. " umlaut('hier stäht jedä mänge täxtä') "

Die obere Folge heißt theoretisch "umlaut" -Funktion und der nachfolgende Text wird mit Hilfe dieser Funktion auf UMlaute überprüft.

Ich hoffe ich konnte euch in Etwa erklären, was ich meine.

Ich möchte Quasi nicht nocheinmal das Gleiche schreiben, um andere Variablen auf ihren Inhalt zu überprüfen.



mfg
Cya

[ichbins]

Eigene Funktionen gehen so schreiben:

Delphi-Quellcode:

[...]

//oben im Interface-Abschnitt den Funktionskopf aufschreiben
function myfunction(parameter1:integer;parameter2:string;parameter3:trect):zurueckgegebenertyp;

implementation

[...]

//hier ausformulieren
function myfunction(parameter1:integer;parameter2:string;parameter3:trect):zurueckgegebenertyp;
begin
  result:=parameter1;   //result=Ergebniss
end;

Prozeduren funktionieren genauso, nur dass sie keinen Wert zurückgeben.

[-lx-]

Hallo und danke schoneinmal.

Abe rleider versteh ich da snicht so ganz.

Erstmal gibt e seine Unterschied zwischen Prpzeduren und Funktione ? Wenn ja welcher ist das denn ??

Oder kann ich auch einzelen Prozeduren ansprechen und dort meine Texte überprüfen lassen ?



mfg
Cya

[Die Muhkuh]

Hi,

der Unterschied zur Procedure und Funktion ist, dass eine Funktion ein Rückgabewert hat:

Delphi-Quellcode:

function Addiere(Zahl1, Zahl2: Integer): Integer;
begin
  Result := Zahl1 + Zahl2;
end;

[ichbins]

Eine Funktion ist soetwas wie eine erweiterte Prozedur, die einen Wert zurückgeben kann, so wie z.B. inttostr, das sieht inetwa so aus:

Delphi-Quellcode:

function inttostr(i:integer):string; //Funktion mit Namen inttostr, die als Parameter einen Integerwert hat und einen String zurückgibt
begin
  str(i,result); 
end;

diese Funktion inttostr kannst du dann ja so aufrufen:

Delphi-Quellcode:

var
  i:integer;
begin
  s:=inttostr(i);

wobei s dann den von inttostr zurückgelieferten String enthält.

Eine Textprüffunktion, die ggf. vorhandene Umlaute in einzelne Buchstaben verwandelt sieht dann so aus:

Delphi-Quellcode:

function texttest(text:string):string;
var
  i:integer;
begin
  result:='';  //Ergebniss der Funktion auf '' setzen
  for i:=1 to length(text) do
    case text[i] of
      'ä': result:=result+'ae';
      'ö': result:=result+'oe';
      'ü': result:=result+'ue';
      'Ä': result:=result+'AE';
      'Ö': result:=result+'OE';
      'Ü': result:=result+'UE';
      'ß': result:=result+'ss';
    end else
      result:=result+text[i];
end;

und wird so aufgerufen:

Delphi-Quellcode:

var
  text:string;
begin
  text:='äößüabc'
  text:=texttest(text);

[-lx-]

Ist nun schon was klarer

Delphi-Quellcode:

function konvert(Text:string):string;
var laenge, i, Buchstabe :Integer ;

begin

laenge:= Length(Text);
Satz:='' ;
For i:= 1 To laenge Do
  begin
    Buchstabe:= ord(Text[i]);
    Case Buchstabe of
      228: Satz:= Satz + 'ä' ;
      196: Satz:= Satz + 'Ä' ;
      246: Satz:= Satz + 'ö' ;
      214: Satz:= Satz + 'Ö' ;
      252: Satz:= Satz + 'ü' ;
      220: Satz:= Satz + 'Ü' ;
      223: Satz:= Satz + 'ß' ;
       13: Satz:= Satz + chr(13) + chr(10) + '<br' ;
       10: Satz:= Satz + '>' + chr(13) + chr(10);
      Else Satz:= Satz + chr(Buchstabe);
    end;
  end;

end;


procedure TForm1.SpeedButton3Click(Sender: TObject);
begin

Satz:= konvert(Satz);



MHTML.Clear ;
MHTML.Lines.Add('<html>');
MHTML.Lines.Add('<head>');
MHTML.Lines.Add('<title>  </title>');
MHTML.Lines.Add('</head>');
MHTML.Lines.Add('<body>');
MHTML.Lines.Add( Satz ) ;
MHTML.Lines.Add('</body>');
MHTML.Lines.Add('</html>');




end;

Was ist nun daran falsch? Es muss ein problem mit der funktion geben.

Die Variable "Satz" ist eine globale String-Variable!


mfg
Cya

[ichbins]

den zurückgelieferten Wert in der Funktion kannst du mit RESULT ansprechen. Also in der Funktion SATZ durch RESULT ersetzten.

[-lx-]

Dankeschön!

Also nochmal zusammenfassen:

Den Wert, den man aus einer Funktion übernehemen will, MUSS der Variablen RESULT zugeordnet werden.

Aber wie ist es, wenn man z.B. 2 verschiedene Werte erwartet ?





mfg
Cya

[3_of_8]

Das ist nur über ein Array oder einen Record möglich.

Oder aber über var.

Delphi-Quellcode:

procedure Bla(var a, b: Integer; c: Integer);
begin
a:=c-1;
b:=c+1;
end;

var bedeutet nichts anderes, als dass die Variable, die du übergibst, direkt verändert wird.

[Corelgott]

ehh leute...?

wenn ich dich richtig verstehe willst du doch nen ganzen satz überprüfen:

Also aus

s := 'Heute ist ein schöner Tag!'; soll dannn

s2 := 'Heute ist ein schöer Tag!' werden?
Wenn ja:

dann musst du ja auf jeden fall das teil einmal für jeden Buchstaben & für jedes zu erstzende Zeichen druchgehen:

ok dann man ein bissel code

Delphi-Quellcode:

(*
  angenommen hier steht der ganze krams von der Form der dann irgendwann mal mit

  end; endet ^^
*)

// da machen wir uns mal nen eigenen kleinen verbund typ...
// ist so als wenn man ein paar variablen mit "klebeband" zu einem neuen namen "zusammenklebt"
// der name hier ist einfach mal replace... kannst du aber nennen wie du willst

type replace = record
  was   : String;        // ok wir müssen uns ja auf jeden fall merken, was wir erstzen wollen
  durch : String;        // und klar... natürlich auch wodurch
end;

var
  liste : Array[0..2] of replace; // so da gibts ja bestimmt nicht nur eine sache, die wir erstzen wollen
                                  // also nicht nur ä sondern auch z.B. ö
                                  // die liste ist erst mal auf max. 3 -> (0, 1, 2) einträge ausgelegt
                                  // wenn du mehr brauchst einfach die "hinter" zahl erhöhen (die obere grenze)
  Form1: TForm1;
 
implementation

{$R *.dfm}

procedure TForm1.FormCreate(Sender: TObject); // so wenn das "formular gemacht" wird
begin
  liste[0].was   := 'ä';         // soll er sich merken, dass im ersten (ACHTUNG 0 ist der erste!) das ä steht
  liste[0].durch := 'ä';    // dass soll dann durch ein "ä" ausgetauscht werden

  liste[1].was   := 'ü';         // das zweite in der liste (ACHTUNG index = 1!)
  liste[1].durch := 'ü';    // usw. sollte einigermaßen selbst erklärend sein

  liste[2].was   := 'ö';
  liste[2].durch := 'ö';
end;

(* 
unsere funktion heisst einmalAllesBitte
bekommt einen String der "aufgeräumt" werden soll
und soll uns einen "sauberen" string zurückgeben //seltsame formulierung ^^

diese eigene funktion gehört zum objekt TForm1 (deswegen steht das auch davor)
   die musst du oben auch nochmal eintragen!
   
    da solte dann so was stehen

    private
      function einmalAllesBitte(str: String): String;
      { Private declarations }
    public

    und jupp da lässt man das Obj wieder weg... weil das ja schon in "seinem bereich" steht
*)

function TForm1.einmalAllesBitte(str : String) : String; // so nun kommt der "dicke brocken"
var // so in unser schönen funktion gibt es eigene nur hier gültige variablen
  i   : Integer; // eine zahl zum druchlaufen der liste
  res : String;  // und das ergebnis, zwischengelagert in res

begin
  res := str; // so erst mal merken wir uns das ungewaschene in res

  for i := 0 to length(liste) - 1 do // dann gehen wir jedes zu erstzende einzelteil in der liste durch
    res := StringReplace(res, liste[i].was, liste[i].durch, [rfReplaceAll]);
(*
    res := "..." ok im resultat soll das gewaschene sein
    und zwar das, was die funktion StringReplace zurück gibt (das ist ein delphi hausmittel)
    was bekommt die StringReplace eigentlich?
    ok klar 1. worin sie was erstzen soll
    2. was ersetzt werden soll
    3. wodurch das gefundene ersetzt werden soll
    4. ein Schalter (Flag) der den modus einstellt; in dem fall soll es alle vorkommnisse erstzten
       (kann auch noch anders geschaltet werden aber das wäre jetzt zu viel des guten!)

   so das läuft jetzt ja alle durch...
*)
  result := res; // so wenn wir fertig sind... dann kann man das auch wieder zurückgeben
end;

so...

benutztung ist dann wie folgt

ergebnis := einmalAllesBitte('Der super gemeine text, der so umlaute oder so enthält... oder auch nicht...');

hat den großen vorteil, dass du das nicht alles buchstabe weise durchlaufen musst...
und dass es recht gut zu verwalten ist...
Und kurz ist es auch noch ^^

hoffe ich konnte helfen und habe dich nicht zu sehr erschlagen

cya
Corelgott

[edit]
aso:
der code ist nicht getestet... der ist einfach mal so frei schnautze...
also bugs behalet ich mir mal vor...

[/edit]