80 Thumbs pro Seite.

[Marcus Vieß]

Dieses Programm soll Thumbs anzeigen.
aber nur 70 Stk. Pro Seite.
Es liest jetzt die Datei xxx aus und soll zuerste nur dir ersten 80 thumbs ausgeben.

Dann bei der übergabe cgi-bin/thumb.cgi?Index=70

Solles von 70-140 ausgeben

bei ?Index=140

140 - 210 usw.

Irgendwo ist ein fehler drin, kann mir vielleicht einer helfen ?

use CGI;

my $query = new CGI;
my $images_per_pages = 70;

&header;
open(file, "$filename");
@lines=<file>;
close(file);

my $Index = $query->param('Index');
if ($Index eq ''){$Index = 0;}

my $linecount;
my $maxcount = $query->param('Index')+ $images_per_pages;
$maxcount = $#lines if $maxcount>$#lines;

my $nextIndex = $maxcount+1;
my $prevIndex = $query->param('Index') - $images_per_pages;
$prevIndex = 0 if $prevIndex <0;

for($linecount = $query->param('Index');$linecount <$maxcount;$linecount++)
  {
  chomp $lines[$linecount];
  }
foreach $line (@lines)
  {
@fields=split(/\s*|\s*/,$line);
$thumb=$fields[5];

print <<HTMLF;
<blablabla>
HTMLF
  }
&footer;
exit;

[Cheatah]

Hi,

use CGI;

benutzt Du auch:

#!/usr/bin/perl -w
use strict;

open(file, "$filename");

perldoc perlfaq4
What's wrong with always quoting "$vars"?

@lines=<file>;

Vorher mit 'my' deklariert?

my $Index = $query->param('Index');
if ($Index eq ''){$Index = 0;}

my $index = $query->param('Index') || 0;

Lies zu Großschrift in Variablennamen bitte

perldoc perlstyle

Auch in URL-Parametern macht sich Kleinschrift irgendwie besser.

my $maxcount = $query->param('Index')+ $images_per_pages;

Auch hier mit '($query->... || 0)' einen Defaultwert zuweisen, sonst meckert strict (welches Du aus genau diesem Grund verwenden solltest).

$maxcount = $#lines if $maxcount>$#lines;

$maxcount = scalar @lines if ...

"$#array" meinst Du eigentlich gar nicht; es ist ein Index auf das letzte Element des Arrays, nicht die Anzahl der Elemente. Achte darauf, ob und wann Du anschließend "+1" hinzufügen musst.

my $linecount;

[...]

for($linecount = [...]

for (my $linecount = ...

{
  chomp $lines[$linecount];
  }

Ah. Was hälst Du von:

chomp @lines;

Also, wo jetzt der Logik-Fehler liegt, hab ich vor lauter Stil- und Syntax-Fehlern leider nicht gesehen ;-) aber was hälst Du von etwas in dieser Richtung:

foreach my $line (@lines[ (
  (($query->param('Index') || 0) < 0)
    ? 0
    : (($query->param('Index') || 0) > scalar @lines)
      ? scalar @lines
      : ($query->param('Index') || 0)
  ) .. (
  (($query->param('Index') || 0) < 0)
    ? 0
    : (($query->param('Index') || 0) > scalar @lines)
      ? scalar @lines
      : ($query->param('Index') || 0)
  ) ]) {
  print $line, "\n";
}

(ungetestet)

Wobei ich ehrlich gesagt vorziehen würde, nicht die komplette Datei einzulesen, sondern etwa wie folgt vorzugehen:

my $count = 0; # Ja, hier kann man auch $. verwenden; ich bevorzuge dies.
open(READ, $file) or die "Kann $file nicht oeffnen: $!";
while (<READ>) {
  next if (++$count < ($query->param('Index') || 0));
  end if ($count > ($query->param('Index') || 0)+$images_per_pages);
  print $_, "\n";
}
close(READ);

Achte auf die exakten Grenzen; vielleicht sind es bei diesem Code dann 69 oder 71 Bilder oder so :-)

Cheatah

[Klaus Mock]

Hallo Cheatah,

my $maxcount = $query->param('Index')+ $images_per_pages;
Auch hier mit '($query->... || 0)' einen Defaultwert zuweisen, sonst meckert strict (welches Du aus genau diesem Grund verwenden solltest).

Tja, strict meckert da eigentlich nicht, aber was soll's.

$maxcount = $#lines if $maxcount>$#lines;
"$#array" meinst Du eigentlich gar nicht; es ist ein Index auf das letzte Element des Arrays, nicht die Anzahl der Elemente. Achte darauf, ob und wann Du anschließend "+1" hinzufügen musst.

Tja, aus dem Kontext heraus kann @lines keine Lücken aufweisen, also ist $#lines vollkommen in Ordnung, wenn man nur weiß, was es bedeutet.

Also, wo jetzt der Logik-Fehler liegt, hab ich vor lauter Stil- und Syntax-Fehlern leider nicht gesehen ;-)

Stilfragen zu diskutieren ist ziemlich müßig, da sogar das von Dir so gern zitierte perlstyle eigentlich nur Empfehlungen und keine Vorschriften enthält.
Mir ist durchaus bewußt, daß eine gute und konsequente Einhaltung eines Programmierstils unerläßlich ist, aber da sollte jeder schon seinen eigenen Weg finden. Aber ich will hier nicht eine Diskussion über Sinn und Unsinn der Empfehlungen aus perlstyle anzetteln.

aber was hälst Du von etwas in dieser Richtung:
foreach my $line (@lines[ (
  (($query->param('Index') || 0) < 0)
    ? 0
    : (($query->param('Index') || 0) > scalar @lines)
      ? scalar @lines
      : ($query->param('Index') || 0)
  ) .. (
  (($query->param('Index') || 0) < 0)
    ? 0
    : (($query->param('Index') || 0) > scalar @lines)
      ? scalar @lines
      : ($query->param('Index') || 0)
  ) ]) {
  print $line, "\n";
}

(ungetestet)

und sicherlich genial, aber ich denke doch, daß selbst Du in zwei Wochen beim Anblick dieses Ungetüms kurz innehältst und Dir denkst "Was hat er damit wohl sagen wollen?"

Wobei ich ehrlich gesagt vorziehen würde, nicht die komplette Datei einzulesen, sondern etwa wie folgt vorzugehen:
my $count = 0; # Ja, hier kann man auch $. verwenden; ich bevorzuge dies.
open(READ, $file) or die "Kann $file nicht oeffnen: $!";
while (<READ>) {
  next if (++$count < ($query->param('Index') || 0));
  end if ($count > ($query->param('Index') || 0)+$images_per_pages);
  print $_, "\n";
}
close(READ);

Ich auch.

Ach ja, bevor ich es vergesse:
@Marcus:

for($linecount = $query->param('Index');$linecount <$maxcount;$linecount++)
  {
  chomp $lines[$linecount];
  }

Überleg mal welche Elemente des Array @lines hier bearbeitet werden...

foreach $line (@lines)
  {
@fields=split(/\s*|\s*/,$line);
$thumb=$fields[5];

print <<HTMLF;
<blablabla>
HTMLF
  }

...und welche hier.

und dann versuch mal (unter der Voraussetzung, die ganze Datei ist eingelesen)

for($linecount = $query->param('Index');$linecount <$maxcount;$linecount++)
  {
  chomp $lines[$linecount];

wobei mir anstelle von

my @fields=split(/\s*|\s*/,$line);
  my $thumb=$fields[5];

das hier

#  my($bla,$ble,$bli,$blo,$blu,$thumb,$wasauchimmer) = split(/\s*|\s*/,$line);

mehr zusagen würde.

print <<HTMLF;
<blablabla>
HTMLF
  }

Jetzt lehn Dich zurück und sieh Dir Zeile für Zeile des ganzen Scripts nochmals an, und versuche festzustellen, was jede einzelene Anweisung wirklich macht.
Die bei den Perl-Distributionen und Moduln beigepackte Dokumentation oder auch ein gutes Buch über Perl hilft Dir da sicherlich auch weiter.

Grüße
  Klaus

[Cheatah]

Hi,

Auch hier mit '($query->... || 0)' einen Defaultwert zuweisen, sonst meckert strict (welches Du aus genau diesem Grund verwenden solltest).
Tja, strict meckert da eigentlich nicht, aber was soll's.

vermutlich, weil Du das Script nie ohne einen sinnvollen Wert im richtigen Parameter aufgerufen hast ;-)

"$#array" meinst Du eigentlich gar nicht; [...]
Tja, aus dem Kontext heraus

_Hier_ hast Du vielleicht immer den richtigen Kontext. In einem anderen Script wurde dann aber $[ verbogen - und dann sitzt Du an dem Fehler und suchst Dich zu Tode.

Gewöhn es Dir lieber gleich richtig an. $#array kann man nicht ohne $[ gemeinsam verwenden.

[...] wenn man nur weiß, was es bedeutet.

Und hier liegt das Problem. _Du_ weißt, wie Dein Script funktioniert. Der nächste weiß es nicht.

Also, wo jetzt der Logik-Fehler liegt, hab ich vor lauter Stil- und Syntax-Fehlern leider nicht gesehen ;-)
Stilfragen zu diskutieren ist ziemlich müßig,

Richtig. Ich weise ihn auch nur darauf hin, wo er stilistisch arbeiten sollte - die eigentlichen Fehler des Scripts sind aber nicht stilistischer Natur.

da sogar das von Dir so gern zitierte perlstyle eigentlich nur Empfehlungen und keine Vorschriften enthält.

Selbstverständlich, ohne Frage. Diese Empfehlungen tragen aber auch die Bezeichnung "Konsens", und zudem sind sie nicht ohne Grund gegeben worden. Jede Empfehlung hat ihren Sinn.

aber was hälst Du von etwas in dieser Richtung:

[...]

und sicherlich genial, aber ich denke doch, daß selbst Du in zwei Wochen beim Anblick dieses Ungetüms kurz innehältst und Dir denkst "Was hat er damit wohl sagen wollen?"

Nein, eigentlich nicht. Wenn Du noch mal drauf schaust wirst Du feststellen, dass es zwar ein komplexes Konstrukt ist, aber in sich sehr einheitlich und logisch. Natürlich kannst Du z.B. durch Zuweisung von "$query->param('Index') || 0)" (oder einer anderen wiederholten Prüfung) zu einer Variablen sowohl optischen Platz als auch (geringfügig) Rechenzeit sparen; ich wollte hier aber eigentlich auch zeigen, dass man sich als (insbesondere Perl-)Programmierer nicht vor solchen Konstrukten fürchten darf - die übrigens bei vernünftiger Strukturierung[1] leichter lesbar sind, als eine Reihe einzelner Befehle.

[1] Siehe dazu übrigens auch perldoc perlstyle ;-)

Wobei ich ehrlich gesagt vorziehen würde, nicht die komplette Datei einzulesen, sondern etwa wie folgt vorzugehen:
Ich auch.

Danke :-)

Jetzt lehn Dich zurück und sieh Dir Zeile für Zeile des ganzen Scripts nochmals an, und versuche festzustellen, was jede einzelene Anweisung wirklich macht.
Die bei den Perl-Distributionen und Moduln beigepackte Dokumentation oder auch ein gutes Buch über Perl hilft Dir da sicherlich auch weiter.

Jo. Das sollte man sich ausdrucken, über den Monitor hängen und durchlesen, wenn man mal wieder nicht weiter weiß.

Cheatah

[Klaus Mock]

Hallo mnochmal,

"$#array" meinst Du eigentlich gar nicht; [...]
Tja, aus dem Kontext heraus

_Hier_ hast Du vielleicht immer den richtigen Kontext. In einem anderen Script wurde dann aber $[ verbogen - und dann sitzt Du an dem Fehler und suchst Dich zu Tode.

Gewöhn es Dir lieber gleich richtig an. $#array kann man nicht ohne $[ gemeinsam verwenden.

Hmm, mal nachdenken (soll ja nicht schaden).
Wenn ich $[ (hab ich bisher noch keine Grund gefunden, es ummodeln zu müssen) modifiziere,
dann muß ich sowieso aufpassen wie ein 'Haftelmacher', denk ich doch.
Also lass ichs lieber gleich sein;-)

Und hier liegt das Problem. _Du_ weißt, wie Dein Script funktioniert. Der nächste weiß es nicht.

Das ist auch der Grund, warum ich immer versuchen werde, meine Programme so klar, wie nur irgend geht, zu schreiben.
Wenn ich nämlich nach langer, langer Zeit wieder einen alten Source von mir zu Gesicht bekomme, dann ist das schon fast so, als ob das wer anderes geschrieben hätte, da ich ja nicht mehr so in das Thema vertieft bin, wie damals als ich mitten im Projekt war.
Ich bin ein etwas einfaches Gemüt, komplexe Dinger durchschau ich so schlecht. Bevor ich irgendeine geniale programmiertechnische Abkürzung wähle, mache ich das ganze lieber Step-by-Step.
Ich denke doch, daß der Source für Menschen geschrieben werden sollte, der Compiler, Interpreter und was auch immer ist mit bald mit dem zufrieden, was ihm so vorgesetzt wird.

Nein, eigentlich nicht. Wenn Du noch mal drauf schaust wirst Du feststellen, dass es zwar ein komplexes Konstrukt ist, aber in sich sehr einheitlich und logisch.

Genau das ist der Punkt: man muß _noch_ mal drauf schauen, um zu sehen, was da wirklich gemeint ist. Und das ist IMHO ebenso schlechter Stil wie Schreiben ohne Einrückungen, keine Unterscheidungen zwischen einem HANDLE und einer $variable.

Natürlich kannst Du z.B. durch Zuweisung von "$query->param('Index') || 0)" (oder einer anderen wiederholten Prüfung) zu einer Variablen sowohl optischen Platz als auch (geringfügig) Rechenzeit sparen;

...und IMHO auch enorm viel Zeit bei der Fehlersuche.

Jo. Das sollte man sich ausdrucken, über den Monitor hängen und durchlesen, wenn man mal wieder nicht weiter weiß.

Danke ;-)

Grüße
  Klaus

[Cheatah]

Hi,

Hmm, mal nachdenken (soll ja nicht schaden).

ja, das hab ich auch schon mal gehört :-)

Wenn ich $[ (hab ich bisher noch keine Grund gefunden, es ummodeln zu müssen) modifiziere,
dann muß ich sowieso aufpassen wie ein 'Haftelmacher', denk ich doch.
Also lass ichs lieber gleich sein;-)

_Du_ lässt es vielleicht sein. Nur: Wie viele Scripte werden in der Praxis schon von nur einer einzigen Person geschrieben?

Die Schreibweise $#array ist lediglich _zufällig_ das, was Du willst. scalar @array ist es jedoch _immer_. Warum also sich auf den Zufall verlassen?

Und hier liegt das Problem. _Du_ weißt, wie Dein Script funktioniert. Der nächste weiß es nicht.

Das ist auch der Grund, warum ich immer versuchen werde, meine Programme so klar, wie nur irgend geht, zu schreiben.

Das ist auch richtig so.

Ich bin ein etwas einfaches Gemüt, komplexe Dinger durchschau ich so schlecht.

Solche Dinge werden kommentiert. Der nächste, der Dein Script anfasst, will nicht erst jede Codezeile lesen müssen - er will schnell die richtige Stelle finden, um den Fehler (oder um was immer es sich handelt; Feature-Erweiterung z.B.) problemarm einkreisen zu können. Dazu _muss_ das Script sinnvoll kommentiert sein - nicht nur als Beschreibung weiter Blöcke, sondern auch bei optimiertem und nicht auf den ersten Blick verständlichem Code.

Bevor ich irgendeine geniale programmiertechnische Abkürzung wähle, mache ich das ganze lieber Step-by-Step.

Wenn Du Dein Leben lang nur Scripts schreibst, die unter allen Umständen in quasi nicht messbarer Zeit ablaufen, ist das okay. In der Praxis hat man es aber oft mit zeit- und ressourcenkritischen Situationen zu tun, in denen Optimierungen schlicht und ergreifend unumgänglich sind. Da ist Step-by-Step nicht drin.

Ich denke doch, daß der Source für Menschen geschrieben werden sollte,

Sourcecode ist in erster Linie dazu da, kompiliert bzw. interpretiert zu werden. Für die Menschenverständlichkeit ist _nicht_ der Code zuständig, sondern Dokumentation und Kommentierung.

der Compiler, Interpreter und was auch immer ist mit bald mit dem zufrieden, was ihm so vorgesetzt wird.

Er kann aber nicht denken. Worauf Du hinauswillst, weiß der Compiler nicht; er kann den Bytecode also nicht optimiert erstellen. Das ist _Dein_ Job.

Ansonsten wär's ja einfach und würde keinen Spaß machen :-)

Nein, eigentlich nicht. Wenn Du noch mal drauf schaust [...]

Genau das ist der Punkt: man muß _noch_ mal drauf schauen, um zu sehen, was da wirklich gemeint ist.

"# Auswahl der richtigen Array-Elemente"

Und das ist IMHO ebenso schlechter Stil wie Schreiben ohne Einrückungen, keine Unterscheidungen zwischen einem HANDLE und einer $variable.

Guter Stil darf _niemals_ auf Kosten der Performance gehen. Wo diese für einen - in Deinen Augen - schlechten Stil sorgt, sind Kommentierungen notwendig.

Schlechte Scripts zu schreiben, nur damit der Code gut aussieht, ist nämlich _ganz_ schlechter Stil.

Natürlich kannst Du z.B. durch Zuweisung von "$query->param('Index') || 0)" (oder einer anderen wiederholten Prüfung) zu einer Variablen sowohl optischen Platz als auch (geringfügig) Rechenzeit sparen;
...und IMHO auch enorm viel Zeit bei der Fehlersuche.

Zweifelsfrei.

Jo. Das sollte man sich ausdrucken, über den Monitor hängen und durchlesen, wenn man mal wieder nicht weiter weiß.
Danke ;-)

Gerne doch :-)

Cheatah