Hallo!
Es stimmt nicht ganz, Perl ist nicht unleserlich! Ich programmiere immer mit "use strict", das entspricht in PB "EnableExplicit". Ihr seht, es wird auch an solche Sachen gedacht. Was ihr aber meint, warum Perl unleserlich sei, ist z. B. folgendes: Es ist egal ob man beispielsweise bei If-Abfragen den Operator or oder || benutzt. Ebenso gibt es drei (!) verschiedene Möglichkeiten, eine If-Abfrage zu gestalten:
Code: Alles auswählen
VARIANTE 1, normale If-Abfrage
if ($testvariable == 5)
{
print "Fünnef";
}
VARIANTE 2, nachgestellte Bedingungen
print "Fünnef" if($testvariable == 5);
VARIANTE 3, verkürzte Schreibweise (gibt's z. B. auch in JavaScript)
print $testvariable == 5 ? "Fünnef";
(In Perl gibt's natürlich auch noch ein LSE, aber das steht hier nicht zur Debatte.)
Perl ist nicht unleserlich, es beitet dem Programmierer nur verschiedene Wege, dasselbe Ziel zu erreichen. Es hängt vom Programmierer ab, ob er sauber programmiert oder schludert. Dagegen zwingen dich ja andere Programmiersprachen, wie PB, PHP oder Delphi ja zu sauberem arbeiten, weil sie keine anderen Schreibweisen dulden (lediglich indirekt, z. B. mit PB's Macros).
Weiterer Grund, warum Perl für unleserlich gehalten wird: Perl stellt dem Programmierer viele Dinge frei, was das Arbeiten mit Perl unglaublich verschönert/versüßt/wasauchimmer. So gibt es keine Unterscheidung zwischen String, Long, Quad, etc. Es gibt nur einen Variablentyp, nämlich den "Skalar", darin können Zahlen als auch Strings gespeichert werden, wobei Perl automatisch Typenkonvertierungen (Konvertieren von String nach Long und umgekehrt) vornimmt, falls nötig.
Vergleiche:
Code: Alles auswählen
PureBasic
=========
EnableExplicit
Define a=72
Define begriff.s="Jungfrauen"
Define satz.s=Str(a)+begriff ; Manuelle Typenkonvertierung
Debug satz
Perl
=========
use strict;
my $a=72;
my $begriff="Jungfrauen"
my $satz=a.begriff; # Automatische Typenkonvertierung
print satz
> Aber die von Dir erwähnte RegExp-Funktionalität wäre doch schon mal ein Anfang, oder? Im Prinzip alles, was Perl so besonders macht und was in PB nicht oder nur schwer machbar ist.
Ich dachte z. B. an Dinge wie:
- Array an Array anhängen (gibts in Perl einen direkten Befehl dafür)
- Anzahl Felder eines Array ermitteln
- Arrays/Strings anhand eines Trennzeichens aufsplitten (StringField wäre hierfür denkbar ungeeignet), diesesn Trennzeichen kann sogar ein Leerstring sein
- Assoziateive Arrays (Hashes), das sind Arrays, auf die nicht mit Zahlen (Index 0, 1, 2...) sondern mit Namen zugrgriffen wird:
Beispiele für Assoziative Arrays (gibt's in PB nicht, da müssen wir tricksen)
PureBasic:Code: Alles auswählen
Structure Bezug
Name.s
Wohnort.s
EndStructure
Dim Personen.Bezug(2)
Personen(1)\Name="Hinz"
Personen(1)\Wohnort="Norden"
Personen(2)\Name="Kunz"
Personen(2)\Wohnort="Süden"
; Hier müsste ich mittels Schleifen und Indizierungen versuchen, den Wohnort von Kunz zu kriegen
Code: Alles auswählen
my %Personen=("Hinz" => "Norden"
"Kunz" => "Süden");
print $Personen{"Hinz"} # Debuggen von Hinz' Wohnort
print $Personen{"Kunz"} # Und wo wohnt Kunz?
@ Kiffi:
Ich könnte auch mal versuchen, einen weiteren Thread zu öffnen, wo "Perl auf PB trifft", nicht umgekehrt wie hier. Sodass auch Perl'sche DInge in PB einfließen.
Noch ein Beispiel, für die Überlegenheit Perls bei der Bearbeitung von Strings/Zahlen:
Beispiel "Tausendertrennzeichen":
PureBasic (Anmerkung: Man muss "lästigerweise" die Zahlen selbst konvertieren!)
Code: Alles auswählen
Procedure.s StrLong(wert.q, tt.s = ".")
If wert > -1000 And wert < 1000 : ProcedureReturn Str(wert) : EndIf
Protected werts.s = StrQ(wert)
Protected ix.l = Len(werts)
Protected start.l
Protected ix3.l = 3
Protected rets.s
Protected sign.s
If wert < 0 : sign = "-" : start = 1 : EndIf
While ix > start
If ix3 = 0 : rets = tt + rets : ix3 = 3: EndIf
rets = Mid(werts, ix, 1) + rets
ix - 1 : ix3 - 1
Wend
ProcedureReturn sign + rets
EndProcedure
Debug StrLong(12345678) ; Code von jear
(hier entfällt die Typenkonvertierung
)
Code: Alles auswählen
sub StrLong
{
my $result=reverse(shift);
my $trennzeichen=shift || ' ';
$result =~ s/(.{3})/$1$trennzeichen/g;
return reverse($result);
}
print StrLong(12345678) # Code von AND51
Arbeitesweise: Das in PB sieht ja jeder, wie das funktioniert. Nun zu Perl: In $result wird der 1. Parameter (die zu trennende Zahl) gespeichert, dabei aber verdreht (bidirektional notiert => 87654321).
Danach wird in der Variablen $tausendertrennzeichen der 2. Parameter gespeichert, und falls es den nicht gibt, wird stattdessen ein Leerzeichen genommen (dies ist wie in PB ein optionaler Parameter).
Danach erfolgt die Anwendung eines
Regulären Ausdrucks (Kiffi, aufpassen!), hier werden jeweils drei Zeichen durch die drei Zeichen plus den Trenner ersetzt, wie erhalten also folgendes Ergebnis:
876.543.21
Dann geben wir das Ergebnis zurück, natürlich nochmals verdreht. Negative Zahlen? Brauchte ich für meine Homepage nicht, ließe sich aber leicht ergänzen.
Dies ist nur ein Musterbeispiel (PB: 14 Zeilen, Perl: 4 Zeilen). Aber genau dieses Musterbeispiel spiegelt meine Meinung wieder, warum Perl hinsichtlich der Bearbeitung von Strings PureBasic um Längen schlägt. (Nein, dieser Satz wurde nicht mit Perl erstellt!
).
Musterbeispiel 2: Erstellen eines Strings mit wiederkehrenden Zeichen:
PureBasic
Code: Alles auswählen
Debug ReplaceString(Space(100), " ", "Ich darf im Klassenraum nicht mit Papier werfen")
Code: Alles auswählen
print "Ich darf im Klassenraum nicht mit Papier werden" x100;
Hier sieht man die Einfachheit gegen über PB, den Stringmultiplikator.
" " x255;
funktioniert genauso wie
Space(255)
nur eben, dass man nicht nur Leerzeichen, sondern alle Möglichen (auch "merhzeichige") Strings nehmen kann.
Zum Schluss: Nicht das ihr denkt, ich will PureBasic bloßstellen und finde Perl viel besser. Natürlich werde ich bei PureBasic bleiben und euch auch in Zukunft noch in diesem Forum auf den Senkel gehen.
Ich dachte mir lediglich, man könne die Einfachheit von PureBasic mit der Kraft von Perl verbinden.
