EDV im MIUB - Meteorological Institute Bonn - Universität Bonn
EDV im MIUB - Meteorological Institute Bonn - Universität Bonn
EDV im MIUB - Meteorological Institute Bonn - Universität Bonn
Sie wollen auch ein ePaper? Erhöhen Sie die Reichweite Ihrer Titel.
YUMPU macht aus Druck-PDFs automatisch weboptimierte ePaper, die Google liebt.
<strong>EDV</strong> <strong>im</strong> <strong>MIUB</strong><br />
<strong>EDV</strong> = Elektronische DatenVerarbeitung<br />
<strong>MIUB</strong> = Meteorologisches Institut der <strong>Universität</strong> <strong>Bonn</strong><br />
Verantwortliche:<br />
Marc Mertes Zi. 108 Tel. 5102<br />
Stefan Heinzelmann Zi. 108 Tel. 5102<br />
Thomas Burkhardt Zi. 113 Tel. 5196<br />
WEBHilfen:<br />
http://www2.meteo.unibonn.de/intern/computer/index.htm<br />
http://www2.meteo.unibonn.de/mitarbeiter/TBurkhardt/vorlesungen_TB.html<br />
http://faq.meteo.unibonn.de<br />
Verfügbare Computer:<br />
Raum 102 (Seminar/PCRaum); 20 Terminals an TerminalServer;<br />
Raum 103 (Lesesaal; 12 Terminals an TerminalServer;<br />
Verfügbare Drucker:<br />
Vorraum vor 113/114 : laser21_s, laser21_d (schwarz)<br />
phaser_s, phaser_d (farbig)<br />
1. Etage, Raum <strong>im</strong> Foyer : laser22_s, laser22_d (schwarz)<br />
pablo_s, pablo_d (farbig)
Inhalte der Veranstaltung<br />
0 Einleitung<br />
1 Betriebssystem<br />
2 Eingabeoberfläche<br />
3 shell<br />
4 Dateisystem<br />
5 Graphische Arbeitsoberfläche<br />
6 Programme<br />
7 Die Cshell<br />
8 R<br />
0 Einleitung<br />
0.1 Rechnerlandschaft<br />
0.2 Vernetzung<br />
0.3 Benutzerverwaltung<br />
0.4 Peripherie
0.1 Rechnerlandschaft<br />
Arbeitsplatzrechner für SHKs (Studentische HilfsKraft), Diplomanden, Mitarbeiter<br />
Terminalpool für Studenten<br />
Server für Spezialaufgaben:<br />
Datenspeicherung (> 250 TB)<br />
Benutzerverwaltung (NIS = Network Information System)<br />
Radardaten<br />
WindowsAnwendungen<br />
RechnerCluster für parallele Verarbeitung von Rechnungen<br />
Rechner besteht aus:<br />
Motherboard (Platine mit Leiterbahnen, Steckplätzen,<br />
Speicherbausteinen = Chips)<br />
BIOS (=Basic Input Output System) ← heute abgelöst durch UEFI<br />
(unified extensible firmware interface)<br />
CPU mit Registern (=Central Processing Unit)<br />
Hauptspeicher (RAM=Random Access Memory)<br />
Massenspeicher (Festplatte, HD=Hard Disk)<br />
Rechner + Eingabeinstrument (Tastatur, Maus) + Ausgabeinstrument (Bildschirm)
0.2 Vernetzung<br />
Ethernet Vernetzung mit 1000 Mbit/s über Kupferkabel WLAN<br />
Protokoll: TCP/IP (TransmissionControlProtocol / InternetProtocol)<br />
weltweit hat jeder Anschluß eine eindeutige Adresse aus 32 Bit<br />
bei uns: 131.220.61.xxx<br />
Kennung für Uni<strong>Bonn</strong><br />
Domäne <strong>MIUB</strong> („meteo.unibonn.de“)<br />
Nummer einzelner Rechner (1254)<br />
r003d.meteo.unibonn.de – Umsetzung in Nummer durch Nameserver<br />
innerhalb der Domäne reicht r003d<br />
Anschluß an das „bonnet“ (Gesamtvernetzung der <strong>Universität</strong>)<br />
HochschulRechenZentrum (HRZ) betreibt Anschluß an das WIN (WissenschaftsNetz),<br />
das ins Internet eingebunden ist (www.hrz.unibonn.de)j<br />
Es besteht die Möglichkeit über das WLAN des bonnet mit Notebook/Laptop <strong>im</strong><br />
Institut <strong>im</strong> Netz zu arbeiten.<br />
Vorgehensweise: s. faq.meteo.unibonn.de, bei Volltextsuche: WLAN eingeben<br />
Firewall : miubgate.meteo.unibonn.de Zugangsdaten: M. Mertes<br />
Kabelanschluß : bei Netzwerkverbindung DHCP (Dynamic Host Configuration<br />
(muss freige Protocol) einstellen ==> IPAdresse wird autom. Zugewiesen.<br />
Schaltet werden)
Internet/WIN<br />
miubgate<br />
PC PC<br />
PC<br />
PC<br />
bonnet - Uni <strong>Bonn</strong><br />
Cluster<br />
Wlan<br />
miub<br />
Laptop
0.3 Benutzerverwaltung<br />
Zugangsschutz für Rechner über Benutzername (UserID) und Passwort<br />
Zentrale Benutzerverwaltung über NIS (Network Information System; früher:<br />
yp=yellow pages)<br />
Zugangsberechtigungen tragen o.g. Systemverwalter ein<br />
An jedem Rechner gibt es Benutzer mit allen Rechten:<br />
Verwalter, Administrator, root, Superuser<br />
Dieser entscheidet an jedem Rechner, ob ein zentral registrierter Benutzer Zugang<br />
zum individuellen Rechner hat.<br />
Euer accountname entspricht dem in basis hinterlegten email Namen: s6xxyyyy<br />
Das Initialpasswort ist: in Anlehung an den account:<br />
nach dem s6 eine 1<br />
Nach den nächsten 4 Buchstaben ein ! (Ausrufungszeichen)<br />
Also: s61xxyy!<br />
Passwort ändern: in einer Konsole yppasswd eingeben<br />
altes Passwort eingeben<br />
2x das neue eingeben (8 Zeichen, Zahlen oder<br />
Sonderzeichen)
0.4 Peripherie<br />
Verfügbare Drucker:<br />
Vorraum vor 113/114 : laser21_s, laser21_d (schwarz)<br />
phaser_s, phaser_d (farbig)<br />
Flur, 1. Etage (vor Raum 206) : laser22_s, laser22_d (schwarz)<br />
pablo_s, pablo_d (farbig)<br />
Raum 106 : a3laser (schwarz, DINA3)<br />
Scanner:<br />
Raum 110 (vor dem Hörsaal) : HP Farbscanner (allg. verfügbar, Windows)<br />
mit winscp exportieren<br />
Raum 103 (Bibliothek) : nur in Absprache mit Bib benutzbar<br />
Externe Massenspeicher:<br />
diverse DVDSchreiber<br />
Stick am PultPC einsetzen<br />
WindowsTerminal Server:<br />
Auf allen Rechnern : WTSSession; zur Nutzung in Raum 108 melden<br />
Parallelrechner
1 Betriebssystem (BS)<br />
Betriebssystem • regelt Funktionen der einzelnen Bauteile und ihre Zusammenarbeit<br />
• besteht aus Kern und zusätzlichen Modulen / Treibern<br />
• ist ein Programm („Code“)<br />
Einschalten des Rechners aktiviert Auslesen des BIOS (Basic Input Output System)<br />
(heute: UEFI) = Chip mit Informationen über Bauteile des Rechners und über Lage des<br />
Master Boot Records (MBR) (meist Festplatte)<br />
booten ist das Einlesen des MBR und des BS in den Hauptspeicher und die<br />
Verarbeitung durch die CPU<br />
Meist ist heute zwischen MBR und BS ein BootManager geschaltet, wenn mehrere<br />
BS <strong>im</strong> Rechner erreichbar sind<br />
Nach Ende des bootens steht vollständige Konsole (Eingabe und Ausgabeeinheit)<br />
zur Verfügung<br />
Die zur Verfügung stehende Eingabeoberfläche ist<br />
befehlszeilen oder zeichenorientiert oder<br />
graphisch
2 Eingabeoberfläche<br />
Eine Eingabeoberfläche ist eine Benutzerschnittstelle<br />
Eine Eingabeoberfläche ist (wieder) ein spezielles Programm<br />
Bedienung der Eingabeeinheit liefert Signal an dieses Programm<br />
Programm setzt Signal in Anweisung an CPU um<br />
Befehlszeilenorientierte Eingabeoberflächen in UNIX (LINUX): shell<br />
Manche Zeichen werden nur dargestellt, manche dienen als Steuerzeichen<br />
shell dient in erster Linie dazu, <strong>im</strong> System vorhandene Befehle und Programme zur<br />
Ausführung zu bringen<br />
shell bietet keine komfortablen Möglichkeiten zur Speicherung von Zeichen (Daten )<br />
Dafür stehen Editoren zur Verfügung<br />
Graphische Oberfläche wird mit Maus bedient. Von dort können shells oder Editoren<br />
ausgeführt (gestartet) werden.<br />
Linux hat <strong>im</strong>mer 6 befehlszeilenorientierte Eingabeoberflächen und auf Wunsch eine<br />
graphische.<br />
zwischen den Befehlszeilenorientierten : drücke AltF1 oder AltF2 .... bis F6<br />
befehlszeilenorientiert >> graphisch : drücke Taste AltF7<br />
graphisch >> befehlszeilenorientiert : drücke Tastenkombination AltStrgF1 (...F2,...<br />
graphisch >> graphisch : drücke StrgF1, StrgF2, ...
Graphische Oberflächen basieren in LINUX auf XWindows (MIT, 1984)<br />
http://de.wikipedia.org/wiki/X_Window_System<br />
= bitmapbasierte (rastergraphikbasierte) Bildschirmdarstellung<br />
Das Bitmap (grauweisser Bildschirm) ist der XServer der verschiedenen XClients<br />
als Grundlage dient.<br />
Der XServer kann <strong>im</strong>mer nur einmal auf einem Rechner gestartet werden<br />
Als erster Client wird ein FensterManager gestartet, der die Anmeldemaske<br />
liefert.<br />
Die Rechte an dem XServer werden dem Benutzer übertragen, der sich<br />
anmeldet.<br />
Diese gewähren jedem an diesem Rechner von diesem Benutzer gestarteten<br />
XClient die Benutzung der Eingabeoberfläche<br />
Ein Client kann auch auf einem fremden (durch ein Netzwerk verbundenen)<br />
Rechner gestartet werden. Dazu sind weitere Maßnahmen nötig
3 shells<br />
Zeichenorientierte Eingabeoberflächen heißen unter UNIX shell<br />
Eine shell ist ein Programm<br />
shells ermöglichen die Eingabe von Kommandos über die Tastatur<br />
Mit der „Return“Taste (◄┘) wird das Ende des Befehls angezeigt<br />
Dieser wird dann von der shell interpretiert<br />
Das Ende des Programms „shell“ wird durch den Befehl exit bzw. die<br />
Tastenkombination „StrgD“ erreicht<br />
Das Erscheinungsbild von shells wird durch spezielle Dateien festgelegt
4 Dateisystem<br />
Ein Dateisystem wird für die geordnete und koordinierte Speicherung von<br />
Informationen (Daten) benutzt<br />
Kleinste Informationseinheit : 1 Bit<br />
Speicherbare Information : ja/nein, an/aus, hoch/tief, 0/1 = 1 Zustand<br />
Nächstgrößere Einheit : 1 Byte = 8 Bit = 8 Zustände<br />
Darstellbare Information : über Vereinbarungen 0255<br />
daraus über ASCIITabelle 256 Zeichen
Einschub: Dual System<br />
Bei der Zahlendarstellung <strong>im</strong> Dualsystem gibt es nur die Ziffern 0 und 1<br />
Die Ziffern werden wie <strong>im</strong> gewöhnlich verwendeten Dez<strong>im</strong>alsystem ohne<br />
Trennzeichen hintereinander geschrieben<br />
Ihr Stellenwert entspricht allerdings der zur Stelle passenden Zweierpotenz<br />
und nicht der Zehnerpotenz<br />
Bsp.: Dez<strong>im</strong>alsystem 3421 entspricht 3∙10 3 +4∙10 2 +2∙10 1 +1∙10 0<br />
= <strong>im</strong> Dualsystem 110101011101 entspricht<br />
1∙2 11 +1∙2 10 +0∙2 9 +1∙2 8 +0∙2 7 +1∙2 6 +0∙2 5 +1∙2 4 +1∙2 3 +1∙2 2 +0∙2 1 +1∙2 0<br />
Man erstellt die Bitfolge nach folgendem Schema:<br />
Dez<strong>im</strong>alzahl / 2 = ganzzahliges Ergebnis mit Rest x<br />
gz. Ergebnis / 2 = ganzzahliges Ergebnis mit Rest y<br />
.....<br />
und reiht die Reste von rechts nach links auf: .....yx<br />
= <strong>im</strong> Hexadez<strong>im</strong>alsystem D5D entspricht 13∙16 2 +5∙16 1 +13∙16 0<br />
(A=10, B=11, .......)
Dateisystem<br />
cp rm<br />
/<br />
bin/ usr/ home/ user/ Projekte/<br />
bash<br />
bin/ local/ cosmo4.2/ DWDgrib/<br />
temp/<br />
text2<br />
tom silvia ahense praktikant<br />
text1<br />
text2<br />
Kleinste Einheit der Informationsspeicherung <strong>im</strong> Umgang mit dem<br />
Rechner: Datei<br />
Dateien werden in Verzeichnissen gesammelt<br />
Verzeichnisse können über- und untergeordnete Verzeichnisse haben<br />
Der Baum (Graph) der zusammenhängenden Verzeichniszweige bildet<br />
das Dateisystem
Der Name der Dateien und Verzeichnisse ist (weitgehend) beliebig.<br />
Zu verwenden sind „vernünftige“ Zeichen.<br />
Es wird zwischen Groß und Kleinschreibung unterschieden („case sensitive“)<br />
Nicht vernünftig sind: ? * [ ] & | < > ( ) : / \“ ` ' ! Leerzeichen<br />
okay sind: _ .<br />
Festgelegte Namen: / Stammverzeichnis<br />
. aktuelles Verzeichnis<br />
.. übergeordnetes Verzeichnis<br />
Dateien/Verzeichnisse, die mit dem Punkt . beginnen, erfahren bei manchen<br />
Operationen eine Sonderbehandlung<br />
Das Zeichen / trennt Verzeichnisnamen untereinander und den letzten VN vom<br />
folgenden Dateinamen<br />
Also bspw.: /user/tom/temp/text2
Absolute und relative Adressierung<br />
Die Auflistung aller Verzeichnisse <strong>im</strong> Zweig evtl. bis zu einem Dateinamen vom<br />
Stammverzeichnis / aus ist die absolute Adresse (/user/tom/temp/text2)<br />
Startet man die Adressierung ausgehend von einem Verzeichnis in der Mitte des<br />
DS, so kann man über relative Adressierung eine Datei oder Verzeichnis eindeutig<br />
benennen. Dies geschieht unter Verwendung des Namens .. für das jeweils<br />
übergeordnete Verzeichnis. ( ../tom/temp/text2)<br />
Über eine sinnvolle Verwendung des . als Name für das aktuelle Verzeichnis wird<br />
später zu berichten sein<br />
Programme zum Erstellen und Verwalten des DS werden in den Kapiteln über<br />
Anwendungen/Befehle in der graphischen und zeichenorientierten<br />
Eingabeoberfläche behandelt werden<br />
Begriffe wie Sektoren, Blocks, Zylinder, die bei Festplatten eine Rolle spielen, haben<br />
für uns keine Bedeutung<br />
Über Inodes wird das DS unter UNIX verwaltet. Sie verbinden unsere symbolischen<br />
Namen mit Angaben für das BS zum Auffinden der Informationen
Die bei Einrichtung einer Festplatte festgelegte Einteilung in Partitionen ist <strong>im</strong><br />
UNIX DS nicht erkennbar.<br />
Verschiedene Partitionen (über ein Netzwerk auch von anderen Rechnern)<br />
können über einen Verzeichnisnamen („mountpoint“) irgendwo ins DS<br />
eingehangen werden. („mounten“)<br />
DOS/Windows hat für jede Partition ein DS
Wichtige Verzeichnisse in UNIX:<br />
/ Stammverzeichnis<br />
. aktuelles Verzeichnis<br />
.. übergeordnetes Verzeichnis<br />
/bin Standard Systemprogramme<br />
/sbin Standard Verwaltungsprogramme<br />
/lib bzw. /lib64 StandardBibliotheken<br />
/usr/bin spezielle Systemprogramme<br />
/usr/sbin spezielle Verwaltungsprogramme<br />
/usr/lib bzw.<br />
/usr/lib64 spezielle Bibliotheken<br />
/usr/local bzw.<br />
/opt Anwendungsprogramme<br />
/home Benutzerdaten<br />
/user Benutzerdaten <strong>im</strong> <strong>MIUB</strong><br />
/root Benutzerdaten des Verwalters<br />
/var Systemdateien (Protokolldateien)<br />
/boot beinhaltet BS Kern<br />
/etc Konfigurationsdateien<br />
/dev Spezialdateien u.a. zur Ansteuerung der Peripherie<br />
/proc Informationen über das System<br />
/media mountpoints für externe Datenträger (DVD, USB etc.)
5 Graphische Arbeitsoberfläche<br />
Schaltknöpfe (Buttons) verknüpft mit Programmen werden gestartet<br />
Dateien werden mit Programm<br />
verbunden<br />
Kontrolleiste zeigt Schaltknöpfe<br />
Kontrollbilder laufende Programme<br />
virtuelle Bildschirme<br />
Uhr<br />
Veränderungen über Druck mit rechter Maustaste in Freifläche > Menü folgen<br />
Schnell erreichbar sollten sein: WebBrowser<br />
MailClient<br />
Konsole<br />
Editor<br />
DS Verwaltungsprogramm<br />
Textverarbeitung
6 Programme<br />
6.0 DAS Programm zur Hilfe<br />
man<br />
man man<br />
man k stichwort_zur_funktion
6.1 Programme zur Verwaltung des Dateisystems<br />
ls Anzeigen von Datei/Verzeichniseinträgen<br />
pwd Anzeigen des Namens des aktuellen Verzeichnisses<br />
mkdir Erstellung eines Verzeichnisses<br />
cd Wechseln des aktuellen Verzeichnisses<br />
cp Verdoppeln von Dateien oder Verzeichnissen (kopieren)<br />
scp Verdoppeln von Dateien oder Verzeichnissen von entfernten oder auf<br />
entfernte, über eine Netzanbindung erreichbare Rechner<br />
mv Umbenennen von Dateien oder Verzeichnissen<br />
ln Verbinden (Linken) einer vorhandenen Datei mit einem weiteren Namen<br />
rmdir Löschen eines leeren Verzeichnisses<br />
rm Löschen von Dateien oder Verzeichnissen<br />
df Abfrage der Belegung zur Verfügung stehender Partitionen<br />
du Abfrage des Speichervolumens zu benennender Verzeichnisse<br />
find Aufsuchen von Dateien <strong>im</strong> Dateisystem
6.2 Programme mit Bezug auf den Inhalt von Dateien:<br />
cat Ausgabe von Dateiinhalten<br />
more Seitenweise Ausgabe von Dateiinhalten<br />
grep Durchsuchen von Dateien nach Textmustern<br />
diff Feststellen von Unterschieden zwischen Dateien<br />
wc Zählen von Zeilen/Worten/Zeichen in Dateien<br />
6.3 Programme von allgemeinem Interesse<br />
ssh Anmeldung auf einem fremden Rechner<br />
date Datum und Zeit abfragen/verändern<br />
ps Laufende Prozesse abfragen<br />
kill Laufende Prozesse abbrechen<br />
which Ausgabe der Lage einer Kommandodatei <strong>im</strong> Dateisystem<br />
whoami Ausgabe der aktuellen UserID<br />
who Ausgabe aller auf einem Rechner angemeldeten Benutzer
Allgemeine Regel unter UNIX<br />
Die systemnahen Befehle in ihrer Grundstruktur sind sehr einfach, können aber durch<br />
meist zahlreiche Optionen sehr mächtig gemacht werden. Optionen werden fast<br />
<strong>im</strong>mer mit „“ , manchmal auch mit „ “ gekennzeichnet, bei manchen<br />
Befehlen gibt es die eine wie die andere Syntax. (...die man mit man abfragen kann)<br />
Zur Schreibweise in der Präsentation:<br />
Kursiv geschriebene TextTeile müssen sinnvoll ersetzt werden !
Eingabe Ausgabe / Zweck / Erläuterung<br />
In den Beschreibungen sind die kursiven Anteile durch geeignete Namen zu ersetzen<br />
ls Listing von Datei und Verzeichnisnamen <strong>im</strong> aktuellen Verzeichnis<br />
ls l Erweiterung um eine Fülle von Informationen (Größe, Rechte):<br />
-rw-r--r-- 1 loktom users 1222 24. Okt 08:20 int_als_bit.f90<br />
- normale Datei (d=Verzeichnis, l= Link, c oder b = Spezialdateien<br />
rwx Rechte für den Besitzer (r=Lesen, w=Verändern, x=Ausführen, -=kein Recht<br />
rwx Rechte für die Gruppe, der die Datei zugeordnet ist<br />
rwx Rechte für alle anderen<br />
Besitzer der Datei<br />
Gruppe, der die Datei zugeordnet ist<br />
Bei Dateien: Größe in Byte<br />
Zeitpunkt der letzten Veränderung (Erzeugung)<br />
Name der Datei (des Verzeichnisses)<br />
ls a Dateien mit Punkt am Anfang werden angezeigt<br />
ls la Kombination von Optionen<br />
ls verzeichnis Listing von Datei und Verzeichnisnamen <strong>im</strong> Verzeichnis mit dem<br />
Namen verzeichnis<br />
ls l datei Fülle von Informationen zur Datei namens datei<br />
pwd Name des aktuellen Verzeichnisses (Position <strong>im</strong> Dateisystem)<br />
mkdir verzeichnis Erzeugen eines Verzeichnisses ohne Inhalt<br />
cd verzeichnis Mach verzeichnis zum aktuellen Verzeichnis (wechsele das akt. Verz.)
„Kopieren“<br />
cp datei1 datei2 Erzeugen einer Datei namens datei2 mit dem Inhalt von datei1<br />
cp r verzeichnis1 verzeichnis2 Verdopplung von verzeichnis1 mit allen Dateien<br />
und Unterverzeichnissen unter dem Namen<br />
verzeichnis2<br />
„Fernkopieren“<br />
scp lokale_datei userid@fremder_rechner :entfernte_datei<br />
Erzeugen einer Datei entfernte_datei auf einem fremden Rechner mit<br />
dem Inhalt von lokaler_datei auf dem lokalen Rechner<br />
Die be<strong>im</strong> 1. Ansprechen eines Rechners eingeblendete Frage:<br />
The authenticity of host 'sv24 (131.220.61.24)' can't be established.<br />
RSA key fingerprint is 99:68:26:11:e1:ab:5d:9b:f4:fb:f4:cc:f6:ea:c0:09.<br />
Are you sure you want to continue connecting (yes/no)?<br />
muss mit yes beantwortet werden<br />
scp userid@fremder_rechner :entfernte_datei lokale_datei<br />
Umkehrung der o.g. Fernkopie<br />
scp r lokales_verzeichnis userid@fremder_rechner :entferntes_verzeichnis<br />
scp r userid@fremder_rechner :entferntes_verzeichnis lokales_verzeichnis<br />
Fernkopie von Verzeichnissen mit Unterverzeichnissen und allen Dateien<br />
mv dateiname1 dateiname2<br />
mv verzeichnisname1 verzeichnisname2<br />
Umbenennen von Dateien oder Verzeichnissen („moven“)<br />
Liegt der neue Name in einer anderen Partition, so ist mit mv ein cp verbunden<br />
ln s vorhandene_datei zweiter_name_fuer_datei<br />
ln s vorhandenes_verzeichnis zweiter_name_fuer_verzeichnis<br />
Stellt den vorhandenen Eintrag (Verz. od. Datei) unter einem weiteren Namen<br />
zur Verfügung: „linken“ = verbinden
Übung 1a:<br />
Erzeuge unterhalb des Verzeichnisses<br />
/user/userid (ersetze userid durch Deine userid = Benutzernamen)<br />
ein Verzeichnis und in diesem ein Unterverzeichnis und eine Datei mit beliebigem<br />
Namen und mit dem Inhalt der Datei /user/userid/.cshrc<br />
Wichtig: Überzeuge Dich vom Erfolg Deiner Aktionen<br />
Gib der erzeugten Datei einen neuen Namen, so daß diese <strong>im</strong> von Dir erzeugten<br />
Unterverzeichnis eingeordnet ist.<br />
Mache eine Fernkopie dieser Datei auf den Rechner mit den Namen<br />
sv31 unter dem Namen /tmp/ersti_uebung.userid
cat datei Gibt den Inhalt von datei auf den Bildschirm aus<br />
grep textmuster datei durchsucht datei nach Auftreten von textmuster<br />
grep R muster verzeichnis durchsucht alle Dateien in verzeichnis und seinen<br />
Unterverzeichnissen nach Auftreten von muster<br />
diff datei1 datei2 Vergleicht die Inhalte der beiden Dateien<br />
Erklärung des Outputs erfolgt in der Übung bzw. ist <strong>im</strong><br />
Skript nachzulesen<br />
wirkt auch bei binären Dateien<br />
wc datei Gibt die Anzahl der Zeilen, Worte (durch Leerzeichen<br />
wc datei1 datei2 .... voneinander getrennte Textstücke) und Zeichen (inkl.<br />
Leerzeichen) aus<br />
Dabei ist zu bedenken, daß am Ende jeder Zeile ein<br />
(unsichtbares) Zeichen steht, daß als Steuerzeichen<br />
den Zeilenumbruch erwirkt
Übung 1b:<br />
Gib den Inhalt der in Üb.1 bearbeiteten Datei auf dem Bildschirm aus<br />
Mache eine Fernkopie der Dateien /tmp/out4 und /tmp/out2 vom Rechner<br />
sv31 in Dein in Üb.1 neu erzeugtes Verzeichnis<br />
Vergleiche die Inhalte der Dateien out2 und out4<br />
In welchen Dateien des Verzeichnisses /boot ist das Textmuster „openSUSE“<br />
enthalten? Überprüfe in einem auch alle Unterverzeichnisse von /boot.<br />
Wieviele sichtbare Zeichen, wieviel Worte hat die Datei .cshrc ?
mdir verzeichnis Löscht das verzeichnis, falls es leer ist<br />
rm datei Löscht die datei<br />
rm link Löscht den link (egal ob der Link auf ein V. oder eine D. zeigt)<br />
rm r verzeichnis Löscht verzeichnis mit allen Unterverzeichnissen und Dateien<br />
ACHTUNG!!! Gefährlichster Befehl in UNIX !!<br />
df Auflisten der zur Verfügung stehenden (gemounteten)<br />
Partitionen mit Angabe der Ausnutzung.<br />
Wichtig: Partitionen nicht über 95% füllen !!!<br />
du sk verzeichnis gibt den verbrauchten Speicherplatz aller Unterverzeichnisse<br />
und Dateien von verzeichnis aus<br />
find suchverzeichnis name datei<br />
durchsucht das Dateisystem in den Zweigen unterhalb von<br />
suchverzeichnis nach datei und gibt das Fundortverzeichnis aus
Übung 1c:<br />
Lösche die Dateien in dem von Dir angelegten Unterverzeichnis<br />
Lösche das von Dir angelegte Unterverzeichnis<br />
Zu welchem Prozentsatz ist auf Deinem Rechner die Partition, die unter dem<br />
Namen /tmp verfügbar ist, gefüllt?<br />
Wieviel Speicherplatz wird von dem Verzeichnis /usr/lib verbraucht ?<br />
In welchem Unterverzeichnis von /usr liegt die Datei gfortran ?
ssh X userid@rechnername meldet den Benutzer userid an dem Rechner<br />
rechnername an. Das X ermöglicht den Start<br />
von Xclients auf dem fremden Rechner und die<br />
Anzeige auf dem lokalen XServer<br />
Beenden des Programms (abmelden) mit exit<br />
ssh X user_id@rechnername kommando führt kommando auf dem Rechner<br />
rechnername aus und überträgt die Ausgabe auf<br />
den lokalen Rechner<br />
date gibt aktuelles Datum und Uhrzeit aus<br />
date +Am_%d.%m.%Y verändert das Aussehen der Datumsausgabe<br />
date +Am_%d.%m.%Y −−date='+2weeks 12 days'<br />
date +Am_%d.%m.%Y −−date='22weeks 12 days'<br />
gibt das relativ zum aktuellen veränderte Datum aus
Übung 1d:<br />
Melde Dich auf dem Rechner sv31 an<br />
Gib das Datum von vorgestern aus
7 Die Cshell<br />
Eine shell ist ein Programm, wird gestartet wie ein Programm, hat manpages<br />
In der rein zeichenorientierten Oberfläche erfolgt Start durch die Anmeldung<br />
Auf der graphischen Oberfläche erfolgt Start durch Klick auf ein Button oder<br />
Eingabe des Befehls csh in einer Konsole (Verschachtelte shells)<br />
Beendet wird eine shell durch den Befehl exit oder die Tastenkombination <br />
Jedes beliebige Programm startet zuerst eine shell in der es sich dann ausführt<br />
Bei Programmende wird auch die shell beendet<br />
Bei jedem shellStart werden die Anweisungen in den Dateien<br />
/etc/csh.cshrc<br />
/user/userid/.cshrc (/user/userid ist das sog. HOMEVerzeichnis)<br />
in dieser Reihenfolge ausgeführt<br />
Sie gestalten die Arbeitsumgebung<br />
Zusätzlich wird die Datei .history aus dem HOMEVerzeichnis geladen, um die letzten<br />
eingegebenen Befehle für die PfeilTasten verfügbar zu machen
Wie fast jeder Befehl in UNIX hat „csh“ Optionen:<br />
f Ausführung der Anweisungen aus .cshrc wird unterdrückt<br />
l es wird eine Loginshell gestartet, wodurch 2 zusätzliche Dateien ausgeführt<br />
werden. Reihenfolge: /etc/csh.cshrc<br />
/etc/csh.login<br />
/user/userid/.cshrc<br />
/user/userid/.history<br />
/user/userid/.login<br />
Weitere Eigenschaften:<br />
Beenden der shell ist auch durch den Befehl logout möglich<br />
Bei jedem Beenden werden die Anweisungen in /etc/csh.logout und<br />
.logout <strong>im</strong> HOMEVerzeichnis<br />
ausgeführt
Übung 2a:<br />
Öffne eine zeichenorientierte Eingabeoberfläche innerhalb der graphischen<br />
Starte in dieser Eingabeoberfläche eine weitere Cshell und verlasse sie gleich<br />
wieder<br />
Starte eine LoginCshell<br />
Gib die Inhalte von .cshrc, .login und .history aus Deinem HOMEVerzeichnis auf<br />
dem Bildschirm aus<br />
Kann man erkennen, ob man in einer „normalen“ oder in einer Loginshell ist ?<br />
Bin ich in einer verschachtelten shell ?
Wichtige Tasten mit Funktion<br />
Enter ◄┘ sendet Zeichenfolge an die shell zur Interpretation<br />
Tabulator →| versucht ein angefangenes Kommando (1. Wort) bzw. einen<br />
angefangenen Dateinamen (als Ergänzung zu einem Befehl)<br />
zu ergänzen. Bietet ggf. eine Rechtschreibkorrektur an<br />
Backspace ← löscht in der Befehlszeile ein Zeichen links vom Cursor<br />
Im separaten Tastenblock:<br />
Pfeil auf ↑ zeigt sukzessive die letzten Befehle rückwärts an<br />
Pfeil ab ↓ geht von älteren zu neueren Befehlen<br />
Pfeil rechts → bewegt den Cursor in der Befehlszeile von links nach rechts<br />
Pfeil links ← bewegt den Cursor in der Befehlszeile von rechts nach links<br />
Im großen Block rechts oben:<br />
Entfernen Entf löscht Zeichen unter dem Cursor<br />
Pos 1 der Cursor springt zum Anfang der Zeile<br />
Ende der Cursor springt zum Ende der Zeile<br />
der Cursor springt <strong>im</strong> Output eine „Seite“ hoch<br />
der Cursor springt <strong>im</strong> Output eine „Seite“ nach unten<br />
Die Funktion vieler Tastenkombinationen (meist mit ) kann mit dem<br />
Befehl bindkey nachgesehen werden<br />
Manche o.a. Funktionen verlangen die geeignete Setzung von best. Variablen (später!)
Die shell erfüllt folgende Aufgaben:<br />
Interpretation der Zeicheneingabe<br />
Vereinfachung der Eingabe<br />
Gestaltung des Erscheinungsbilds, der Ausgabe<br />
Programmierter Ablauf von Befehlen<br />
Als Hilfsmittel stellt die shell zur Verfügung:<br />
Spezialzeichen mit Funktion<br />
Spezialzeichen, die andere Zeichen ersetzen können (Jokerzeichen)<br />
Variablen<br />
shellspezifische Befehle („builtin“ Befehle)<br />
Hier findet keine systematische Darstellung dieser 4 Hilfsmittel statt, sondern es wird<br />
– wie bisher ein übungsorientierter Zugang gewählt
Das Jokerzeichen<br />
* Ergänzt in einer Anweisung an die shell beliebig viele beliebige Zeichen (an<br />
Stellen, an denen eine mehrdeutige Angabe zulässig ist)<br />
Übung 2b: Liste alle Dateien auf, die <strong>im</strong> Verzeichnis /usr/bin mit „f“ anfangen<br />
Frage: Wieviele Dateien sind das?<br />
Wir erinnern uns an den UNIX Befehl wc, der .....<br />
.....Zeilen, Worte, Zeichen in einer Datei zählte<br />
Wie bekommen wir die Ausgabe des Befehls ls /usr/bin/* in eine Datei ?<br />
Das Spezialzeichen<br />
> leitet die Ausgabe eines Befehls, die für den Bildschirm („Standardoutput“)<br />
gedacht ist, um (Umleitungszeichen)<br />
befehl > datei wählt dafür die Datei datei<br />
Übung 2c: wieviele Dateien <strong>im</strong> Verzeichnis /usr/bin beginnen mit „f“ ?<br />
Einfacher geht es mit dem Spezialzeichen | (Erzeugen mit )<br />
bef1 | bef2 führt den Standardoutput von bef1 dem bef2 als Input zu<br />
(„pipe“Symbol von Pipeline)<br />
bef2 filtert den Output von bef1<br />
Übung 2d: Löse Übung 2c ohne eine Datei anzulegen!
Die restlichen Jokerzeichen:<br />
? Ersetzt in einer Anweisung an die shell genau ein beliebiges Zeichen (an Stellen,<br />
an denen eine mehrdeutige Angabe zulässig ist)<br />
Das ? kann mehrmals benutzt werden und auch in Verbindung mit dem * .<br />
Übung 2e: Liste alle Dateien aus /usr/bin auf, die mit f beginnen und genau<br />
5 Zeichen in Ihrem Namen haben<br />
[ a,f,2,+] Ersetzt in einer Anweisung an die shell genau ein beliebiges Zeichen (an<br />
Stellen, an denen eine mehrdeutige Angabe zulässig ist) aus der in den<br />
eckigen Klammern festgelegten durch Komma getrennten Auswahl<br />
Die Auswahl kann auch in Form einer Spanne eingegeben werden:<br />
[ a-f ,2-7,+]<br />
Die eckigen Klammern können mehrfach und in Verbindung mit den<br />
anderen Jokern genutzt werden. (Erzeuge mit bzw. )<br />
Beachte: „“ und „,“werden innerhalb der eckigen Klammern zum<br />
Spezialzeichen!<br />
Übung 2f: Liste alle Dateien aus /usr/bin auf, die mit a bis m und mit z beginnen<br />
Beachte: Jokerzeichen können auch für Verzeichnisnamen verwendet werden<br />
Liste bspw. alle Dateien mit f am Anfang und 5 Zeichen in allen Unterverzeichnissen<br />
von /usr auf: ls /usr/*/f????
Variable ist die Bezeichnung für einen Speicherplatz <strong>im</strong> Hauptspeicher<br />
Mit der shell (oder einem anderen Programm) vereinbare ich einen Namen für<br />
eine Variable und damit ist die Existenz der Variable und ein Speicherplatz<br />
festgelegt<br />
Eine Variable kann einen Wert (Inhalt) zugewiesen bekommen<br />
Die shell und andere Programme können spezielle Variablennamen abfragen<br />
In der Cshell gibt es 2 Typen von Variablen, die von der shell unterschieden<br />
werden: shellVariablen<br />
Umgebungsvariablen (Umgebung = Environment)<br />
�� Unterschied wird später geklärt<br />
Die Vereinbarung über eine Variable wird über ein builtinKommando getroffen:<br />
set name bei shell Variablen<br />
set name=wert ...mit Wert (vor und hinter dem = KEIN Leerzeichen!)<br />
setenv name wert bei Umgebungsvariablen (mit oder ohne Wert)<br />
Übung 2g: Gib set ein; filtere den Output ggf. mit dem UNIXBefehl more (Zur<br />
nächsten Seite mit der Leertaste)<br />
Mache das gleiche mit setenv<br />
Was fällt Dir auf?<br />
shellVariablen werden vereinbarungsgemäß mit Kleinbuchstaben<br />
Umgebungsvariablen mit Großbuchstaben geschrieben
Wie kann man den Wert einer einzelnen Variablen ausgeben?<br />
Mit dem builtinKommando<br />
echo $variablenname<br />
Ohne das $Zeichen ist der Output des Befehls die Zeichenfolge, die man eingibt<br />
$ ist eines der Spezialzeichen<br />
Übung 2h: Gib den Wert der Variablen HOME aus<br />
Gib das Wort HOME auf dem Bildschirm aus<br />
Die Umgebungsvariable HOME ist eine der Standardvariablen der Cshell und hat<br />
<strong>im</strong>mer den Wert des persönlichen Standardverzeichnisses
Warum gibt es 2 verschiedene Variablentypen ?<br />
shell Variablen gelten nur für die shell, in der die Variablen gesetzt wurden<br />
und vererben sich nicht<br />
Umgebungsvariablen vererben sich in verschachtelte shells<br />
Eine verschachtelte shell entsteht, wenn ich aus einer shell eine weitere shell aufrufe<br />
set abc=123<br />
echo $abc<br />
>123<br />
setenv DEF 345<br />
echo $DEF<br />
>345<br />
csh<br />
echo $abc<br />
>abc: Undefinierte Variable.<br />
echo $DEF<br />
>345<br />
Explizit geschieht das nun eher selten, <strong>im</strong>plizit aber bei jedem Programmaufruf<br />
Daher müssen alle Variablen, die von einem aufgerufenen Programm genutzt<br />
werden sollen, mit setenv gesetzt werden
Übung 2i: (Alle Aufgaben mit Erfolgskontrolle!)<br />
Setze eine shell Variable<br />
Gib ihr einen best<strong>im</strong>mten Wert (keine Leer und Sonderzeichen)<br />
Setze eine Umgebungsvariable mit einem Wert<br />
Setze eine Umgebungsvariable mit dem selben Namen, wie Du ihn für<br />
die shellVariable verwendet hast und gib ihr einen anderen Wert<br />
Was fällt Dir auf?<br />
Setze eine shellVariable mit dem selben Namen, wie Du ihn für die<br />
1. Umgebungsvariable verwendet hast und gib ihr einen anderen Wert<br />
Was fällt Dir auf?<br />
Öffne eine verschachtelte shell in der shell und frage den Wert der<br />
letztgenannten Variablen ab<br />
Verlasse die verschachtelte shell<br />
Lösche die erzeugten Variablen mit unset<br />
Lösche die erzeugten Variablen mit unsetenv
Um die Vererbung weiter zu üben, erinnern wir uns an Übung 2c/d (Folie 36):<br />
Übung 2j: Starte einen Editor (über Symbol anklicken oder mit kile in der<br />
Befehlszeile), schreibe die zwei Befehle aus Übung 2c untereinander<br />
und speichere unter beliebigem Namen.<br />
Gib diesen Namen in der BZ ein.<br />
Was passiert ? � Überprüfe ob die Datei vorhanden ist!<br />
Gib csh dateiname ein.<br />
Was passiert nun ? � Wenn Du nichts siehst, mach <strong>im</strong> Editor ein ◄┘hinter der<br />
2. Zeile und<br />
Gib csh dateiname erneut ein<br />
Mach dateiname zu einer ausführbaren Datei indem Du die Rechte<br />
änderst mit dem Befehl<br />
chmod a+x dateiname (Erfolgskontrolle)<br />
Gib dateiname ein.<br />
Übung 2k: Setze eine shell Variable namens abc und eine Umgebungsvariable<br />
namens UVW auf beliebige unterscheidbare Werte<br />
Erzeuge 2 ausführbare Dateien mit folgenden Inhalten:<br />
datei1: datei2:<br />
#!
Ergebnisse:<br />
Der UNIX Befehl ps gibt laufende Prozesse aus. Teste ihn mit den Optionen: auwx<br />
Die Datei mit der Leerzeile startet eine Bash (Bourne Again Shell; /bin/sh), die andere<br />
(vermöge der Angabe #!) eine Cshell<br />
Die Bash kann mit den (shell)Variablen shell und abc nichts anfangen, die<br />
Umgebungsvariable UVW hat sich vererbt<br />
In der Cshell bricht die Ausführung mit der nicht definierten shellVariable ab<br />
shell ist eine vom System bei jedem Start einer Shell definierte shellVariable, die als<br />
Wert den Namen der gestarteten Shell hat<br />
Dateien aus hintereinander aufgelisteten Befehlen nennt man ShellSkripte.<br />
Gibt man ihnen das Ausführungsrecht, sind sie wie normale Befehle zu verwenden<br />
ShellSkripte sind Programme mit speziellen Anweisungen zur bedingten und zur<br />
wiederholten Ausführung von Befehlen.<br />
Neben der Verwendung von Variablen sind Möglichkeiten zur bedingten und<br />
wiederholten Ausführung die zentralen Merkmale von „Programmierung“.
Zu den bereits bekannten „Standardvariablen“ HOME und shell sollen hier noch die<br />
folgenden bekannt gemacht werden:<br />
shlvl/SHLVL gibt die Tiefe der Verschachtelung von shells<br />
Übe es!<br />
path/PATH Liste der Verzeichnisse in denen nach ausführbaren Dateien<br />
gesucht wird<br />
user/USER account Name des Befehlsausführenden (synchronisiert)<br />
Übe normal und: su useriddesnachbarn c 'echo $user'<br />
edit Setzung ohne Wert ermöglicht Nutzung des Kommandozeileneditors<br />
prompt „Das Prompt“ ist die Zeichenkette, die ausgegeben wird, bevor man<br />
Befehle eintippen kann. Die Variable prompt besteht aus einer Kette<br />
von Zeichen, die vom Programm /usr/bin/tcsh zu einer Ausgabe<br />
verarbeitet werden.<br />
Die Bedeutung der Kontrollsequenzen sind in der bek. Doku zu finden<br />
Übe bspw.: set prompt=%d %D.%W.%Y><br />
HOST Netzname des Rechners auf dem man es eingibt<br />
Übe auch: ssh ......<br />
Auch eigene Programme können Variablen abfragen und auf ihren Inhalt reagieren.<br />
Welche Variablen können das nur sein?
ShellSkripte<br />
ShellSkripte sind Programme<br />
Die builtin Kommandos der shell sind Elemente einer Programmiersprache<br />
Es gibt kompilierte (FORTRAN, C) und interpretierte Programmsprachen<br />
Die Shell liefert eine interpretierte Sprache<br />
Manche builtin Kommandos können nur in Skripten eingesetzt werden,<br />
manche auch auf der Oberfläche<br />
builtin Kommandos öffnen bei ihrer Ausführung keine neue shell<br />
Es gibt die Möglichkeit Text zu kennzeichnen, der nicht interpretiert wird:<br />
� Kommentar / Kommentarzeile (wichtig !!)<br />
Nach der Zeichenkombination #! in der ersten interpretierten Zeile eines<br />
Skriptes steht der Name des interpretierenden Programms.<br />
Steht hinter #! nichts, so ist das interpretierende Programm /bin/csh, die<br />
Cshell<br />
Steht in der 1. Zeile kein #!, so ist /bin/sh das interpretierende Programm (bash)<br />
In allen anderen Zeilen wird Text hinter dem Zeichen # nicht interpretiert<br />
(Kommentar)<br />
Übung 2m: Kommentiere Deine 2 ShellSkripte aus Übung 2k sinnvoll<br />
(Teste!)
Ein einfaches ShellSkript, in dem UNIX oder builtin Kommandos sukzessive – Zeile<br />
für Zeile ausgeführt werden, haben wir schon geschrieben.<br />
Wir wollen nun ein builtin Kommando kennenlernen, das festgelegte Teile des<br />
Skriptes wiederholt ausführt:<br />
foreach variable ( Liste mit n Werten, die variable nacheinander ann<strong>im</strong>mt )<br />
# Die n Werte sind durch Leerzeichen voneinander getrennt<br />
# Beispiel: foreach varia ( a 345 uv )<br />
.......... # Hier stehen nun wieder<br />
.......... # sukzessive auszuführende Befehle<br />
end # Bezeichnet das Ende der „foreachSchleife“<br />
In der foreachAnweisung wird variable zunächst der erste (von links) der<br />
Werte der Liste zugewiesen. (set varia=a)<br />
Dann werden die „sukzessiv auszuführenden Befehle“ von oben nach unten<br />
ausgeführt<br />
Bei Erreichen des builtin Befehls end verzweigt die Ausführung zum foreach<br />
Variable wird auf den zweiten Wert der Liste gesetzt (set varia=345) und die<br />
Befehle werden erneut ausgeführt (Schleife)<br />
Die Schleife wird insgesamt „AnzahlderWerte“mal (= nmal) durchlaufen.<br />
variable kann von den Befehlen in der Schleife benutzt werden (Wie ist der Wert<br />
von variable zu referenzieren ?)<br />
Übung 2n: Schreibe ein Skript, das die Zahlen 2, 3, 7, 12 untereinander schreibt.<br />
Diese Spalte soll 3x untereinander geschrieben werden.
foreach variable ( Liste mit n Werten, die variable nacheinander ann<strong>im</strong>mt )<br />
# Die n Werte sind durch Leerzeichen voneinander getrennt<br />
# Beispiel: foreach varia ( a 345 uv )<br />
.......... # Hier stehen nun wieder<br />
.......... # sukzessive auszuführende Befehle<br />
end # Bezeichnet das Ende der „foreachSchleife“<br />
foreachSchleifen können ineinander verschachtelt sein<br />
Be<strong>im</strong> Auftreffen auf eine innere foreachSchleife wird zunächst diese abgearbeitet<br />
Führt die äußere Schleife einen das nächste Mal zur inneren wird sie wieder ganz<br />
abgearbeitet<br />
Es ist oft sinnvoll, den Output eines in `...` ausgeführten Befehls als Liste_mit_Werten zu<br />
verwenden.<br />
Übung 2o: Schreibe ein Skript, das die Dateien des aktuellen Verzeichnisses untereinander<br />
(eine Datei pro Zeile; ohne Auflistung der Rechte) auflistet
foreach variable ( Liste mit n Werten, die variable nacheinander ann<strong>im</strong>mt )<br />
.......... # Hier stehen nun wieder<br />
.......... # sukzessive auszuführende Befehle<br />
end # Bezeichnet das Ende der „foreachSchleife“<br />
Abweichungen vom obigen Ablauf können programmiert werden durch die builtin<br />
Kommandos:<br />
break bricht die Schleifenabarbeitung komplett ab (verzweigt hinter das end)<br />
continue (springt zum end und) setzt die Verarbeitung mit dem nächsten Wert<br />
der Liste fort<br />
Diese beiden Kommandos werden sinnvoll nur in bedingter Ausführung eingesetzt<br />
Ein builtin zur bedingten Ausführung wird später behandelt<br />
Recht umständlich ist es, mit der foreachSchleife eine a priori festgelegte Anzahl von<br />
Durchläufen zu formulieren. Ein Trick ist da:<br />
Bsp.: foreach NUM ( ` repeat 100 echo x ` )<br />
.......<br />
end<br />
Warum (nur?) der repeatBefehl in `..` ausgeführt den Output „Abbruch“ liefert, konnte ich bisher nicht ermitteln<br />
Eleganter läßt sich das Problem mit einer whileSchleife lösen (später)
Für die nächste Übung wollen wir ein weiteres builtin Kommando (arbeitet nur in<br />
Skripten!) kennenlernen:<br />
@ variable = arithmetischer_oder_logischer_ausdruck<br />
Bsp. Arithmetischer Ausdruck: $variable1 + $variable2<br />
� Die Variablen müssen ganze Zahlen als Wert haben<br />
����Die Variablen können durch Konstanten (1, 2, 3976,...) ersetzt werden<br />
Bsp. Logischer Ausdruck : ( $variable1 >= $variable2 )<br />
( $variable1 == $variable2 )<br />
���Der Operator == prüft auf Gleichheit<br />
Dieses Kommando wertet den Ausdruck auf der rechten Seite des<br />
Zuweisungszeichens („=“) aus und weist den Wert der Variablen links davon zu<br />
Wichtig sind hier die Leerzeichen: hinter dem @<br />
vor/hinter den Operatoren<br />
Frage: Welche Ergebnisse können logische Ausdrücke haben?<br />
Sie haben 0 (falsch) oder 1 (richtig) als Ergebnis<br />
Übung 2p: Schreibe ein Skript, das einen <strong>im</strong> Skript festgelegten Wert einer Variablen<br />
um 5 erhöht und das Ergebnis auf der gleichen Variablen abspeichert.<br />
Übung 2q: Verbinde Übung 2o und 2p und schreibe ein Skript, das die Dateien aus<br />
dem Verzeichnis /usr/bin, die mit „f“ anfangen, von 1 bis ...<br />
durchnummeriert auflistet.
Für die nächsten Übungen lernen wir eine weitere Spezialvariable kennen, die nur<br />
in ShellSkripten existiert. Ihr Name: 1. Sie hat als Wert das 1. Argument, das dem<br />
ShellSkript bei der Ausführung hinzugegeben wird.<br />
Bsp.: skriptname 1.argument<br />
Implizit wird damit ein set 1=1.argument <strong>im</strong> Skript gemacht<br />
Explizit ist das nicht zulässig, kann es nicht sein ! ....warum ??<br />
Weil Variablennamen nicht mit Ziffern beginnen dürfen<br />
Entsprechend können weitere Argumente mit den Namen 2, 3, ..... abgerufen<br />
werden. (Bsp.: myskri abc 123 z)<br />
Die einzelnen Argumente sind durch Leerzeichen zu trennen.<br />
Soll ein Argument ein Leer oder Sonderzeichen beinhalten, so ist es seiner<br />
Funktion durch entsprechende Spezialzeichen zu entheben.<br />
Die Spezialvariable 0 (=null) hat als Wert den SkriptNamen, der als 0. Argument<br />
interpretiert wird<br />
Übung 2r: Gib das 1. Argument eines ShellSkriptes auf dem Schirm aus<br />
Gib das 2., 3., ....... und das 0. Argument ............
Eine weitere wichtige Programmstruktur ist die bedingte Ausführung. Dafür bedient<br />
man sich des builtin Kommandos if :<br />
if ( wert ) bedingt_auszuführender_befehl<br />
Der bedingt_auszuführende_befehl wird ausgeführt, wenn<br />
wert ungleich Null ist.<br />
wert kann gewonnen werden durch<br />
eine Variable (oder Zahl)<br />
einen arithmetischen Ausdruck<br />
einen logischen Ausdruck<br />
Ausführen eines Befehls (wenn das Ergebnis eine Zahl ist)<br />
Bei logischen Ausdrücken ist das Ergebnis ungleich Null, wenn<br />
die Aussage richtig ist.<br />
Übung 2s: Schreibe ein Skript, das einen beliebigen Befehl (bspw. echo Hallo) in<br />
Abhängigkeit vom 1.Argument des Skriptes ausführt<br />
Mit dem builtin endif kann man aus if und endif eine Klammerung konstruieren,<br />
innerhalb derer mehrere Befehle zur bedingten Ausführung aufgelistet werden.<br />
Der Befehl in der Zeile mit dem if wird dann durch ein then ersetzt:<br />
Bsp.: if ( wert ) then<br />
...... # bedingt auszuführende Befehle,<br />
...... # die sukzessive 1mal ausgeführt werden<br />
endif<br />
Übung 2t: Ändere Dein Programm aus Übung 2s ab in die if ... endif Struktur
Mit dem builtin else kann man innerhalb einer if ... endif Struktur eine<br />
alternative Ausführung formulieren:<br />
Bsp.: if ( wert ) then<br />
........ # Befehle, die bei wert ungleich 0 ausgeführt werden<br />
else<br />
........ # Befehle, die bei wert gleich 0 ausgeführt werden<br />
endif<br />
Übung 2u: Ändere Dein Programm aus Übung 2t ab, derart, daß es 2 alternative<br />
Befehle in Abhängigkeit vom 1. Argument ausführt<br />
Ferner ist es möglich, alternative Bedingungen zu formulieren mit dem builtin else if:<br />
Bsp.: if ( wert1 ) then<br />
........ # Befehle, die bei wert1 ungleich 0 ausgeführt werden<br />
else if ( wert2 ) then<br />
........ # Befehle, die bei wert1 gleich 0 und wert2 ungleich 0<br />
# ausgeführt werden<br />
else if .....<br />
........<br />
else<br />
........<br />
endif<br />
Übung 2v: Ändere Dein Programm aus 2u ab, derart, daß 4 alternative Befehle<br />
ausgeführt werden in Abhängigkeit des 1. Arguments
Die whileSchleife verbindet wiederholte und bedingte Ausführung:<br />
Bsp.: while ( wert )<br />
.......... # Hier stehen nun wieder<br />
.......... # sukzessive auszuführende Befehle<br />
end # Bezeichnet das Ende der „whileSchleife“<br />
Die sukzessive auszuführenden Befehle werden ausgeführt, wenn<br />
wert ungleich Null ist.<br />
Bei Erreichen des end verzweigt der Ablauf zurück zum while<br />
wert kann gewonnen werden durch<br />
eine Variable (oder Zahl)<br />
einen arithmetischen Ausdruck<br />
einen logischen Ausdruck<br />
Ausführung eines Befehls wenn das Ergebnis eine Zahl ist<br />
Bei logischen Ausdrücken ist das Ergebnis ungleich Null, wenn<br />
die Aussage richtig ist.<br />
Für das Ende der Schleife muß der Programmierer sorgen! Durch<br />
Veränderung des Ergebnisses von wert innerhalb der Schleife oder<br />
durch Veränderung der Werte seiner Komponenten, wenn wert durch einen<br />
Ausdruck gebildet wird<br />
durch break (wie in der foreachSchleife)<br />
Übung 2w: Schreibe die Zahlenfolge 100, 99, 98 ...... untereinander bis 0 auf den<br />
Schirm
Unterschiedliche Eigenschaften von Dateien lassen sich mit unseren bisherigen<br />
Möglichkeiten nur schwer für die Formulierung bedingter Ausführungen nutzen.<br />
Dies erleichert das builtin filetest (auch in der Befehlszeile ausführbar).<br />
filetest bietet 41 Optionen, um Zustände von Dateien abzufragen.<br />
Bsp.: filetest x meine_datei # fragt ab, ob meine_datei ausführbar ist<br />
Falls meine_datei ausführbar ist, liefert der Befehl als StandardOutput eine „1“<br />
andernfalls eine „0“.<br />
Das ist eine ideale Voraussetzung für die Benutzung in ifAbfragen.<br />
Bsp.: if ( `filetest x meine_datei ` ) then<br />
.......<br />
endif<br />
Übung 2x: Schreibe ein Skript mit dem Du für eine beliebige Datei, deren Namen<br />
Du als Argument bei der SkriptAusführung eingibst, die Ausführbarkeit<br />
testen kannst (nicht für Verzeichnisse)<br />
Beachte die Liste der möglichen Optionen für filetest<br />
Beachte die Liste der Operatoren für arithmetische und logische Ausdrücke<br />
Beachte, daß bei filetest sinnvolle Kombinationen von Optionen zulässig sind
Zum Abschluß des Abschnitts über die shell Programmierung und die builtins noch<br />
ein Kommando, das weniger in shellSkripten als vielmehr für Dateien mit shell<br />
Kommandos Anwendung findet.<br />
Das builtin source liest Befehle aus einer <strong>im</strong> 1.Argument genannten Datei und führt<br />
sie in der aktuellen shell aus.<br />
Bsp.: source datei_mit_shell_befehlen<br />
Unterschied zur bisher geübten Ausführung: es wird keine neue shell geöffnet<br />
Das betrifft vor allem Variablenvereinbarungen<br />
Übung2y: � Schreibe ein Skript, das eine shell und eine Umgebungsvariable<br />
setzt und deren Werte auf dem Schirm ausgibt<br />
� Führe das skript aus und gib danach in der shell die Werte der<br />
benannten Variablen aus<br />
� Führe nun<br />
source skript_datei<br />
aus und gib danach in der shell die Werte der benannten<br />
Variablen aus<br />
Beachte: die o.g. Ausführungsreihenfolge der Übung ist exakt<br />
einzuhalten. Kann das nicht eingehalten werden, so ist in<br />
einer neuen shell neu zu beginnen
Neben dem bisher benutzten Editor auf graphischer Basis gibt es in UNIX einen<br />
prominenten zeichenbasierten Editor.<br />
Aufruf: vi datei (datei kann eine bestehende oder neue Datei sein)<br />
Übung 3a: Bitte Aufruf vollziehen und die folgenden Aktionen nachmachen<br />
Es gibt einen Befehls und einen EingabeModus<br />
Nach dem Start befindet man sich <strong>im</strong> Befehlsmodus<br />
In den Eingabemodus gelangt man durch Befehle, bspw. durch<br />
i läßt Text links vom Cursor einfügen<br />
� Gib Text ein!<br />
Die enter Taste schreibt das newline Zeichen (ASCII 10)<br />
Dies wird in der Umgebung des vi als Zeilenumbruch interpretiert<br />
In den Befehlsmodus gelangt man durch die Taste Esc.<br />
Man speichert die Datei durch den Befehl :w („write“)<br />
Man verläßt den Editor durch den Befehl :q („quit“)<br />
Mehrere Befehle können sinnvoll kombiniert werden. Bspw. :wq (aber nicht :qw)<br />
..........wir haben unsere erste Datei mit „dem vi“ geschrieben
Es gibt Befehle mit Doppelpunkt ( : ) am Anfang<br />
Sie werden links unten angezeigt<br />
Sie werden mit abgeschlossen<br />
Es gibt auch Befehle, die ohne : eingegeben werden<br />
Sie bestehen nur aus einem oder mehreren Buchstaben und ggf. Zahlen<br />
Befehle aus mehreren Zeichen kann man (bei Fehleingabe) durch Esc löschen.<br />
Wichtige solche Befehle sind (case sensitive):<br />
x löscht ein Zeichen unter dem Cursor und schreibt es in einen Speicher<br />
dd löscht die Zeile unter dem Cursor und schreibt sie in einen Speicher<br />
���Die Befehle können durch vorgestellte Zahlen in ihrer Funktion vervielfacht werden<br />
p fügt den Inhalt des Speichers unterhalb/rechts vom Cursor ein<br />
P fügt den Inhalt des Speichers oberhalb/links vom Cursor ein<br />
r überschreibt das Zeichen unter dem Cursor mit dem auf r folgenden Zeichen<br />
� Der Editor verbleibt <strong>im</strong> Befehlsmodus<br />
R überschreibt Text ab dem Cursor<br />
� Der Editor verbleibt <strong>im</strong> Eingabemodus<br />
J löscht das newlineZeichen am Ende der Zeile (verbindet 2 Zeilen; „join“)<br />
u macht die letzte Veränderung rückgängig (mehrfach anwendbar)
Die Befehle :w und :q kennen Ergänzungen zur Funktionsveränderung:<br />
:q! Der Editor wird auf jeden Fall und ohne Speicherung des seit der letzten<br />
Sicherung Veränderten verlassen<br />
:w! datei Die vorhandene datei wird in jedem Fall überschrieben<br />
Ist nötig, wenn ich den Inhalt des Editors unter einem anderen Namen als<br />
be<strong>im</strong> Aufruf speichern möchte<br />
/zeichenkette durchsucht den EditorInhalt nach zeichenkette und setzt den Cursor<br />
auf den ersten Fundort von der aktuellen Position nach unten<br />
(Befehl wird angezeigt und ist mit backspace Taste korrigierbar)<br />
n sucht nach dem nächsten Auftreten nach unten (nicht angezeigt)<br />
Wenn das Ende einer Datei erreicht ist, wird oben weitergesucht („wrap“)<br />
?zeichenkette durchsucht den EditorInhalt nach zeichenkette und setzt den Cursor<br />
auf den ersten Fundort von der aktuellen Position nach oben<br />
N sucht nach dem nächsten Auftreten nach oben<br />
:n,m s/muster1/muster2/<br />
durchsucht den EditorInhalt von Zeile n bis Zeile m nach muster1,<br />
ersetzt dieses durch muster2 und setzt den Cursor auf den letzten Fundort<br />
Oft taucht der „/“ in muster auf. Dann sind die „/“ in der Befehlseingabe durch ein<br />
beliebiges 3mal gleiches Zeichen zu ersetzen, das nicht in muster vorkommt.<br />
Nach Eingabe des : <strong>im</strong> Befehlsmodus kann man die letzten Befehle mit den ↑ ↓<br />
Tasten durchscrollen