Also nicht vergessen Treffpunkt nicht im Heidehof sondern im LEU. Bis Samstag dann....
]]>Also, auf ein neues.
Heute gehts weiter mit dem Programmieren in Perl. Dazu ist es ganz nützlich, sich noch mit dem Editor VIM auszukennen, mit dem wir uns ja bereits beschäftigt haben.
Um die Programme auszuführen, speichert man sie in eine Datei, z. B. mein_skript.pl, und führt sie dann mit dem Kommando perl mein_skript.pl aus.
(Der Dateiname muss auf der Konsole angegeben werden.)
#!/usr/bin/perl
use strict;
# Dateiname einlesen
my $fn = Größerzeichen STDIN Kleinerzeichen;
chomp($fn);
# Datei oeffnen
open TMP, "< s1.pl";
# Datei einlesen
my $r = Größerzeichen TMP Kleinerzeichen;
# Datei wieder schliessen
close(TMP);
# Eingelese Daten ausgeben
print "$r";
#!/usr/bin/perl
use strict;
# Dateiname einlesen
my $fn = Größerzeichen STDIN Kleinerzeichen;
chomp($fn);
# Datei oeffnen
open SRC, "< $fn";
# Zeilen in ein array einlesen
my @lines = Größerzeichen SRC Kleinerzeichen;
# Datei schliessen
close(SRC);
# Zeilen ausgeben
print @lines;
Die Datei wird in ein sog. array eingelesen. Ein array kann man sich wie folgt vorstellen:
@mein_array:
$mein_array[0]
$mein_array[1]
$mein_array[2]
...
$mein_array[n]
Ein Array ist also eine Liste von Variablen; auf die einzelnen Variablen der Liste kann man über die Nummerierung zugreifen.
#!/usr/bin/perl
use strict;
# Dateiname einlesen
my $fn = Größerzeichen STDIN Kleinerzeichen;
chomp($fn);
# Zeilennummer einlesen
my $lineno =
chomp($lineno);
# Datei oeffnen
open SRC, "< $fn";
# Zeilen in ein array einlesen
my @lines = Größerzeichen SRC Kleinerzeichen;
# Datei schliessen
close(SRC);
# Angefordertes Element des Arrays ausgeben
print $lines[$lineno];
#!/usr/bin/perl
use strict;
# Dateiname einlesen
my $fn = Größerzeichen STDIN Kleinerzeichen;
chomp($fn);
# Zeilennummer einlesen
my $lineno =
chomp($lineno);
# Datei oeffnen
open SRC, "< $fn";
# Zeilen in ein array einlesen
my @lines = Größerzeichen SRC Kleinerzeichen;
# Datei schliessen
close(SRC);
# Angefordertes Element des Arrays aendern
$lines[$lineno] = "Ein wenig Schachsinn am Samstag morgen =)\n";
# Geaendertes Array ausgeben
print @lines
Dieses Programm zeichnet sich dadurch aus, dass es dem Benutzer nun auch sagt, was er denn bitte eingeben soll :) (printf vor den Zeilen mit Größerzeichen STDIN Kleinerzeichen)
#!/usr/bin/perl
use strict;
# Dateiname einlesen
printf "Dateiname der Quelldatei eingeben: ";
my $fn = Größerzeichen STDIN Kleinerzeichen;
chomp($fn);
# Zeilennummer einlesen
printf "Nummer der Zeile, die geaendert werden soll, eingeben: ";
my $lineno = Größerzeichen STDIN Kleinerzeichen;
chomp($lineno);
# Zieldateiname einlesen
printf "Dateiname der Zieldatei eingeben: ";
my $target_fn = Größerzeichen STDIN Kleinerzeichen;
chomp($lineno);
# Datei oeffnen
open SRC, "< $fn";
# Zeilen in ein array einlesen
my @lines = Größerzeichen SRC Kleinerzeichen;
# Datei schliessen
close(SRC);
# Angefordertes Element des Arrays aendern
$lines[$lineno] = "Ein wenig Schachsinn am Samstag morgen =)\n";
# Geaenderte Daten in neuer Datei speichern
# Datei oeffnen
open DST, "> $target_fn";
# Inhalt in Datei speichern
print DST @lines;
# Datei wieder schliessen
close(DST);
Schreibt man statt open DST, "> $target_fn"; open DST, ">> $target_fn";, wird der neue Inhalt an das Ende der Datei angehängt, wenn die Datei schon existiert. (Mit einer spitzen Klammer wird eine evtl. existierende Datei überschrieben.)
#!/usr/bin/perl
use strict;
print "Zahl eingeben: ";
my $number = Größerzeichen STDIN Kleinerzeichen;
chomp($number);
if ($number < 0) {
print "Die Zahl ist kleiner als 0.\n";
}
elsif ($number > 0) {
print "Die Zahl ist groesser als 0.\n";
}
else {
print "Die Zahl ist 0.\n";
}
Wenn die Bedinung in Klammern ($number < 0) wahr ist, wird der Code in den gescheiften Klammern (print "Die Zahl ist kleiner als 0.\n";) ausgeführt.
Ist die erste Bedinung nicht erfüllt (und nur dann), wird die Bedinung bei elsif überprüft und ggf. der dazugehörige Code ausgeführt. Es ist möglich, vor dem else-Teil eine weitere elsif-Bedingung zu notieren. Diese wird dann nur überprüft und ggf. ausgeführt, wenn sowohl die Bedinung bei if als auch die Bedingungen bei allen vorangehenden elsif nicht zutreffen.
Ist keine der Bedinungen erfüllt, wird schließlich der Code bei else ausgeführt.
Es ist auch möglich, die elsif- oder else-Teile wegzulassen. Beispiel:
if ($number < 0) {
print "Die Zahl ist kleiner als 0.\n";
}
elsif ($number == 1) {
print "Die Zahl ist 1.\n";
}
elsif ($number > 0) {
print "Die Zahl ist groesser als 0, aber nicht 1.\n";
}
if ($number < 0) {
print "Die Zahl ist kleiner als 0.\n";
}
else {
print "Die Zahl ist 0 oder groesser als 0.\n";
}
In den genannten if-Bedingungen (und an allen anderen Orten, wo Bedinungen verwendet werden, z. B. bei Schleifen) lassen sich u. a. die folgenden Operatoren verwenden:
Methode Operatoren Alternativer Operator
gleich == eq (für equal)
ungleich != neq (für not equal)
kleiner < lt (für lower than)
größer > gt (für greater than)
kleinergleich <= le (für lower or equal)
größergleich >= ge (für greater or equal)
Methode Operatoren Alternativer Operator
und && and
oder || or
Beispiel:
...
# "Wenn $number1 gleich 4 und $number groessergleich 7
if (($number1 eq 4) and ($number2 >= 7)) {
...
}
...
#!usr/bin/perl
use strict;
#Wir lesen Dateiinhalte in Arrays ein.
print "Bitte Dateinamen angeben:\n";
my $Dateiname = Größerzeichen STDIN Kleinerzeichen;
chomp($Dateiname);
open TEMP, "< $Dateiname";
my @ErstesArray = Größerzeichen TEMP Kleinerzeichen;
close(TEMP);
print @ErstesArray;
#Wir geben nun eine spezielle Zeile des Arrays aus
my $Zeilennummer = Größerzeichen STDIN Kleinerzeichen;
chomp($Zeilennummer);
print "In Zeile $Zeilennummer stand:\n";
print "$ErstesArray[$Zeilennummer]\n";
#Wir aendern nun den Inhalt von $Zeilennummer
$ErstesArray[$Zeilennummer] = "Das hier ist die geänderte Zeile mit wirrem Text.\n";
print @ErstesArray;
#Geänderte eingelesene Datei zurück in eine neue Datei schreiben
print "Bitte neuen Dateinnamen angeben:\n";
my $neueDatei = Größerzeichen STDIN Kleinerzeichen;
chomp($neueDatei);
open TEMP2, ">> $neueDatei";
print TEMP2 @ErstesArray;
close(TEMP2);
#!usr/bin/perl
#Die If-Elsif-Else-Anweisung
print "Bitte eine Zahl angeben:\n";
$zahl1 = Größerzeichen STDIN Kleinerzeichen;
chomp($zahl1);
if ($zahl1 == 5) {
print "Die Zahl war tatsächlich 5!\n";
# } elsif ($zahl1 < 5) {
# print "Die Zahl ist kleiner als 5.\n";
} elsif (($zahl1 > 5) and ($zahl1 != 666)) {
print "Die Zahl ist größer als 5.\n";
} elsif ($zahl1 == 666) {
print "Du bist mit dem Teufel im Bunde.\n";
} else {
print "Du bist noch nicht wach. Weiter probieren!\n";
}
Das ist hier ist die Testdatei
Zeile 2.
Zeile 3.
Zeile 4.
Zeile 5.
Zeile 6.
Schon wieder Zeile 6.
Zeile wird noch gefertigt.
Zeile neuneinhalb.
Eigentlich die 10.
Warum perl?
Zum testen eines Programmes ist kein vorkompilieren nötig. Dies erleichtert
die Fehlersuche enorm, da der Interpreter seine Fehlerausgaben auf den
geschriebenen Perlcode bezieht (beispielsweise mit Zeilenangaben).
Perlcode ist im allgemeinen sehr kompakt.
Perl ist weit verbreitet.
Hallo Welt!
#!/usr/bin/perl
# mein erstes Perlprogramm <- dies ist ein Kommentar! (wird ignoriert)
# ein Semikolon schliesst eine Zeile (ein Befehl) ab.
# ein \n geht in eine neue Zeile
print "Abrakadabra, jetzt wird gerechnet!\n";
# das $-Zeichen leitet eine Variable ein
$zahl1 = 2;
$zahl2 = 5;
$summe = $zahl1 + $zahl2;
$produkt = $zahl1 * $zahl2;
$differenz = $zahl1 - $zahl2;
$quotient = $zahl1 / $zahl2;
# jetzt wollen wir unsere Zahlen auch sehen!
# eine Variable wird innerhalb von "" als solche erkannt
print "Die Summe von $zahl1 und $zahl2 ist $summe\n";
print "Das Produkt von $zahl1 und $zahl2 ist $produkt\n";
print "Die Differenz von $zahl1 und $zahl2 ist $differenz\n";
print "Der Quotient von $zahl1 und $zahl2 ist $quotient\n";
# Variablen koennen verschiedene Dinge, egal ob Zahlen (Gleitkomma und ganze Zahlen, Text oder andere Werte)beinhalten
$string = "Geld ist schoen, wenn man's hat, deshalb lernen wir Programmieren!";
# Das ist ein String
$integer = 3; # Das ist eine ganze Zahl
$float = 2.554; # Das ist eine rationale Zahl
print "Geld ist schoen, wenn man's hat, deshalb lernen wir Programmieren!\n";
#ist das gleiche wie
print "$string\n"; #oder mit
$string = "$string\n"; # Wahnsinn!!!
print $string;
# Jetzt wollen wir noch die Werte fuer die Variablen einlesen
# (duch eingabe oder textfile)
print "Abrakadabra, jetzt wirds interaktiv!\n";
# Tastatureingabe ueber STDIN (Standard-In) (im normalfall Tastatur)
print "Bitte Dateiname eingeben!\n";
$eingabe = Görßerzeichen STDIN Kleinerzeichen;
# ueberfluessiges \n entfernen! (sonst gibts ueberfluessige Leerzeilen)
chomp( $eingabe );
print "Ihre Eingabe $eingabe war richtig!\n";
# Einlesen von Daten aus einer anderen Datei
open TEMP, "< $eingabe";
$ausDatei = Görßerzeichen TEMP Kleinerzeichen;
close TEMP;
chomp( $ausDatei );
print "Dieser Text stand in einer Datei: $ausDatei\n";
Es ist bei jedem Programm zu empfehlen die "use strict"-Direktive
zu verwenden, um fehlerträchtigen Code zu vermeiden.
So werden beispielsweise private Variablen vorgeschrieben.
Diese werden mit eine einleitenden "my" vor der Variablendeklaration
gekennzeichnet.
Viel Perlcode und Module (wird später erklärt) gibt es im Internet
im CPAN (Comprehensive Perl Archive Network, http://cpan.org/).
Code von mir, falls euch der von Martin nicht gefällt:
#!/usr/bin/perl
# Mein 1. Perl-Programm
print "Das unser erstes Perl-Programm. Wir lieben alle die Informatik-AG.\n";
# Wir rechnen ein bißchen
$zahl1=2;
$zahl2=5;
$neuezahl3= $zahl1 + $zahl2;
$neuezahl4= $zahl1 * $zahl2;
$neuezahl5= $zahl1 - $zahl2;
$neuezahl6= $zahl1 / $zahl2;
print "Das sind unserer errechneten Zahlen: $neuezahl3, $neuezahl4, $neuezahl5, $neuezahl6.\n";
# Text in einer Variablen
$textinvar= "Geld ist schön wenn man's hat, deshalb lernen wir Programmieren.\n";
print "$textinvar";
# Tastatureingaben über Standard-In lesen.
$frieingelestext= Görßerzeichen STDIN Kleinerzeichen;
chomp($frieingelestext);
print "Ihre Eingabe war: $frieingelestext\n";
# Einlesen aus von Daten aus einer anderen Datei
open TEMP, "< $frieingelestext";
$eingelesenes= Görßerzeichen TEMP Kleinerzeichen;
close(TEMP);
chomp($eingelesenes);
print "Dieser Text stand in einer Datei: $eingelesenes\n";
# In obigen Zeilen bezüglich des Stdin und der Open-Prozedur wurde nachträglich Chomp eingeführt.
]]>CD -> ???
Diskette -> Bootsektor
Festplatte -> MBR
lsmod =
Steht für list modules. Listet alle im Kernel geladenen Kernel-Module auf. Kann z. B. verwendet werden, um zu überprüfen, ob ein bestimmtes Treibermodul geladen ist.
modprobe / insmod =
lädt ein Kernelmodul im laufenden Betrieb. Kernelmodule befinden sich i. d. R. in /lib/modules/Kernelversion
uname -r =
Gibt die Version des momentan laufenden Kernels aus
ps -e
= Zeigt alle laufenden Prozesse im System.
top =
Zeigt eine laufend aktualisierte Liste aller laufenden Prozesse, sortiert nach ihrer momentanenen Beanspruchung der CPU
/etc/inittab =
Legt grundlegende Einstellung für den Init-Prozess fest, z. B. den Standardrunlevel, der beim Systemstart aufgerufen werden soll. Die Datei ist normalerweise mit vielen Kommentaren geschmückt, im Zweifelsfall hilft auch man inittab
/etc/init.d =
Enthält die sog. Init-Skrpiten, die vom Init-Prozess je nach Konfiguration aufgerufen werden, und verschiedene Prozesse, wie z. B. einen Apache-Webserver oder den X-Server für die grafische Oberfläche auf dem Bildschirm. Die Init-Skripten sind i. d. R. in der Skript- und Shell-Sprache Bash geschrieben.
Wenn z. B. das Skript /etc/init.d/apache2 zum Apache-Webserver (Version 2) gehört, kann dieser mit /etc/init.d/apache2 start gestartet, mit /etc/init.d/apache2 restart / stop neugestartet oder beendet werden.
/etc/rc[0123456].d (/etc/rc0.d, /etc/rc1.d, ...) =
Diese Verzeichnisse enthalten Verweise auf die Dateien aus /etc/init.d, die im entsprechenden Runlevel gestartet werden sollen. (Ein Verweisname von S20apache2 heißt, dass der Apache-Webserver gestartet, K30apache2 dass er im diesem Runlevel gestopt werden soll. Die Nummer legt die Reihenfolge fest.) (dieses Schema wird oft Sys-V init scripts genannt.)
Auf manchen Systemen funktioniert das ganze allerdings ein wenig anders; dort werden zunächst alle Skripte in /etc/init.d aufgerufen, und danach ggf. weitere aus /etc/rc[0123456].d.
Auf wieder anderen Systemen (z. B. gentoo) werden zu startende Systemprozesse auch über Verweise in /etc/runlevels festgelegt. (gentoo-style init scripts)
Im Anschluss wurde der berühmt berüchtigte Texteditor vi eingeführt. Folgendes ist bei seiner Benutzung zu beachten: Es gibt mehrere Modi, in denen sich der Editor befinden kann:
Im Kommandomodus, der durch den Doppelpunkt gestartet wird, sind folgende Kommandos relevant:
:q - Beendet den vi
:w - Speichert die Datei
:q! - Beendet, auch wenn nicht gespeichert wurde.
Diese Kommandos lassen sich auch kombinieren, so beendet ":wq" den Editor und speichert das aktuelle Dokument. Der Kommandomodus wird verlassen, indem ein Kommando mit "Enter" ausgeführt wird, oder das Kommando mit "Esc" abgebrochen wird.
Im Standardmodus gelten folgende Kommandos:
k - Cursor nach oben
j - Cursor nach unten
h - Cursor nach links
l - Cursor nach rechts
w - Cursor ein Wort weiter
/ - vorwärts suchen
? - rückwärts suchen
x - löscht ein Zeichen
dd - löscht eine Zeile
dw - löscht ein Wort
u - letzte Aktion widerrufen
yy - kopiert eine Zeile
p - fügt ein
Durch i, I, a, A, o oder O wechselt man in den Eigabemodus, der mit "Esc" wieder beendet wird.
i - vor dem aktuellen Zeichen schreiben
a - nach dem aktuellen Zeichen schreiben
I - am Zeilenanfang schreiben
A - am Zeilenende schreiben
o - neue Zeile nach der aktuellen einfügen und darin schreiben
O - dito nur vor der aktuellen Zeile
Dateisystem:
/proc Systemzustände, z. B. Akkustand bei einem Notebook
/root Homeverzeichnis von root
/home Homeverzeichnisse der Benutzer
/boot Kernel, Boot-Loader (GRUB, LILO)
/etc Systemweite Konfigurationsdateien
/dev Verbindung zu den Geräten (werden zum mounten benötigt)
/bin (Meistens) zum Booten benötigte Programme
/sbin (Meistens) zum Booten benötigte Programme für root (s -> super user)
/usr Programme, Programmdateien, Programmbibliotheken (steht afaik für Unix System Resource)
/lib (Meistens) zum booten benötigte Programmbibliotheken
/mnt Einhängbare Geräte
Übersicht über Gerätedateien:
hda Erstes IDE-Gerät (Primary Master)
hdb, hdc, hdd, ... Weitere IDE-Geräte (Primary Slave, Secondary Master, Secondary Slave, ...)
hda1, hda2, ... (hdb1, ...) Partition auf hda, wenn auf hda (hdb) eine lesbare Partitionstabelle gefunden wurde
sda Erstes SCSI-Gerät (USB-Sticks sind in der Regel SCSI-Geräte!)
zero Liefert beim Lesen Nullen (binäre nullen, nicht ASCII-Nullen)
null Liefert beim Lesen EOF und verwirft geschriebene Daten
Wichtige Befehle:
bash
- Kommandozeile / Shell / DOS-Eingabeaufforderung (*wee* ^^)
ls
- Dateilisting des aktuellen Verzeichnisses
ls /root
- Dateilisting von /root
ls -alh /root
- Dateilisting von /root, versteckte Dateien anzeigen (a -> all), ausführliche Auflistung (l -> long), Dateigrößen in MByte / GByte / ... (h -> human readable units)
cd verzeichnis
- Verzeichnis zu verzeichnis wechseln (change directory)
pwd
- aktuelles Verzeichnis anzeigen
cd ..
- ein Verzeichnis nach oben wechseln
rm datei
- datei löschen (remove)
rm -r verzeichnis
- verzeichnis rekursiv löschen
rm -rf verzeichnis
- verzeichnis rekursiv ohne Nachfrage löschen (Nachts um zwei ausführen ^^)
rmdir verzeichnis
- (leeres) Verzeichnis namens verzeichnis löschen (remove directory)
touch datei
- leere Datei namens datei anlegen
cat datei
- Inhalt von datei anzeigen
hexdump -C datei
- Hex-Listing von datei anzeigen (nützlich für Binärdateien)
hexdump -C /dev/hda
- Hex-Listing (sehr wahrscheinlich) der ersten Festplatte anzeigen ^^
less datei
- Inhalt von datei scrollbar anzeigen (Beenden mit q)
cp datei datei-kopie
- datei nach datei-kopie kopieren
mv datei neuername
- datei nach neuername verschieben
mount
- momentan eingehängte Dateisysteme anzeigen
mount /dev/hda2 /mnt/daten
- Dateisystem auf /dev/hda2 in /mnt/daten einhängen
chmod 755 datei
- Berechtigungen von datei auf 755 ändern
chown benutzer:gruppe datei
- Besitzer von datei auf benutzer und gruppe ändern
Dateizugriffsberechtigungen
Für eine Datei kann jeweils für den Besitzer, für Benutzer, die der der Datei zugordneten Gruppe angehören, und für alle übrigen Benutzer festgelegt werden, welche Operationen erlaubt sind. Mögliche Operationon sind r (read, Datei lesen), w (write, Datei schreiben) und x (execute, Datei ausführen).
ls -l gibt die Zugriffsberechtigungen z. B. in der Form rw-r--r-- oder rwxr-xr-x aus. Dabei stehen jeweils drei Zeichen für das erlauben (r, w, x) oder Verweigern (-) der Aktion für Benutzer, Gruppe und Rest (in dieser Reihenfolge.
Beispiel: rwx-rw-r-x heißt, dass der Besitzer lesen, schreiben und ausführen, die Benutzer der Gruppe der Datei lesen und schreiben (aber nicht ausführen) und alle anderen lesen und ausführen (aber nicht schreiben) dürfen.
Für Verzeichnisse heißt r, das die Namen der im Verzeichnis enthaltenen Dateien und Verzeichnisse aufgerufen werden dürfen, und x heißt, dass Zugriff auf beliebige Dateien und Verzeichnisse unterhalb dieses Verzeichnisses gestattet ist, wenn dies die Berechtigung der Datei selbst ebenfalls erlauben. Wenn ein Benutzer auf einem Verzeichnis kein x darf, darf er auf keine der enthaltenen Dateien und Verzeichnisse zugreifen, auch wenn es die Berechtigungen der Datei selbst gestatten würden.
User Group World
r w x r w x r w x
4 2 1 4 2 1 4 2 1
Beispiel: rwxr-xr-x -> 4+2+1=7, 4+1=5, also 755; rw-rw-r-- -> 4+2=6, sowie 4, also 664.