Thread Zwei Zeichen _gleichzeitig_ in String finden (19 answers)
Opened by geloescht at 2012-06-20 18:13

topeg
 2012-06-20 22:00
#159258 #159258
User since
2006-07-10
2611 Artikel
BenutzerIn

user image
Ich vermute du hast etwas Erfahrung in BASIC.

Dort gibt es den Befehl GOSUB.
Falls du das nicht kennst der funktioniert wie GOTO mit dem unterschied das bei einem RETURN an die Stelle zurück gesprungen wird wo das GOSUB war.

Um es in etwas Pseudocode auszudrücken:
Code: (dl )
1
2
3
4
5
6
7
8
GOTO ANKER_SUB
ANKER_BACK:

...

ANKER_SUB:
...
GOTO ANKER_BACK

GOSUB verkürzt das:
Code: (dl )
1
2
3
4
5
6
7
GOSUB ANKER_SUB

...

ANKER_SUB:
...
RETURN


Wohin will ich damit.

Funktionen oder "SubCode" funktioniert ganz ähnlich. Du definierst eine Schlüsselwort und packst dahinter etwas Code der angesprungen werden soll, wenn dieses Schlüsselwort auftaucht. Wenn der CodeBlock ausgeführt wurde kehrt das Programm an die Stelle zurück an der die Funktion aufgerufen wurde.
Der Schlüssel um ein Stück Subcode zu definieren lautet sub gefolgt vom Schlüssewort und einem Codeblock ({ ... }).

Code (perl): (dl )
1
2
3
4
5
6
7
8

hallo();

#...

sub hallo
{
  print "hallo\n";
}

das ist ganz ähnlich zu:
Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10

goto hallo;
BACK:

#...

hallo: do
{
  print "hallo\n";
  goto BACK;
}


Funktionen machen das doch übersichtlicher, oder?
Aber natürlich gibt es Unterschiede. Der Code innerhalb einer Funktion wird nur ausgeführt wenn die Funktion angesprungen wird. Funktionen kann man an mehreren Stellen nutzen und Perl kehrt immer an die richtige zurück.

Meist übergibt man Werte an Subcode, die verarbeitet werden sollen und das Ergebnis soll wider wo anders Verwendung finden.
Bei GOTO oder GOSUB macht man das Über globale Variablen. Man definiert z.B ein Array "funktions_werte" und packt da alles rein was man in einem Stück Subcode haben will. Ein anderes Array "funktion_returns" nutzt man um Werte an den Ort des Aufrufs zurück zu geben. Als Code:

Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

my @funktions_werte;
my @funktion_returns;

#...

@funktions_werte=('Etwas text',2);
goto ausgabe;
ausgabe_return:
if($funktion_returns[0] == 1)
{
  print "Erfolgreich\n";
}
else
{
  print "FEHLER\n";
}

#...

ausgabe: do
{
  my $text=$funktions_werte[0];
  my $wiederholungen=$funktions_werte[1];
  my $ok=0;
  for(my $i=0; $i<$wiederholungen; $i++)
  {
    print "$i : $text\n";
    $ok++;
  }
  @funktion_returns=($ok);
  goto ausgabe_return;
}


Das ist eine Menge Tipperei und zudem kann dabei einiges Schief gehen. Was ist wenn man vergisst die Arrays zu leeren, wenn man einen neuen Codeblock anspringt.
Aber es gibt noch eine Interessante Frage. Wie kann man den Code an mehreren Stellen nutzen?
Man könnte mit übergeben wohin zurück gesprungen werden soll:
Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39

my @funktions_werte;
my @funktion_returns;
my $return_to;

#...

$return_to='ausgabe_return1';
@funktions_werte=('Etwas text',2);
goto ausgabe;
ausgabe_return1:
if($funktion_returns[0])
{
  print "Erfolgreich\n";
}
else
{
  print "FEHLER\n";
}

$return_to='ausgabe_return2';
@funktions_werte=('Anderer Text',1);
goto ausgabe;
ausgabe_return2:

#...

ausgabe: do
{
  my $text=$funktions_werte[0];
  my $wiederholungen=$funktions_werte[1];
  my $ok=0;
  for(my $i=0; $i<$wiederholungen; $i++)
  {
    print "$i : $text\n";
    $ok++;
  }
  @funktion_returns=($ok);
  goto $return_to;
}


Aber auch hier. Wie verhindert man Fehler? Man Muss immer drei Variablen im Auge behalten.
Perl nimmt einem mit Funktionen die ganze Arbeit ab. Der Befehl return erlaubt es Werte an die Stelle zurück zu geben, an der die Funktion aufgerufen wurde. Das in Perl vordefinierte Array @_ nimmt die Werte auf die an eine Funktion übergeben werden sollen. Dazu braucht man die Werte nur in einer Klammer hinter den Namen der Funktion zu schreiben. Es wird immer Passend gefüllt und gelehrt.

Also nun das selbe wie oben. Nur diesmal mit einer Funktion:
Code (perl): (dl )
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27

#...

my @funktion_returns = ausgabe ('Etwas text',2);
if($funktion_returns[0])
{
  print "Erfolgreich\n";
}
else
{
  print "FEHLER\n";
}

ausgabe('Anderer Text',1);
#...

sub ausgabe
{
  my $text=$_[0];
  my $wiederholungen=$_[1];
  my $ok=0;
  for(my $i=0; $i<$wiederholungen; $i++)
  {
    print "$i : $text\n";
    $ok++;
  }
  return ($ok);
}

Und wieder hat man sich viel Tipperei und Fehlerquellen gespart.

Wie du siehst sind Funktionen nicht schwer zu verstehen, sie sind Abkürzungen für das was du schon machst. Funktionen können noch mehr aber das sollte für den Anfang reichen.

View full thread Zwei Zeichen _gleichzeitig_ in String finden