28.02.2013 Aufrufe

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

MEHR ANZEIGEN
WENIGER ANZEIGEN

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 />

WEB­Hilfen:<br />

http://www2.meteo.uni­bonn.de/intern/computer/index.htm<br />

http://www2.meteo.uni­bonn.de/mitarbeiter/TBurkhardt/vorlesungen_TB.html<br />

http://faq.meteo.uni­bonn.de<br />

Verfügbare Computer:<br />

Raum 102 (Seminar­/PC­Raum); 20 Terminals an Terminal­Server;<br />

Raum 103 (Lesesaal; 12 Terminals an Terminal­Server;<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 C­shell<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 />

Windows­Anwendungen<br />

Rechner­Cluster 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.uni­bonn.de“)<br />

Nummer einzelner Rechner (1­254)<br />

r003d.meteo.uni­bonn.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.uni­bonn.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.uni­bonn.de, bei Volltextsuche: WLAN eingeben<br />

Firewall : miubgate.meteo.uni­bonn.de Zugangsdaten: M. Mertes<br />

Kabelanschluß : bei Netzwerkverbindung DHCP (Dynamic Host Configuration<br />

(muss freige­ Protocol) einstellen ==> IP­Adresse 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 (User­ID) 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 e­mail 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, DIN­A3)<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 DVD­Schreiber<br />

Stick am Pult­PC einsetzen<br />

Windows­Terminal Server:<br />

Auf allen Rechnern : WTS­Session; 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 Boot­Manager 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 Alt­F1 oder Alt­F2 .... bis ­F6<br />

befehlszeilenorientiert ­­>> graphisch : drücke Taste Alt­F7<br />

graphisch ­­>> befehlszeilenorientiert : drücke Tastenkombination Alt­Strg­F1 (...­F2,...<br />

graphisch ­­>> graphisch : drücke Strg­F1, Strg­F2, ...


Graphische Oberflächen basieren in LINUX auf X­Windows (MIT, 1984)<br />

http://de.wikipedia.org/wiki/X_Window_System<br />

= bitmapbasierte (rastergraphikbasierte) Bildschirmdarstellung<br />

Das Bitmap (grau­weisser Bildschirm) ist der X­Server der verschiedenen X­Clients<br />

als Grundlage dient.<br />

Der X­Server kann <strong>im</strong>mer nur einmal auf einem Rechner gestartet werden<br />

Als erster Client wird ein Fenster­Manager gestartet, der die Anmeldemaske<br />

liefert.<br />

Die Rechte an dem X­Server werden dem Benutzer übertragen, der sich<br />

anmeldet.<br />

Diese gewähren jedem an diesem Rechner von diesem Benutzer gestarteten<br />

X­Client 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 „Strg­D“ 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 0­255<br />

daraus über ASCII­Tabelle 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 Standard­Bibliotheken<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: Web­Browser<br />

Mail­Client<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 User­ID<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 Text­Teile 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 user­id@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 user­id@fremder_rechner :entfernte_datei lokale_datei<br />

Umkehrung der o.g. Fernkopie<br />

scp ­r lokales_verzeichnis user­id@fremder_rechner :entferntes_verzeichnis<br />

scp ­r user­id@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/user­id (ersetze user­id durch Deine user­id = Benutzernamen)<br />

ein Verzeichnis und in diesem ein Unterverzeichnis und eine Datei mit beliebigem<br />

Namen und mit dem Inhalt der Datei /user/user­id/.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.user­id


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 user­id@rechnername meldet den Benutzer user­id an dem Rechner<br />

rechnername an. Das ­X ermöglicht den Start<br />

von X­clients auf dem fremden Rechner und die<br />

Anzeige auf dem lokalen X­Server<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 C­shell<br />

Eine shell ist ein Programm, wird gestartet wie ein Programm, hat man­pages<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 shell­Start werden die Anweisungen in den Dateien<br />

/etc/csh.cshrc<br />

/user/user­id/.cshrc (/user/user­id ist das sog. HOME­Verzeichnis)<br />

in dieser Reihenfolge ausgeführt<br />

Sie gestalten die Arbeitsumgebung<br />

Zusätzlich wird die Datei .history aus dem HOME­Verzeichnis geladen, um die letzten<br />

eingegebenen Befehle für die Pfeil­Tasten 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 Login­shell gestartet, wodurch 2 zusätzliche Dateien ausgeführt<br />

werden. Reihenfolge: /etc/csh.cshrc<br />

/etc/csh.login<br />

/user/user­id/.cshrc<br />

/user/user­id/.history<br />

/user/user­id/.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> HOME­Verzeichnis<br />

ausgeführt


Übung 2a:<br />

Öffne eine zeichenorientierte Eingabeoberfläche innerhalb der graphischen<br />

Starte in dieser Eingabeoberfläche eine weitere C­shell und verlasse sie gleich<br />

wieder<br />

Starte eine Login­C­shell<br />

Gib die Inhalte von .cshrc, .login und .history aus Deinem HOME­Verzeichnis auf<br />

dem Bildschirm aus<br />

Kann man erkennen, ob man in einer „normalen“ oder in einer Login­shell 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 />

shell­spezifische 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 C­shell gibt es 2 Typen von Variablen, die von der shell unterschieden<br />

werden: shell­Variablen<br />

Umgebungsvariablen (Umgebung = Environment)<br />

�� Unterschied wird später geklärt<br />

Die Vereinbarung über eine Variable wird über ein builtin­Kommando 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 UNIX­Befehl more (Zur<br />

nächsten Seite mit der Leertaste)<br />

Mache das gleiche mit setenv<br />

Was fällt Dir auf?<br />

shell­Variablen werden vereinbarungsgemäß mit Kleinbuchstaben<br />

Umgebungsvariablen mit Großbuchstaben geschrieben


Wie kann man den Wert einer einzelnen Variablen ausgeben?<br />

Mit dem builtin­Kommando<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 C­shell 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 shell­Variable verwendet hast und gib ihr einen anderen Wert<br />

Was fällt Dir auf?<br />

Setze eine shell­Variable 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 C­shell<br />

Die Bash kann mit den (shell­)Variablen shell und abc nichts anfangen, die<br />

Umgebungsvariable UVW hat sich vererbt<br />

In der C­shell bricht die Ausführung mit der nicht definierten shell­Variable ab<br />

shell ist eine vom System bei jedem Start einer Shell definierte shell­Variable, die als<br />

Wert den Namen der gestarteten Shell hat<br />

Dateien aus hintereinander aufgelisteten Befehlen nennt man Shell­Skripte.<br />

Gibt man ihnen das Ausführungsrecht, sind sie wie normale Befehle zu verwenden<br />

Shell­Skripte 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 user­id­des­nachbarn ­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?


Shell­Skripte<br />

Shell­Skripte sind Programme<br />

Die built­in 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 built­in Kommandos können nur in Skripten eingesetzt werden,<br />

manche auch auf der Oberfläche<br />

built­in 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 />

C­shell<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 Shell­Skripte aus Übung 2k sinnvoll<br />

(Teste!)


Ein einfaches Shell­Skript, in dem UNIX­ oder built­in Kommandos sukzessive – Zeile<br />

für Zeile ­ ausgeführt werden, haben wir schon geschrieben.<br />

Wir wollen nun ein built­in 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 „foreach­Schleife“<br />

In der foreach­Anweisung 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 built­in 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 „Anzahl­der­Werte“mal (= n­mal) 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 „foreach­Schleife“<br />

foreach­Schleifen können ineinander verschachtelt sein<br />

Be<strong>im</strong> Auftreffen auf eine innere foreach­Schleife 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 „foreach­Schleife“<br />

Abweichungen vom obigen Ablauf können programmiert werden durch die built­in<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 built­in zur bedingten Ausführung wird später behandelt<br />

Recht umständlich ist es, mit der foreach­Schleife 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 repeat­Befehl in `..` ausgeführt den Output „Abbruch“ liefert, konnte ich bisher nicht ermitteln<br />

Eleganter läßt sich das Problem mit einer while­Schleife lösen (später)


Für die nächste Übung wollen wir ein weiteres built­in 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 Shell­Skripten existiert. Ihr Name: 1. Sie hat als Wert das 1. Argument, das dem<br />

Shell­Skript 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 Skript­Namen, der als 0. Argument<br />

interpretiert wird<br />

Übung 2r: Gib das 1. Argument eines Shell­Skriptes 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 built­in 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 built­in 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 while­Schleife 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 „while­Schleife“<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 foreach­Schleife)<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 built­in 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 Standard­Output eine „1“<br />

andernfalls eine „0“.<br />

Das ist eine ideale Voraussetzung für die Benutzung in if­Abfragen.<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 Skript­Ausfü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 built­ins noch<br />

ein Kommando, das weniger in shell­Skripten als vielmehr für Dateien mit shell­<br />

Kommandos Anwendung findet.<br />

Das built­in 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 Eingabe­Modus<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 newline­Zeichen 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 Editor­Inhalt 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 Editor­Inhalt 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 Editor­Inhalt 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

Hurra! Ihre Datei wurde hochgeladen und ist bereit für die Veröffentlichung.

Erfolgreich gespeichert!

Leider ist etwas schief gelaufen!