tag:blogger.com,1999:blog-83086900293539438262024-02-21T08:28:06.309-08:00Linux Shell blogGeisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.comBlogger34125tag:blogger.com,1999:blog-8308690029353943826.post-84944189510265704552010-12-31T06:26:00.000-08:002010-12-31T06:26:43.892-08:00Das beste zum Schluß? oder: Der Sony-DVD-Recorder vs. GNU/LinuxNein, 2010 lasse ich ruhig ausklingen. Und bevor reingefeiert wird, liegt mir eine ominöse Datei vor, für die wahrscheinlich ein Sony-Gerät verantwortlich ist. Es geht um einen Film, der als DVD gebrannt wurde. Legt man das Original in das Laufwerk ein, so sieht man aber nur einen leeren "VIDEO_TS"-Ordner.<br />
<br />
Um mehrere Kopien anzulegen, habe ich ein Image mittels ImageBurn ausgelesen (ja, unter Linux! Dieses Windows-Programm läuft perfekt durch Wine und erkennt auch alle DVD-Laufwerke im Rechner).<br />
Es liegen also folgende Dateien vor:<br />
<br />
<code><br />
/home/Videos/SONY_DVD_RECORDER_VOLUME.mds<br />
/home/Videos/SONY_DVD_RECORDER_VOLUME.bin<br />
</code><br />
<br />
Damit möchte ich nun weiter arbeiten. Das Original-Medium fasse ich erst garnicht mehr an -- wer weiß, was Sony da wieder für einen Mist fabriziert hat... Eigentlich möchte ich aus den oben genannten Dateien eine ISO erstellen. Nach einem google-Unser stoße ich auf tools wie <b>ccd2iso</b> und <b>bchunk</b>. Diese Kommandozeilentools probiere ich aus, aber ein Umwandeln scheint nicht möglich (cue-file fehlt usw).<br />
<br />
Bevor ich mich weiter mit diesen Programmen beschäftige, fällt mir <b>Furius ISO Mount </b>ins Auge. Ich starte, un wähle die extrahierte bin-Datei (siehe oben) aus. Das mounten funktioniert ohne Probleme. Und das beste: die Inhalte der DVD sind nun sichtbar:<br />
<br />
<code><br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/video_ts.bup<br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/video_ts.ifo<br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/video_ts.vob<br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/vts_01_0.bup<br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/vts_01_0.ifo<br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/vts_01_1.vob<br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/vts_02_0.bup<br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/vts_02_0.ifo<br />
/home/chris/SONY_DVD_RECORDER_VOLUME_bin/video_ts/vts_02_1.vob<br />
</code><br />
<br />
Ab hier kann ich nun mit einem Videoprogramm meiner Wahl weiter arbeiten.Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-79445851206687358772010-07-18T14:26:00.000-07:002010-07-18T14:26:05.592-07:00MP3-Dateien schneiden mit mp3cut in der linux shellEs geht um ein tool, das einem das Zurechtschneiden (cutten) von mp3-files ermöglicht.<br />
<code><br />
sudo apt-get install poc-streamer<br />
</code><br />
Danach steht einem das tool mp3cut zur Verfügung. Hiermit kann man einfach ein mp3-file beschneiden. Ich habe es aktuell verwendet, um einen Klingelton aus einem Lied zu erstellen. Gerade dort kann man ein längeres intro nicht gebrauchen, sondern möchte gerne den refrain als eigentlichen Klingelton hören.<br />
<br />
Folgende Anleitung bekommt man präsentiert, wenn man nur <b>"mp3cut" </b>auf der Kommandozeile eingibt:<br />
<ausgabe><br />
Usage: mp3cut [-o outputfile] [-T title] [-A artist] [-N album-name] [-t [hh:]mm:ss[+ms]-[hh:]mm:ss[+ms]] mp3 [-t ...] mp3 -o output: Output file, default mp3file.out.mp3<br />
</ausgabe><br />
Ein Beispiel, um das Lied Testlied_1_extended_version.mp3 zu beschneiden, sähe so aus:<br />
<eingabe><br />
mp3cut -o Testlied_1_kurz.mp3 -t 00:50-03:43 Testlied_1_extended_version.mp3<br />
</eingabe>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-81356225119478041962010-05-29T21:39:00.000-07:002010-05-29T21:40:27.118-07:00Audio-CD extrahieren mit LinuxSeit langem mal wieder eine <b>Audio-CD extrahiert </b>und zu MP3 konvertiert. Womit sollte man arbeiten? Es bietet sich zum Beispiel "<b>Sound Juicer</b>" an. Leider bemerken viele, oft erst nachdem man mehrere CDs ausgelesen hat, dass die Qualität bei konstanten <b>128kb/Sekunde</b> liegt. Das ist eine zu geringe Datenrate. Grund ist die folgende Voreinstellung für das Profil "<i>CD-Quality, MP3 (.mp3-type)</i>".<br />
<br />
Grundeinstellung (so, oder so ähnlich):<br />
<code>audio/x-raw-int,rate=44100,channels=2 ! lame name=enc mode=4 vbr-quality=6 ! id3v2mux</code><br />
<br />
Wir ändern das Profil einfach auf folgenden Wert (Bearbeiten -> Einstellungen -> Profile editieren):<br />
<br />
Verbesserte Einstellung:<br />
<code>audio/x-raw-int,rate=44100,channels=2 ! lame name=enc mode=0 vbr=4 vbr-quality=2 ! xingmux ! id3v2mux</code>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-37554070263789555782010-05-06T03:02:00.000-07:002010-05-06T04:20:55.079-07:00Dateien umbenennen mit der Linux-shell<b>Szenario 1:</b> Musikdateien (z.B. best-off, Musikmix) auf MP3-Player haben teilweise Titelnummern am Anfang, die wir bei der best-off-Sammlung nicht gebrauchen können. Daher soll alles (auch Sonderzeichen) bis zum ersten Buchstaben(!) gelöscht werden.<br />
<eingabe><br />
rename -v 's/^[^a-zA-Z]*//' *.mp3<br />
</eingabe><br />
<b>Erläuterung: </b><br />
Es wird nach allem gesucht, was am Anfang(^-Symbol <b>vor</b> der eckigen Klammer) des Dateinamens keine (^-Symbol <b>innerhalb</b> der Klammer) Buchstaben (groß oder klein) aufweist.<br />
-v steht für verbose und gibt alles aus, was der Befehl "rename" ausführt<br />
-n kann als Option angegeben, wenn man erstmal testen möchte, was passieren wird. Es werden keine Dateien umbenannt!<br />
<b><br />
</b><br />
<hr /><b>Szenario 2:</b> Allen Dateien soll etwas vorangestellt werden.<br />
In folgendem Beispiel wird "file_" vor jede bestehende Dateibezeichnung im aktuellen Verzeichnis gesetzt.<br />
Der komplette Dateiname wird durch .* in der Variablen $1 gespeichert. Dann wird dieser komplett durch file_ und den ehemaligen Dateinamen ersetzt.<br />
<eingabe><br />
rename -n 's/(.*)/file_$1/' *<br />
</eingabe><br />
Falls beispielsweise nur mp3-Dateien geändert werden sollen, wird der Befehl wie folgt abgeändert: <br />
<eingabe><br />
rename -n 's/(.*)/file_$1/' *.mp3<br />
</eingabe><br />
Achtung, mit dem regulären Ausdruck <b>.*</b> muss vorsichtig umgegangen werden. Dazu später mehr.<br />
<hr /><a name='more'></a><br />
Ein umbennennen kann auch mit sed erfolgen. Dies und weitere Infos auf folgender Seite: <a href="http://tips.webdesign10.com/how-to-bulk-rename-files-in-linux-in-the-terminal">http://tips.webdesign10.com/how-to-bulk-rename-files-in-linux-in-the-terminal</a>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-23431410719142186352010-04-26T11:52:00.000-07:002010-04-26T12:08:39.984-07:00Input und Output - Linux Shell TutorialDie folgenden Beiträge möchte ich verstärkt die basics der Linux Shell erläutern, da es dazu immer wieder Fragen an mich gibt. Bitte <b>klicken Sie auf den folgenden Link</b>, um den gesamten Beitrag zu sehen!<br />
<a name='more'></a><br />
<br />
<b>feste Variablen/Befehle</b><br />
<br />
Ausführbare Programme der shell sind typischerweise im Verzeichnis /bin gespeichert. <br />
Es gibt weiterhin fest eingebaute Befehle der shell, wie z.B. <b>echo oder printf</b>. Hierzu sei angemerkt, dass printf viel mächtiger als echo ist.<br />
<br />
Es gibt wie in fast allen Programmiersprachen Variablen, denen Werte zugeordnet werden können. Um auf den Wert der Variablen zuzugreifen, wird ein $-Zeichen vorangestellt. Eine einfache Zuweisung sieht wie folgt aus: <br />
<eingabe><br />
var1=40;<br />
var2=abc;<br />
</eingabe><br />
Die Ausgabe kann wie folgt durchgeführt werden:<br />
<eingabe><br />
echo $var1<br />
printf "$var2"<br />
</eingabe><br />
<br />
Auf Werte aus der Kommandozeile (evtl übergeben oder aus listings) können über $1, $2, $3, $4,.... zugegriffen werden.<br />
<br />
<skript><br />
#!/bin/bash<br />
printf "Hallo Argument 1: %s!\n" "$1"<br />
printf "Argument 2: $2"<br />
</skript><br />
<br />
Nun probieren wir das obige shellskript aus:<br />
<eingabe>$ ./hello test_1 test_2<br />
</eingabe><br />
<ausgabe><br />
Hallo Argument 1:, test_1!<br />
Argument 2: test_2<br />
</ausgabe><br />
Damit auch Zahlen-Variablen erkannt werden, die zweistellig sind, sollte man sich an folgende Schreibweise gewöhnen: ${10} ${42}<br />
<hr /><b>Arguments and Options - Argumente und Optionen</b><br />
<br />
Argumente werden übergeben, indem sie bei Aufruf des Programms über die Kommandozeile hinter dessen Namen angegeben werden. Die Reihenfolge fängt mit $1 an und zählt jeweils um 1 hoch ($2,$3,$4,...). Eine Trennung erfolgt durch Leerzeichen. Um Argumente zu übergeben die ein Leerzeichen enthalten, muss diesem ein backslash vorangestellt werden. Alternativ kann man eine Gruppierung durch Anführungszeichen markieren.<br />
<br />
<eingabe><br />
./programm_0 das sind mehrere Argumente<br />
./programm_1 das\ ist\ ein\ einziges\ Argument<br />
./programm_2 "das ist ein argument"<br />
printf "%s %s" test1 "wir gehoeren zusammen"<br />
printf "%s %s" test1 'Ja ich bin nur ein Argument'<br />
</eingabe><br />
<br />
Optionen werden standartmäßig mit zwei oder einem (Kurzform) vorangestellten Minuszeichen übergeben (vgl "bash --version"). Zusätzlich zu einer Option wird oft ein weiteres Argument erwartet (vlg "cp -t verzeichnis_1" ist identisch mit "cp --target-directory=verzeichnis_1").<br />
<br />
Beispielskript um eine Versionsausgabe nach Optionsübergabe "--version" auszugeben:<br />
<skript><br />
if [[ $1 == "--version" ]] ; then<br />
printf "\n Version 0.1"<br />
fi<br />
</skript><br />
<hr /><b>Der echo-Befehl</b><br />
<br />
Der shell-Befehl 'echo' gibt standartmäßig die übergebenen Argumente, getrennt durch einzelne Leerzeichen aus(auch wenn mehrere Leerzeichen zwischen den Argumenten in der Übergabe stehen). Anschließend erfolgt ein Zeilensprung. Dieser kann durch dio Option -n (z.B. bei bash) oder ein \c hinter den Argumenten vermieden werden, je nach shell-Variante.<br />
<br />
<skript><br />
# Die ersten beiden Varianten funktionieren in der bourne again shell (a.k.a BASH)!<br />
echo -n Kein Zeilensprung aka newline!<br />
echo -e "Kein Zeilensprung\c"<br />
echo "Kein Zeilensprung\c"<br />
</skript><br />
<br />
Warum man "echo" vermeiden sollte.<br />
Printf ist vorzuziehen, da durch die oben genannten Unterschiede in der Ausführung eine große Unsicherheit bezüglich Portabilität auf verschiedenen Rechnern entsteht, vA bei verschiedenen Shell-Versionen.<br />
<hr /><br />
<b>Der printf-Befehl</b><br />
Wie bei dem echo-Befehl kann die bloße Ausgabe durch diverse Optionen verfeinert werden. Dadurch wird eine Formatierung der Ausgabe erreicht.<br />
printf FORMATBEFEHL Arg1 Arg2 ...<br />
<br />
Weiterhin kann der ausgegebene Text durch Escape-Sequenzen verfeinert werden.<br />
\a -> Alarm aka bell (Piepston durch Motherboard-eigene Lautsprecher)<br />
\b -> Backspace (löscht das vorangegehende Zeichen)<br />
\e -> Escape charakter<br />
\f -> form-feed (newline und einrücken der nächsten Zeile hinter das Ende der letzten Ausgabe)<br />
\n -> Zeilensprung aka newline<br />
\r -> carriage return (löscht Zeile bis zum Anfang)<br />
\t -> horizontal tab (Tabulatorsprung, ~4 Zeichen)<br />
\v -> vertical tab (wie \f -> dahinter erfolgt newline und einrücken hinter letzte Zeilenlänge) Wo ist der Unterschied zu "\f"?<br />
\\ -> Muss escaped werden, da Sonderzeichen<br />
\nnn -> oktale Zahl, 3-stellig<br />
<br />
Format-Argumente<br />
%s -> Einfache Ausgabe des Arguments<br />
Beispiel: printf "%s\n" "wort1 wort2 wort3"<br />
Worte werden durch newline getrennt.<br />
<br />
%b -> wie %s, aber Escape-Sequenzen werden umgewandelt und ausgeführt<br />
printf "%b" "wort1\nwort2\nwort3"<br />
Worte werden auch hier durch newline getrennnt.<br />
<br />
%d -> Ausgabe eines Integers, Fehlermeldung bei nicht-validen Werden<br />
printf "%d\n" 12 0xff<br />
<br />
%f -> Ausgabe eines floats, Fehlermeldung bei nicht-validen Werten<br />
printf "%f\n" 1.45 5.23<br />
<br />
%e -> Ausgabe der Zahlen in Exponential-Darstellung<br />
printf "%e\n" 1000000<br />
Ausgabe: 1.000000e+06<br />
Die obige Ausgabe ist identisch mit 10^(1*6)<br />
<br />
%x bzw. %X -> Dezimalzahlen in Hexadezimal-Schreibweise ausgeben<br />
printf "Hexadezimal-ausgabe: %x" 16<br />
<br />
<b>Nachkommastellen</b><br />
Die Ausgabe von Zahlen (außer int) erfolgt standartmäßig mit 6 Nachkommastellen (evtl. Auffüllung mit Nullen). Beschränkt werden kann dies mit einer Angabe der Nachkommastellen zwischen % und f. Beispiel: %.2f -> 2 Nachkommastellen. Werden Zahlen abgeschnitten, so wird kaufmännisch gerundet.<br />
<br />
<b>Auffüllen von Zahlen</b><br />
Man kann angegeben werden, dass die Zahlen bei Bedarf mit Nullen aufgefüllt wird:<br />
printf "%05d" 23 45 42 4355<br />
Wird die Null nicht zum Auffüllen angegeben, so werden Leerzeichen verwendet. Dies kann auch nützlich sein, um zB alle Zahlen rechtbündig um 10 Zeichen einzurücken: <br />
printf "%10d\n" 23 45 42 4355<br />
<br />
Die Formatierung kann in einem shellskript in einer Variablen einmal festgelegt werden, und mehrmals verwendet werden.<br />
<br />
<skript><br />
#!/bin/bash<br />
format="%17.15s %5.2f\n"<br />
printf "$format" \<br />
Zahl_1 12 \<br />
Zahl_2 3 \<br />
Zahl_3 22.5<br />
# weiteres Beispiel<br />
printf "\n"<br />
printf "$format" \<br />
Arbeitsstunden 44.258 \<br />
Leistung 3542.235 <br />
</skript><br />
<br />
In dem letzten Skript wurde, der Übersichtlichkeit wegen, der printf-Befehl jeweils nicht in eine einzige Zeile gepackt, sondern durch Absätze getrennt. Damit trotzdem alles wie eine Zeile erkannt wird, werden an das jeweilige Ende ein Leerzeichen und ein Backslash angehangen. <br />
Interessant: Dies kann z.B. auch nützlich sein, wenn man eine Textdatei verwenden möchte, die durch Absätze getrennte Datensätze aufweist. An jedes Zeilenende muss nun einfach ein " \" angehangen werden, um mit einem vorangestellten printf die komplette Datei abzuarbeiten.<br />
<br />
printf -v (seit BASH 3.1)<br />
Durch ein printf kann auch eine Zuweisung erfolgen. Es erfolgt keine Ausgabe, aber der Variablen kann ein Wert zugewiesen werden. In folgendem Beispiel erfolgt keine Ausgabe, aber der Variablen zahl_1 wird der Wert 1000 zugewiesen.<br />
printf -v zahl_1 1000<br />
<br />
Praktisch, und dann auch kürzer als eine normale Zuweisung, ist eine gleichzeitige Formatierung der Variablen. So kann sehr einfach eine Modifizierung einer Variablen durchgeführt werden. In folgendem Beispiel wird der Zahl ein tabstop vorangestellt und die Nachkommastelle auf 2 Stellen begrenzt.<br />
printf -v zahl_2 "\t%.2f" 451.545<br />
<br />
<hr /><b>Standart Eingabe / Standart Ausgabe / Umleitung</b><br />
<br />
Mit dem ">"-Zeichen, werden Daten in eine Datei geschrieben. Falls die Datei nicht existiert, wird diese erstellt. Eine leere Datei lässt sich also folgendermaßen erstellen:<br />
<eingabe>printf "" > file_1</eingabe><br />
oder verkürzt:<br />
<eingabe>> file_1</eingabe><br />
<br />
Mit der Zeichenkombination ">>" wird die Ausgabe an eine Datei angehangen. Sollte die Datei nicht existieren, so wird sie angelegt.<br />
printf hallo >> datei_1<br />
<br />
Eine wichtige Umleitung, die man häufig benutzt ist 2>/dev/null<br />
Die 2 steht für alle Fehlermeldungen, die bei Ausführung eines Befehls normalerweise ausgegeben werden (Beispiel: Verzeichnis kann durch zu geringe Rechte des Nutzers nicht angezeigt/durchsucht werden). Da man diese bei einer Ausgabe nicht sehen möchte oder bei Umleitung in eine Datei nicht gespeichert haben möchte, werden diese nach /dev/null umgeleitet. Dabei handelt es sich um eine Art Mülleimer, alles dort abgelegte wird nicht gespeichert.<br />
<br />
<hr /><b>Nutzereingaben mit read</b><br />
<br />
Mit dem Befehl "read" können Daten von der Kommandozeile eingegeben werden. Diese werden vorher festgelegten Variablen zugewiesen:<br />
read a b c<br />
Eine Ausgabe efolgt z.B. mit:<br />
echo $a<br />
<br />
Eine Trennung bei der Eingabe erfolgt durch Leerzeichen. Werden mehr Worte als Variablen eingegeben, so wird der letzten Variablen der "überstehende Rest" zugeordnet.<br />
<eingabe><br />
read a b c<br />
hallo das ist ein test<br />
echo $c</eingabe><br />
<ausgabe>ist ein test</ausgabe><br />
<br />
Die erste Zeile einer Datei kann über read einer Variablen zugeordnet werden.<br />
<eingabe>read a < datei_1</eingabe><br />
<hr /><b>Pipe |</b><br />
Mit dem Pipe-Symbol wird der output aus einem Befehl in den input des nächsten Befehls geleitet.<br />
Beispiel:<br />
<eingabe>ls | less</eingabe><br />
<br />
Gerne wird <b>der tee-Befehl</b> genutzt. Damit wird die vorherige Ausgabe wie ohne das pipe ausgegeben, aber auch in eine Datei umgeleitet.<br />
Beispiel: <br />
<eingabe>ls | tee datei_1</eingabe><br />
<br />
<b>Befehlsausgabe in Variable speichern</b><br />
Die Ausgabe eines Befehls kann problemlos in einer Variablen gespeichert werden. Der offensichtliche Weg ist die Benutzung von Backticks, welche einen Befehl "on the fly" ausführen.<br />
<eingabe>datum=`date`</eingabe><br />
Eine Ausgabe erfolgt mit:<br />
<eingabe>printf $datum</eingabe><br />
Diese Substituierung kann und <b>sollte man besser über folgende Befehlskette</b> durchführen:<br />
<eingabe>datum=$( date )</eingabe><br />
Auch mehrere Befehle hintereinander kann man einer Variablen zuweisen:<br />
<eingabe>variable_1=$( cat test | tr [a-z] [A-Z] ; printf "\n" )<br />
echo $variable_1<br />
</eingabe><br />
<hr /><br />
<b>Übung:</b> Vier Zufallszahlen untereinander ausgeben. 5 Vor- und Nachkommastellen. Formatiert, so dass Kommazeichen übereinander stehen.<br />
<skript><br />
#/bin/bash<br />
speichern="zufall_ausgabe"<br />
rm $speichern 2>/dev/null<br />
printf "\nZufallszahlen. Pro BASH Programming S.17 / Uebung 2\n"<br />
for (( i=0; i<5; i++)) <br />
do printf "%11.5f\n" $RANDOM | tee $speichern <br />
done <br />
</skript><br />
<ausgabe><br />
Zufallszahlen. Pro BASH Programming S.17 / Uebung 2<br />
12357.00000<br />
5913.00000<br />
6775.00000<br />
9828.00000<br />
24561.00000<br />
</ausgabe><br />
<hr /><br />
Dieser Beitrag wurde inspiriert durch das Buch "pro Bash programming - Scripting The GNU Linux Shell" - 2. KapitelGeisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-15151542320985357622010-04-10T11:46:00.000-07:002010-04-10T12:19:25.093-07:00Gnuplot 102 - einfacher Graph mit 2 WertepaarenGnuplot kann sehr aufwendige Operationen ausführen. Am Anfang möchte ich aber vorerst die Grundlagen erklären. Wir möchten folgende Datei namens "aepfel_birnen_preise" auslesen und mit Gnuplot darstellen lassen.<br />
<code><br />
# Durchschnittspreise/kg von Aepfeln und Birnen in Jahren 2000-2010<br />
# Ausgedachte Werte!<br />
# Spalte 1: Jahr<br />
# Spalte 2: Aepfel<br />
# Spalte 3: Birnen<br />
# -----------------<br />
2000 2.1 1.7<br />
2001 1.9 1.65<br />
2002 2.34 1.26<br />
2003 1.24 1.8<br />
2004 1.56 2.1<br />
2005 2.13 2.04<br />
2006 1.67 2.56<br />
2007 1.45 2.04<br />
2008 2.56 2.11<br />
2009 1.76 1.99<br />
2010 1.63 1.56<br />
</code><br />
<br />
Beim Aufruf in der Gnuplot-Kommandozeile (starten durch <i>gnuplot</i>) müssen wir definieren, welche Spalten in welcher Beziehung stehen. Zusätzlich sollen die Punkte mit Linien verbunden sein. Zum guten Schluß soll noch erkennbar sein, welche Linie mit welchen Obstpreisen in Beziehung stehen. Das ganze wird in Gnuplot durch einen Einzeiler erledigt.<br />
<eingabe>gnuplot</eingabe><br />
<code>plot "./aepfel_birnen_preise" using 1:2 title "Aepfel" with lines, "./aepfel_birnen_preise" using 1:3 title "Birnen" with lines</code><br />
Das selbe kann auch abgekürzt werden (abkürzen bis auf Anfangsbuchstaben der Befehle; filename wird beim zweiten Aufruf interpoliert (es wird der letzte benutzte file genutzt)):<br />
<code>plot "./aepfel_birnen_preise" u 1:2 t "Aepfel" w l, "" u 1:3 t "Birnen" w l</code><br />
<br />
Als Ergebnis wird uns folgender Graph ausgegeben:<br />
<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiuF04il_8sV1mQkdeitxyQxsqQH2zo4iz9EjXzqZBoPi_XJ5rg84BbH60-QGfJmgyWKnLUwGexpOyHl8nygtn39d6nc4TaSd5m-U5j8JL38iXAWZ1YkoDg_e3lEHXrDDvw_r3xDkSKS2AU/s1600/screenshot_001.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEiuF04il_8sV1mQkdeitxyQxsqQH2zo4iz9EjXzqZBoPi_XJ5rg84BbH60-QGfJmgyWKnLUwGexpOyHl8nygtn39d6nc4TaSd5m-U5j8JL38iXAWZ1YkoDg_e3lEHXrDDvw_r3xDkSKS2AU/s320/screenshot_001.png" /></a></div>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-42082580630289729802010-03-31T00:39:00.000-07:002010-04-10T11:04:18.478-07:00GnuPlot 101 - Graph mit ZufallszahlenIch möchte einen <b>einfachen Graph mit GNUPLOT </b>ausgeben lassen. Als Zahlenquelle wähle ich Zufallszahlen. Gnuplot erwartet pro Zeile einen Datensatz. Man kann auch andere Formatierungen nutzen, dafür müsste der Befehlssyntax aber erweitert werden. Um eine Liste mit entsprechenden Datensätzen auszugeben, erstelle ich ein kleines Skript, das 100 Zufallszahlen in eine Datei schreibt: <br />
<skript><br />
#!/bin/bash<br />
# Dateinamen festlegen<br />
l="random_1"<br />
# Datei loeschen - Fehler unterdruecken<br />
rm $l 2>/dev/null<br />
# 100 Zufallszahlen erstellen<br />
for ((i=0;i<100;i++))<br />
do<br />
echo $RANDOM >>$l<br />
done<br />
</skript><br />
Bevor man GnuPlot nutzt, muss man es natürlich installieren (die ersten 2 Befehle sind wichtig):<br />
<eingabe><br />
sudo apt-get install gnuplot<br />
sudo apt-get install gnuplot-doc<br />
sudo apt-get install gnuplott-X11<br />
</eingabe><br />
Nachdem man das Programm mit gnuplot aufruft, kann man Befehle über eine Text-Konsole eingeben. Eine kleine Einführung zu den Befehlen habe ich <a href="http://www.pci.tu-bs.de/agelstner/lehre/thc2-08/gnuplot-befehle-small.pdf">hier</a> gefunden.<br />
<br />
Gestartet werden kann auch direkt über die Linux-shell.<br />
<eingabe>echo 'plot "./random_1"; pause 10'|gnuplot</eingabe><br />
<br />
Oder man startet gnuplot ('gnuplot') und gibt folgendes ein (Achtung, hier habe ich den Befehl durch "with lines" ergänzt. Damit verbindet man die Punkte mit Linien; vgl. Liniendiagram):<br />
<code>plot "./random_1" with lines</code><br />
<br />
<div class="separator" style="clear: both; text-align: center;"></div><div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEihCOCLAvlgrW-QfPxgJUiHc34HbNxQcphR_AzCMgvc4soBoZSUd9GNQeUrCQREbjJm2UJCvzPfIle7LZiw2ZIz0_eLa8DmvG_J9_lPHFRal8tOy7BP7GvVwTmzZPnBjhztQvXOyihz9ntP/s1600/gnuplot_random1.png" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEihCOCLAvlgrW-QfPxgJUiHc34HbNxQcphR_AzCMgvc4soBoZSUd9GNQeUrCQREbjJm2UJCvzPfIle7LZiw2ZIz0_eLa8DmvG_J9_lPHFRal8tOy7BP7GvVwTmzZPnBjhztQvXOyihz9ntP/s320/gnuplot_random1.png" /></a></div><br />
Die Graphen können auf vielfältige Weise definiert werden. Diverse Muster stehen zur Auswahl. Eine gute Erklärung findet man auf <a href="http://t16web.lanl.gov/Kawano/gnuplot/intro/style-e.html">folgender Seite</a>.Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-27152856043343842002010-03-30T09:39:00.000-07:002010-03-30T09:39:28.811-07:00Sicherheitsrelevante updatesAuch bei Linux gibt es Sicherheitslücken. Allerdings kann man diese durch aptitude, dem Packetmanager, schnell beheben. Eine Internetzverbindung vorausgesetzt, spielt man durch folgende Befehle in der Konsole (aka shell) die neuesten Sicherheits-Updates ein:<br />
<br />
<code>sudo aptitude update<br />
sudo aptitude safe-upgrade</code><br />
<br />
Leider muss man da alle paar Tage dran denken. Gut wäre eine automatisierung. Leider brauch man für diese Befehle root-Rechte. Es sollte aber eine Lösung dafür geben; evtl durch einen <b>cronjob</b>.Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-13311343626802185672010-03-23T05:01:00.000-07:002010-03-23T05:02:00.519-07:00Geschütztes PDF-Dokument druckenLeider schützen viele Ihre PDF-Dokumente, damit Sie <b>nicht gedruckt werden </b>können. Dies kann man aber zum Glück mit dem Standart-Dokumentenbetrachter (bei UBUNTU: Evince) umgehen.<br />
<br />
Man öffnet das Dokument einfach und druckt es dann aus! Die Sperre greift hier nicht. Man kann auch erstmal in eine Datei drucken, falls man zB die Live-CD nutzt. Anschließend kann man mit der Ausgegebenen Datei (Ausgabe.pdf) machen, was man möchte!<br />
<br />
Linux ist mal wieder besser als Windows ;-) epic win.Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-10322515219559202362010-03-13T06:35:00.000-08:002010-03-13T06:35:53.391-08:00Thunderbird 3.0 in Ubuntu installierenWie installiere ich das neue Thunderbird 3.0.3 (oder aktueller) bei Ubuntu (o.Ä.)?<br />
<code><br />
sudo add-apt-repository ppa:ubuntu-mozilla-daily/ppa<br />
sudo apt-get update<br />
sudo apt-get install thunderbird-3.0</code><br />
<br />
</code><br />
Fertig!Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-64476862721811057952010-02-21T12:24:00.000-08:002010-03-13T06:40:38.167-08:00Spezielle VariablenEs gibt Variablen, die von der Shell gesetzt werden (können), aber vom Nutzer nicht direkt verändert werden können.<br />
<br />
<ul><li><code>$$</code> Prozess-ID der aktuellen Shell</li>
<li><code>$!</code> Prozess-ID des letzten Hintergrund-Prozesses</li>
<li><code>$-</code> für die Shell gesetzte Option</code></li>
<li><code>$_</code> Letztes Argument des vorherigen Kommandos</code></li>
<li><code>$?</code> Rückgabestatus / Exit-Status</code></li>
<li><code>$#</code> Anzahl der Parameter</code></li>
<li><code>$*</code> Alle Parameter</code></li>
<li><code>$@</code> Alle Parameter als einzelne Zeichenketten</code></li>
</ul>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-46618542854160117722010-02-16T09:44:00.000-08:002010-06-23T06:07:45.667-07:00Mit wget Bilddateien runterladenMan kann den wichtigen Befehl "wget" dazu verwenden, bestimmte Dateiarten bei einer bestimmten domain runter zu laden (vgl. scraping). Folgendes Beispiel steht für eine Beispielseite - alle Bilder liegen auf der img-Subdomain. Wichtig ist, dass die for-Schleife für die zu scrapende Seite(n) geeignet ist.<b> Nicht alle Seiten</b> weisen eine Struktur auf, bei denen Unterseiten mit 1-10 (o.Ä.) aufgerufen werden!<br />
<br />
Ein Beispiel:<br />
<br />
<skript>for i in {1..9}; do wget -H -c -nd -e robots=off --include-directories=img -r --reject=tn_* --accept=*.jpg,*.jpeg,*.png,*.bmp,*.gif --domains=img.testserver.com --user-agent="Opera/9.00 (Windows NT 5.1; U; en)" "http://testserver.com/archive/tags/realestate/page/${i}"; done<br />
</skript><br />
<br />
Achtung, es wird in das jeweils aktuelle Verzeichnis gespeichert! Also am besten vorher ein Verzeichnis erstellen, in dieses wechseln und erst dann den obigen Befehl ausführen!Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-24181730659685924212010-02-15T11:24:00.000-08:002010-02-16T09:50:44.207-08:00Festplatten synchronisieren mit Linux-ShellBeispielhaftes Szenario: Ein Verzeichnis auf dem Desktop-Rechner soll mit einer externen Festplatte synchronisiert werden. Ein einfacher copy-Befehl (cp) hätte diverse Nachteile. Vielmehr benutzen wir den Befehl "rsync" um einen Abgleich der Daten zu machen.<br />
<br />
Beispiel:<br />
<code><b>rsync</b> -aP /daten/wichtig /media/##_backupverzeichnis</code><br />
<b>Die Option "-a" </b>vereint mehrere Optionen und steht für "archive". So werden zB die Verzeichnisse rekursiv abgeglichen, also auch Unterverzeichnisse.<br />
<br />
<b>Die Option "-P" </b>sorgt dafür, dass einem der Fortschritt der Operation angezeigt wird. Vor allem bei Gigabyte-großen Kopieraktionen sollte dies aktiviert werden. <br />
<br />
Das Verzeichnis <b>/media/... </b>wird oft für angeschlossene USB-Festplatten verwendet (Ubuntu-Linux). Wird von einer USB-Festplatte auf die andere synchronisiert (zB bei Umstieg von 1TB auf 1,5TB Festplatte), so kann es zu folgenden Befehlen kommen, die erst nicht nach einer Sicherung zwischen verschiedenen Festplatten aussieht:<br />
<code><b>rsync </b>-aP /media/MP3 /media/##_MP3</code>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-60770950626197911732010-02-12T09:09:00.000-08:002010-02-16T09:51:27.390-08:00Shellskript für Liste mit allen AVI/MKV Dateien im jew Verzeichnis<code>#!/bin/bash<br />
# Liste, um alle avi/mkv-Dateien im aktuellen(!) Verzeichniss<br />
# (+alle Unterverzeichnisse) in eine Liste zu schreiben<br />
# Alternativ könnte man alle Dateien auflisten und diese dann auf ein egrep<br />
# pipen. Dann muss man aber mit einem<br />
# sed-Befehl anschließend mehr entfernen (uA auch viele Leerzeilen!).<br />
<br />
#Dateiname festlegen HIER<br />
l="liste.txt"<br />
<br />
#Datei löschen<br />
rm $l 2>/dev/null<br />
<br />
# Überschrift!<br />
echo "###### Filmliste #####" >>$l<br />
<br />
# So, jetzt noch eine Leerzeile!<br />
printf "\n" >>$l<br />
<br />
# avi-Dateien finden, Fehlermeldungen löschen, Bis zum letzten "/" löschen,<br />
# Rest an Datei anhängen. <br />
printf "#### AVI-Dateien #####" >>$l<br />
printf "\n" >>$l<br />
find `pwd` -type f -name *.avi 2>/dev/null | sed 's:.*\/::' >>$l<br />
printf "\n" >>$l<br />
printf "\n" >>$l<br />
printf "#### MKV-Dateien #####" >>$l<br />
printf "\n" >>$l<br />
find `pwd` -type f -name *.mkv 2>/dev/null | sed 's:.*\/::' >>$l<br />
</code>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-41704778115203892532010-02-09T11:52:00.001-08:002022-12-18T02:04:14.993-08:00STDOUT, STDERR und STDINSTDOUT, STDERR und STDIN werden benutzt, um Eingaben und Ausgaben in der Shell umzuleiten. Die Begriffe stehen für "standart output" (STDOUT), "standart error" (STDERR) und "standart input" (STDIN). Per default werden Ausgaben eines shell-Befehls über STDOUT und STDERR auf der Befehlszeile direkt sichtbar ausgegeben.<br />
<br />
STDIN kann benutzt werden, um Nutzereingaben aufzunehmen und zu verarbeiten.<br />
<br />
In einem shell-skript oder einem Einzeiler werden die obigen, langen Begriffe nicht direkt benutzt, sondern Zahlen-Variablen. Die 1 für STDOUT und die 2 für Fehlermeldungen, also STDERR. Ein Beispiel, was sehr häufig genutzt wird ist der Befehl "<b>2>/dev/null</b>". Damit werden alle Fehlermeldungen (z.B. keine Leserechte in bestimmen Verzeichnissen) in den Müll (a.k.a. /dev/null) geschickt und<b> erscheinen somit nicht auf dem Bildschirm! </b>Sehr nützlich, bitte merken.<br />
<br />
Wird keine Nummer angegeben,so geht die shell davon aus, dass man STDOUT (also 1) meint:<i> </i><br />
<blockquote><b><i>ls -la > inhalt.txt</i></b></blockquote><i> </i>Ist das selbe wie: <br />
<blockquote><b><i>ls -la 1> inhalt.txt</i></b> </blockquote>Möchte man STDOUT in einen file und STDERR in einen anderen file lenken, macht man dies wie folgt:<br />
<blockquote><b><i>ls -la 1>inhalt.txt 2>fehlermeldungen.txt</i></b></blockquote>STDOUT und STDERR in einen file zusammen lenken? Kein Problem:<br />
<blockquote><b><i>ls -la >inhalt.txt 2>&1</i></b></blockquote>Möchte man allerdings trotz Umleitung in eine Datei eine Ausgabe (zur Kontrolle zB) auf dem <a href="https://www.heider-ing.de" target="_blank">Bildschirm</a> sehen, gibt es auch dafür eine Lösung:<br />
<blockquote><b><i>ls -la | tee inhalt.txt </i></b></blockquote><br />
Mehr Infos bei <a href="http://www.skorks.com/2009/09/using-bash-to-output-to-screen-and-file-at-the-same-time/">skorks.com.</a>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-8333315103999415582010-02-07T09:26:00.000-08:002010-04-10T10:15:08.303-07:00Linux Shell und RegEx Befehle 1Ich habe eine Datei mit <b>unnötigen Leerzeilen</b> erstellt, eine Wortliste. Ich möchte mit egrep alle Leerzeilen entfernen.<br />
<br />
Die Datei heißt "wl" und die Ausgabe erfolgt in die Datei "wl2". Folgende Befehle sind möglich:<br />
<eingabe><br />
egrep -e ^[^$] wl > wl2<br />
</eingabe>oder<br />
<eingabe><br />
cat wl | egrep ^[^$] > wl2<br />
</eingabe><br />
oder in VIM (ein Befehl wird auf die GANZE Zeile angewendet, darum wird :g verwendet):<br />
<code>:g/^$/d</code><br />
Folgender Befehl würde in VIM nicht wie gewünscht funktionieren, da eine leere Zeile einfach durch eine leere Zeile ersetzt wird...(ergo: keine sichtbare Änderung!):<br />
<code>:%s/^$//</code><br />
<br />
Der zweite Befehl ist komplizierter, aber für manche vielleicht einfacher zu verstehen.<br />
<br />
----------------------------------------------------------------------------- <br />
<br />
Nachdem alle Leerzeilen entfernt wurden, möchte ich aus der Datei "wl2" <b>alle Leerzeichen entfernen</b>, die am Anfang jeder Zeile stehen. Dies erledigt man am besten (dachte ich!) im VI- bzw. VIM-Editor (Aufruf mit "vim wl2"). Dann wird dort folgender Befehl ausgeführt:<br />
<code><br />
:%s/^ //<br />
</code><br />
Problem: Es werden wirklich nur einzelne Leerzeichen am Anfang einer Zeile gelöscht (aka "Ersetzen durch NICHTS"). Was ist zB mit 2 oder mehr Leerzeichen?<br />
<br />
Hier die Lösung mit sed:<br />
<eingabe><br />
<b>sed 's/^[ ]*//' <alterfile.txt>neu.txt</alterfile.txt></b><br />
</eingabe>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-82717022034488725452010-02-07T08:58:00.000-08:002010-02-07T09:00:16.552-08:00Mit Linux (Ubuntu) eine externe Festplatte formatieren - howtoIch möchte meine neue Hitachi-1GB-Festplatte mit Ubuntu formatieren (NTFS Format), um sie mit dem WDTV-Live Standalone-Player zu nutzen. <br />
<br />
Wichtig: Für folgende Aktionen muss man Administratoren-Rechte (zB mit "su" erlangen) haben!<br />
Ich öffne die shell und überprüfe, welche Festplatten dem System zu Verfügung stehen:<br />
<br />
<b>fdisk -l</b><br />
---------------------------------------------------------------------------<br />
Platte /dev/sda: 250.1 GByte, 250059350016 Byte<br />
255 Köpfe, 63 Sektoren/Spuren, 30401 Zylinder<br />
Einheiten = Zylinder von 16065 × 512 = 8225280 Bytes<br />
Disk identifier: 0xccd464a0<br />
<br />
Gerät boot. Anfang Ende Blöcke Id System<br />
/dev/sda1 * 1 3654 29350723+ 83 Linux<br />
/dev/sda2 3655 30401 214845277+ 5 Erweiterte<br />
/dev/sda5 3655 5478 14651248+ 83 Linux<br />
/dev/sda6 5479 15265 78614046 83 Linux<br />
/dev/sda7 15266 25052 78614046 83 Linux<br />
/dev/sda8 25053 28821 30274461 83 Linux<br />
/dev/sda9 28822 30401 12691318+ 82 Linux Swap / Solaris<br />
<br />
Platte /dev/sdb: 1000.2 GByte, 1000204886016 Byte<br />
255 Köpfe, 63 Sektoren/Spuren, 121601 Zylinder<br />
Einheiten = Zylinder von 16065 × 512 = 8225280 Bytes<br />
Disk identifier: 0x1348d81d<br />
<br />
Gerät boot. Anfang Ende Blöcke Id System<br />
/dev/sdb1 1 121601 976760001 7 HPFS/NTFS<br />
---------------------------------------------------------------------------<br />
<br />
Es werden 2 physiche Festplatten angezeigt. Die zweite möchte ich partitionieren. Das Dateisystem ist schon NTFS, da muss ich eigentlich nichts ändern, da der Hersteller (Hitachi) schon alles richtig eingerichtet hat :)<br />
<br />
fdisk /dev/sdb<br />
<br />
Ich erstelle eine Primäre Partition, Größe ca 150 GB und als Dateisystem wird HPFS/NTFS ausgewählt (Hexcode 7). <br />
Nun versuche ich diese neue Partition zu mounten:<br />
<br />
sudo mount -t ntfs /dev/sdb1 ~/extern<br />
<br />
<b>Das schlägt fehl</b>, als nächstes lösche ich alles und erstelle eine neue Partition, diesmal aber als "erweitert".<br />
<br />
--------------------------------------------------------------------------<br />
<br />
Da alles nicht funktioniert, hier <b>meine abschließende LÖSUNG des PROBLEMS:</b><br />
<br />
Ich installiere <b>gParted</b>, eine graphische Partitionierungsoberfläche für Gnome. Zusätzlich installiere ich NTFSPROGS (apt-get install ntfsprogs), damit man auch ntfs-Partitionen erstellen kann.<br />
<br />
Ein Aufruf des Programms gParted erfoglt bei Ubuntu über das Menü SYSTEM -> SYSTMVERWALTUNG -> GParted.<br />
<br />
Ergebnis:<br />
--------------------------------------------------<br />
Platte /dev/sdb: 1000.2 GByte, 1000204886016 Byte<br />
255 Köpfe, 63 Sektoren/Spuren, 121601 Zylinder<br />
Einheiten = Zylinder von 16065 × 512 = 8225280 Bytes<br />
Disk identifier: 0x1304581d<br />
<br />
Gerät boot. Anfang Ende Blöcke Id System<br />
/dev/sdb1 1 121601 976760001 5 Erweiterte<br />
/dev/sdb5 1 79222 636350652 7 HPFS/NTFS<br />
/dev/sdb6 107640 121601 112149733+ 7 HPFS/NTFS<br />
/dev/sdb7 79223 107639 228259521 7 HPFS/NTFS<br />
<br />
-----------------------------------------------------<br />
<br />
Es wurde also <b>eine Erweiterte Partition</b> über die kompletten 1000 Gigabyte erstellt. Diese wurde in <b>3 Logische Partitionen</b> eingeteilt.<br />
<br />
Erfolg!Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-91550366520340480692010-01-17T05:19:00.000-08:002010-01-17T05:19:38.413-08:00iMac? Genau sowas brauche ich doch!Mein Rechner ist alt und einen richtigen Schreibtisch habe ich auch nicht. Wenigstens das eine könnte ich mit etwas Glück gewinnen (bitte bitte ;)).<br />
<br />
Hier der Beweis:<br />
<div class="separator" style="clear: both; text-align: center;"><a href="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEir7NHj5bYczIfewZKshNLIjI5WPEE0NTmyxlP931vlrpb4N75rtpAmbvZ1w1LEftLRFwzHE9NRT6_RhKzCk6A9vDM-W_PaY-nZLFfY-E3y0opVokCchCH6eGLJrFryj1m9qwlSSupn2Sl7/s1600-h/Arbeitsplatz_2010.jpg" imageanchor="1" style="margin-left: 1em; margin-right: 1em;"><img border="0" height="400" src="https://blogger.googleusercontent.com/img/b/R29vZ2xl/AVvXsEir7NHj5bYczIfewZKshNLIjI5WPEE0NTmyxlP931vlrpb4N75rtpAmbvZ1w1LEftLRFwzHE9NRT6_RhKzCk6A9vDM-W_PaY-nZLFfY-E3y0opVokCchCH6eGLJrFryj1m9qwlSSupn2Sl7/s400/Arbeitsplatz_2010.jpg" width="265" /></a><br />
</div><br />
<br />
<a href="http://www.whudat.de/?p=6006">Link zum MC seinen Blog!<br />
<br />
</a><br />
<a href="http://www.tdblog.de/blog/2010/01/tech-depot-verlost-imac-neues-gewinnspiel/">Link zum Techdepot thread.</a>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-35162906560747705132010-01-13T12:13:00.000-08:002010-01-13T12:13:36.160-08:00Das Fedora-Unglück (oder: die verschlüsselte Festplatte und Ich)Ich habe Fedora 12 auf einem Notebook installiert. Bei der Installationsroutine von der Live-CD habe ich die Verschlüsselung der gesamten Platte aktiviert (nicht sehr schlau). Danach habe ich mir mit einem falschen(?) Nvidia-Treiber die Xorg.config zerschossen. Letztendlich konnte ich noch nichtmal mehr in die Kommandozeile! Mit der shell hätte ich ja nochwas retten können, aber leider ging garnix mehr.<br />
<a name='more'></a><br />
<b>Erster Versuch:</b> In Ubuntu-System eingebaut. Einbinden funktioniert nicht, obwohl sie als verschlüsselte Partition erkannt wird! Fail.<br />
Hier die Fehlermeldung: <br />
160 GB Verschlüsselt konnte nicht eingehängt werden. Error starting job: Failed to execute child process "cryptsetup" (No such file or directory)<br />
<b><br />
Zweiter Versuch </b>mit dieser Anleitung: http://onecool1.wordpress.com/2009/03/05/how-to-recover-that-encrypted-ext4-formatted-logical-volume-you-allowed-fedora-to-create/<br />
<br />
1. Es wird die Live-CD von Fedora12 benutzt. Das selbe System, das auch bei der Installation auf der besagten verschlüsselten Partition verwendet wurde (das ist wichtig!).<br />
<br />
<br />
<blockquote># fdisk /dev/sda<br />
</blockquote>-> zeigt uns folgendes an (p drücken für die Partitionstabelle!):<br />
<br />
Device Boot Start End Blocks Id System<br />
/dev/sda1 * 1 26 204800 83 Linux<br />
Partition 1 does not end on cylinder boundary.<br />
/dev/sda2 26 19457 156083521 83 Linux<br />
<br />
Allein der Größe nach zu uerteilen, ist <b>/dev/sda2 </b>die gesuchte, richtige Partition<br />
<br />
<br />
2. Um die Festplatte zu öffnen/entschlüsseln:<br />
<blockquote># cryptsetup luksOpen /dev/sda2 mydisk<br />
# Enter passphrase for /dev/sda2: ********** <br />
</blockquote><br />
"<b>mydisk</b>" ist ein Bezeichner, den man selber festlegt und nachher noch braucht!<br />
<br />
<br />
<br />
3.<br />
<blockquote># vgscan <br />
Reading all physical volumes. This may take a while... <br />
Found volume group "vg_notebook" using metadata type lvm2<br />
</blockquote>4. Die Volume-Group wird als nächstes aktiviert.<br />
<blockquote># vgchange -a y<br />
2 logical volume(s) in volume group "vg_notebook" now active<br />
</blockquote><br />
5. LVDISPLAY<br />
<blockquote># lvdisplay<br />
</blockquote>-> zeigt uns 2 volumes an, hier die gesuchte (die andere ist die swap-Partition):<br />
<br />
<blockquote> --- Logical volume ---<br />
LV Name /dev/vg_notebook/lv_root<br />
<b> VG Name vg_notebook</b><br />
LV UUID GwlnJO-AkR4-hVAm-NN89-Op0Q-lIlf-AbmtsC<br />
LV Write Access read/write<br />
LV Status available<br />
# open 0<br />
LV Size 144.91 GB<br />
Current LE 37096<br />
Segments 1<br />
Allocation inherit<br />
Read ahead sectors auto<br />
- currently set to 256<br />
Block device 253:3<br />
</blockquote><br />
Wichtig ist hier der Eintrag "VG Name".<br />
<br />
6. Diese Bezeichnung benutzen wir nun mit dem mount-Befehl:<br />
Einbinden der Festplatte:<br />
<blockquote># mkdir /mnt/mydisk<br />
# mount /dev/vg_notebook/lv_root /mnt/mydisk<br />
</blockquote><br />
Jetzt kann über das Verzeichnis /mnt/mydisk auf den gesamten Inhalt zugegriffen werden! Schnell alles auf ne externe Festplatte kopieren und nie wieder Fedora installieren. Juchuuuuu!Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-31586794722434597082009-11-19T15:28:00.000-08:002009-11-19T15:28:24.937-08:00Gutes Videoschnittprogramm für LINUX installierenHallo lieber Videoschnittfreund!<br />
<br />
Wer einfach ein flv-Video für Linux schneiden möchte, dem sei <a href="http://avidemux.org/">AVIDEMUX</a> empfohlen. Das ist wirklich kinderleicht zu bedienen und sehr schnell.<br />
<br />
Installiert wird es mit:<br />
<br />
<div style="text-align: center;"><b>sudo apt-get install avidemux</b><br />
</div><div style="text-align: center;"><br />
</div><div style="text-align: left;">Dies funktioniert unter UBUNTU und anderen DEBIAN-basierten Systemen.<br />
</div><div style="text-align: left;"><br />
</div><div style="text-align: left;"><hr /></div><div style="text-align: left;"><br />
</div><div style="text-align: left;">Als umfangreicheres Videoschnittprogi wollte ich <b><a href="http://www.heroinewarrior.com/cinelerra.php">CINELERRA</a></b> installieren. Am besten selber kompilieren, oder? Klaro, <a href="http://www.heroinewarrior.com/cinelerra/cinelerra.html#INSTALLATION">die Anleitung</a> lässt das ja auch einfach aussehen.<br />
</div><div style="text-align: left;"><br />
</div><div style="text-align: left;">Leider werden hier Fehlermeldungen ausgegeben, die ich nicht interpretieren kann.<br />
</div><div style="text-align: left;"><br />
</div><div style="text-align: left;">Hilfe, welches Programm aus<a href="http://en.wikipedia.org/wiki/List_of_video_editing_software"> dieser Liste</a> soll ich benutzen? Danke.<br />
</div>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-91346727603606630962009-11-19T15:01:00.001-08:002009-11-19T15:01:16.961-08:00Volles Verzeichnis unter Linux löschenEin volles Verzeichnis wird unter Linux mit dem folgenden Befehl gelöscht:<br />
<br />
<div style="text-align: center;"><b>rm -rf [Verzeichnisname]</b><br />
</div><div style="text-align: center;"><br />
</div><div style="text-align: left;">Fertig. Es erfolgt keine Abfrage! Gefundenes Verzeichnis wird sofort gelöscht.<br />
</div>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-38831346292933977542009-11-12T09:00:00.000-08:002010-01-13T12:14:37.495-08:00Einführung in die Sprache SQLIn diesem Beitrag möchte ich Ihnen eine Einführung in die Sprache SQL geben. Bevor ich mich jedoch den Sprachelementen dieser Sprache zuwende, möchte ich ein paar theoretische Grundlagen ansprechen und die Voraussetzungen dafür schaffen, dass Sie SQL-Anweisungen erstellen, ausführen und die Ergebnisse nachvollziehen können. Zu diesem Zweck soll das Produkt Microsoft Access aus dem Office-Paket genutzt werden. Neben der Theorie möchte ich Ihnen deshalb auch eine kurze praktische Einführung in das Produkt geben. Hierfür steht uns der heutige Tag zur Verfügung. Zur Darstellung der grundlegenden Begriffe habe ich diese Präsentation vorbereitet, in der einige Aspekte des Relationenmodells stichwortartig angesprochen werden. Die gesamte Thematik ist recht komplex, so dass man in der Kürze der sicherlich nur ein wenig an der Oberfläche kratzen kann. Die Präsentation soll den roten Faden durch diesen ersten Lehrgangsteil bilden und den Stoff auf wenige einprägsame Kernsätze komprimieren. In der praktischen Einführung möchte ich kurz auf die Benutzeroberfläche von Access eingehen. Anschließend möchte ich die Umsetzung der theoretischen Aspekte in Access vorstellen. D.h. Sie sollen zunächst eine Datenbank erstellen und Beziehungen zwischen Tabellen definieren, ein paar Daten eingeben und Datenbankabfragen erstellen. Zuletzt möchte ich die Beispieldatenbank vorstellen, die für das Übungsszenario genutzt werden soll.<br />
<a name='more'></a><br />
<br />
Zunächst müssen wir die Frage klären, was SQL überhaupt ist. SQL steht für Sturctured Query Language und ist eine standardisierte Datenbankabfragesprache zur Abfrage und Manipulation von Daten in relationalen Datenbanken. Auf diese Definition möchte ich zu einem späteren Zeitpunkt noch einmal zurückkommen, um sie etwas ausführlicher zu erläutern. Wir stellen zunächst einmal fest, die Sprache dient dazu, Informationen aus relationalen Datenbanken zu gewinnen bzw. Daten in relationalen Datenbanken - im weitesten Sinne - zu verändern. Damit stellt sich die Frage „Was sind relationale Datenbanken?“.<br />
<br />
Als Datenbank bezeichnen wir allgemein eine Sammlung von Daten, die in irgendeiner Form logisch zusammen gehören. Von einer relationalen Datenbank spricht man dann, wenn diese Daten durch ein<b> relationales Datenbankverwaltungssystem (RDBMS) </b>verwaltet werden. Microsoft Access ist ein solches relationales Datenbankmanagementsystem (RDBMS). Ein RDBMS speichert und verwaltet die Daten wiederum auf der Grundlage des relationalen Datenmodells. Um den Begriff „relationale Datenbank“ weiter zu konkretisieren, müssen wir erst einmal über das relationale Datenmodell sprechen.<br />
<br />
<b>Relationales Datenmodell</b><br />
<br />
<ul><li>Mathematiker Edgar F. Codd</li>
<li>Forscher in den Entwicklungslabors der IBM in San Jose</li>
<li>Veröffentlichung erster Ansätze 1969-1970</li>
<li>alle Daten werden ausschließlich als Feldinhalte in Tabellen (Relationen) dargestellt</li>
<li>es existieren keine dem Benutzer sichtbaren Verbindungen zwischen den Tabellen</li>
<li>es muss eine Sprachschnittstelle mit einem relationalen Verarbeitungsspektrum zur Verfügung gestellt werden</li>
</ul><br />
Grundlage des Konzeptes relationaler Datenbanken ist die Relation. Dabei handelt es sich im Wesentlichen um eine mathematische Beschreibung für eine Tabelle. Operationen auf diesen Relationen werden durch die relationale Algebra bestimmt. Diese Operationen finden im Sprachumfang von SQL Berücksichtigung.<br />
<br />
<b>Ziel des relationalen Datenmodells</b><br />
<ul><li> Vermeidung redundanter Daten</li>
<li> Vermeidung von Anomalien bei Speicheroperationen</li>
<li> Nutzung der Daten durch verschiedene Applikationen</li>
</ul><br />
<b>Datenredundanz</b><br />
<ul><li>das mehrmalige Festhalten desselben Faktums, d.h. ein und derselben Aussage</li>
</ul><br />
Werden solche Aussagen mehrfach in einer Datenbank festgehalten, so wird zunächst einmal mehr Speicherplatz benötigt. Darüber hinaus kann es vorkommen, dass die Beobachtung der Realität eine Änderung solcher Aussagen erzwingt. Wurden solche Aussagen mehrfach festgehalten, muss jede aufgefunden und geändert werden. Dies bedingt einen Mehraufwand und eine erhöhte Fehleranfälligkeit gegenüber der redundanzfreien Speicherung. Letztlich führen Datenredundanzen zu negativen Auswirkungen auf das Antwortzeitverhalten der Datenbank (Perfomance-Verlust). Dies soll später noch anhand eines Fallbeispiels erläutert werden.<br />
<br />
<b>Speicheranomalien</b><br />
<ul><li>Schwierigkeiten, die beim Einfügen, Ändern oder Löschen von Daten in der Datenbank auftreten</li>
<li>Verletzung der Integrität (Richtigkeit)</li>
<li>Relation entspricht nicht mehr den Realitätsbeobachtungen</li>
</ul><br />
An dieser Stelle möchte ich zunächst lediglich die Begriffsdefinition vorstellen. Auch dieses Problem soll anhand des Beispiels erörtert werden.<br />
<br />
<b>Tabellen</b><br />
<ul><li> Grundlage des relationalen Datenmodells</li>
<li> Kollektionen von Werten, die in Reihen und Spalten angeordnet sind</li>
<li> logische Datenstrukturen</li>
<li> werden vom Datenbankmanagementsystem verwaltet</li>
<li> besitzen Schlüssel</li>
<li> stellen Objekte der realen Welt dar</li>
</ul><br />
Logische Datenstrukturen bedeutet, dass die tabellarische Darstellung der Daten unabhängig ist von der physischen Speicherungsform. Was Objekte der realen Welt sein können, soll im Folgenden dargestellt werden. Dasselbe gilt für die Notwendigkeit von „Schlüsseln“.<br />
<br />
<b>Entität</b><br />
<ul><li>Individuelles und identifizierbares Exemplar von Dingen, Personen oder Begriffen der realen oder Vorstellungswelt</li>
<li>Individuum, reales Objekt, abstraktes Konzept oder Ereignis</li>
<li>Eindeutig identifizierbare Einheit, für die Informationen gesammelt und auf Speichermedium festgehalten werden sollen</li>
</ul><br />
Objekte der realen Welt werden als Entitäten bezeichnet. Der Begriff der Entität ist jedoch so allumfassend und vielfältig, dass eine Definition wohl nicht möglich ist. Auf dieser Folie sind drei Umschreibungen dargestellt, die den Begriff verständlich machen sollen. In einer Tabelle sollen als mehrere Entitäten, also Entitätsmengen, festgehalten werden.<br />
<br />
<b>Entitätsmenge</b><br />
<ul><li> eindeutig benannte Kollektion von Entitäten gleichen Typs</li>
<li> Entitäten, die aufgrund der gleichen Eigenschaften (nicht Eigenschaftswerte) charakterisiert werden können</li>
</ul><br />
Eine Tabelle im relationalen Datenmodell repräsentiert eine Entitätsmenge. In der Literatur wird gelegentlich darauf hingewiesen, dass Tabellen auch Beziehungsmengen beinhalten. Auf diesen Begriff werde ich im Zusammenhang mit der Normalisierungstheorie noch einmal zurückkommen. Eigenschaften sind beispielsweise der Name eines Kunden, sein Wohnort etc.. Eigenschaftswerte hingegen sind die konkreten Ausprägungen zu diesen Attributen, Beispiel: der Kunde mit der Kundennummer 1 hat den Namen „Meier“ und wohnt in „Düsseldorf“.1, Meier und Düsseldorf sind also Eigenschaftswerte.<br />
<br />
<b>Reihe, Zeile, Tupel</b><br />
<ul><li> logisch zusammgehörige Informationen</li>
<li> enthält eine Entität mit ihren Eigenschaften</li>
<li> unterteilt die Tabelle waagerecht</li>
<li> entspricht einem Datensatz</li>
<li> Reihenfolge ist unbestimmt</li>
</ul><br />
<b>Spalte</b><br />
<ul><li> unterteilt die Tabelle senkrecht</li>
<li> teilt die Reihe in Felder auf</li>
<li> Aufteilung ist für jede Reihe gleich</li>
<li> Werte in der Spalte sind vom selben Datentyp</li>
<li> Reihenfolge wird beim Anlegen der Tabelle festgelegt</li>
<li> besitzt Namen</li>
</ul><br />
<b>Spaltenname</b><br />
<ul><li> Zugriff auf die Daten einer Spalte erfolgt über symbolischen Namen</li>
<li> wird beim Anlegen der Tabelle zugewiesen</li>
<li> muss innerhalb der Tabelle eindeutig sein</li>
<li> soll Bedeutung der Information widerspiegeln</li>
</ul><br />
<b>Wert</b><br />
<ul><li> Schnittpunkt von Reihe und Spalte</li>
<li> Feld enthält genau einen skalaren Wert</li>
<li> wird durch Daten repräsentiert</li>
<li> keine Verweise</li>
<li> keine Werteliste</li>
<li> NULL</li>
</ul><br />
<b>NULL-Wert</b><br />
<ul><li> <> 0, Leerzeichen oder leere Zeichenkette</li>
<li> Ergebnis arithmetischer Operationen ist NULL</li>
<li> nie gleich, kleiner oder größer als ein Vergleichswert</li>
<li> Darstellung ist systemabhängig</li>
</ul><br />
<b>Identifizierbare Einheiten</b><br />
<ul><li> Die Zeilen einer Tabelle müssen paarweise verschieden sein</li>
<li> Es darf keine Zeilen geben, die miteinander identisch sind</li>
</ul><br />
Die Beschreibung des Begriffs Entität sagt aus, dass es sich um identifizierbare Einheiten handeln muss. Eine Zeile in einer Tabelle stellt eine Entität mit ihren Attributen dar. Daraus folgt, dass in einer Tabelle keine identischen Zeilen existieren dürfen. In einer Tabelle muss es also Spalten geben, die nur eindeutige Werte bzw. Wertekombinationen beinhalten. Solche Attribute bezeichnet man als Schlüssel.<br />
Die meisten RDBMS‘e lassen das Einfügen identischer Zeilen in einer Tabelle zunächst zu. Die Eindeutigkeit der Werte in einer Spalte wird bei den meisten Systemen durch das Anlegen eines unique Index erzwungen. Exkurs: Ein Index ist eine geordnete Liste von Werten und Pointern, die den Zugriff auf die Daten beschleunigen. Unter Access kann beim Anlegen eines Index über die Feldeigenschaften festgelegt werden, ob Duplikate zugelassen oder ausgeschlossen werden sollen. <br />
<br />
<b>Schlüssel</b><br />
<ul><li> eindeutige Identifikation und Adressierbarkeit der Daten</li>
<li> eine oder mehrere Spalten bilden den Primärschlüssel</li>
<li> nur eindeutige Werte bzw. Wertekombinationen in den Primärschlüsselspalten</li>
<li> Schlüsselkandidaten</li>
<li> Fremdschlüssel</li>
</ul><br />
Die Festlegung von Spalten als Primärschlüssel unter Access impliziert auch das Anlegen eine unique Index.<br />
Als Schlüsselkandidaten bezeichnet man weitere Attribute neben dem Primärschlüssel, die eine eindeutige Identifizierung einer Zeile in einer Tabelle ermöglichen.<br />
Fremdschlüssel sind Attribute in einer Tabelle, die in einer anderen Tabelle die Funktion als Primärschlüssel besitzen. Die Beziehungen zwischen den Tabellen werden über die Dateninhalte der Primär- und Fremdschlüsselspalten zum Ausdruck gebracht. Diese ermöglichen auch, die Daten später wieder sinnvoll miteinander zu kombinieren. Dies soll im Zusammenhang mit den referentiellen Beziehungen noch einmal näher betrachtet werden.<br />
<br />
<b>Relationale Datenbank</b><br />
<ul><li> Sammlung logisch zusammengehöriger Tabellen</li>
<li> Normalisierung</li>
<li> referentielle Beziehungen</li>
<li> referentielle Integrität</li>
</ul><br />
Aufgrund der bisherigen Aussagen können wir nun den Begriff der relationalen Datenbank weiter konkretisieren. Wir verstehen sie nun im Kontext des relationalen Datenmodells als eine Anordnung logisch zusammen gehörender Tabellen. Nun stellt sich die Frage, wie die Daten in einem möglicherweise unternehmensweiten Datenmodell auf die einzelnen Tabellen verteilt werden sollen. Mit dieser Frage setzt sich die Normalisierungstheorie auseinander. In diesem Zusammenhang müssen auch die Begriffe referentielle Beziehungen und referentielle Integrität etwas näher beleuchtet werden. Ich möchte nun einige Aspekte des Datenbankentwurfs an einem kleinen Beispiel verdeutlichen. Im Anschluss daran sollen die Begriffe noch einmal mit Hilfe dieser Präsentation dargestellt werden.<br />
<br />
Gegeben sei ein Unternehmen bei dem Kunden verschiedene Artikel bestellen. Dieser Bestellvorgang soll nun in einer Datenbank erfasst werden.<br />
Um in diesem Beispiel die Übersicht zu behalten, möchte ich mich auf wenige Daten wie den Kundennamen, seine Adresse, die Artikel, den Artikelpreis und die Anzahl der bestellten Artikel beschränken. Da es sich um eine überschaubare Anzahl von Attributen handelt, könnte man in Versuchung kommen, alle Merkmale in einer Tabelle abzulegen. Die Relation könnte wie folgt aussehen:<br />
BESTELLUNG(B#, Name, Anschrift, Bestelldatum, Anzahl, Artikel, Preis)<br />
Der Inhalt der Tabelle könnte nun wie folgt aussehen:<br />
<br />
B# Name Anschrift Bestelldatum Anzahl Artikel Preis<br />
Anne Ecke 40476 Düsseldorf, Mauerstr. 51 10.07.2007 3 CD 5,- €<br />
B.Trug 42551 Velbert, Bahnhofstr. 1 15.07.2007 1, 1 CD, DVD 5,- €, 6,- €<br />
Anne Theke 42549 Velbert, Thekbusch 50 20.07.2007 2, 2 DVD, MC 6,- €, 10,-€<br />
Anne Ecke 40476 Düsseldorf, Mauerstr. 51 30.07.2007 1 CD 5,- €<br />
<br />
Es fällt sofort auf, das verschiedene Informationen mit jeder Bestellung erneut gespeichert werden müssen. Es werden also dieselben Fakten mehrfach in der Datenbank festgehalten. Es handelt sich also um einen Fall von Datenredundanz mit den negativen Begleiterscheinungen, die ich bereits angesprochen hatte. Die Spalten Anzahl, Artikel und Preis enthalten Wiederholungsgruppen (Wertekollektive). Die Aussage beispielsweise, dass der Kunde B.Trug eine CD bestellt hat bzw. das ein Gebinde CD‘s 5 Euro kostet, ist aus diesem Datenmodell nicht zweifelsfrei ableitbar. Schwierigkeiten bereiten auch die Spalten Name und Anschrift. So ist beispielsweise nicht möglich, durch eine einfache Suchabfrage alle Kunden zu ermitteln, die in Velbert wohnen.<br />
<br />
Einige Probleme können dadurch behoben werden, dass die Informationen soweit zerlegt werden, das in jeder Spalte nur noch elemetare Datenelemente abgelegt werden. Für die Spalten Name und Anschrift ist dies sicherlich unproblematisch. Für die Spalten Anzahl, Artikel und Preis hätte dies zur Folge, das sie in einzelnen Zeilen dargestellt werden müssen. Die Relation beschreibt in diesem Fall nicht mehr die Bestellung sondern die Bestellposition. Das hat auch zur Folge, dass die B# nicht mehr ausreicht, um eine Zeile eindeutig zur identifizieren. Diese Maßnahme bedingen außerdem, dass die Zahl der redundant gespeicherten Daten weiter zunimmt. <br />
<br />
Nun existiert auch noch ein weiteres Problem. Nehmen wir an, die Bestellung mit der B# 3 ist abgearbeitet und wir möchten unsere Daten nach einer gewissen Frist bereinigen. Wir löschen also die entsprechenden Zeilen aus unserer Tabelle. Mit dieser Operation geht die Information, der Artikel MC kostet je Gebinde 10 Euro verloren. Damit wird unsere Relation in einen Zustand überführt, die den Realitätsbeobachtungen nicht mehr entspricht. In diesem Fall spricht man von den bereits genannten Speicheranomalien.<br />
<br />
Es bietet sich an, die Daten auf mehrere Tabellen zu verteilen. Betrachten wir die Objekt der realen Welt für die wir Daten sammeln und auf Speichermedium festhalten wollen. <br />
<br />
So kann man gewiss die Kundeninformationen in einer separaten Relation festhalten. <br />
KUNDE(Name, Vorname, PLZ, Ort, Straße, Nr)<br />
Nun besteht hier das Problem, das Müller, Meier und Schmitz in der Realität sicherlich häufiger vorkommen. Auch die weiteren Attribute dieser Relation sind nicht geeignet, einen Kunden eindeutig zu identifizieren. Deshalb muss auch hier ein künstlicher Schlüssel gebildet werden, z.B. K#.<br />
KUNDE(K#, Name, Vorname, PLZ, Ort, Straße, Nr)<br />
<br />
Ein weiteres Objekt der realen Welt, über das wir informationen Speichern wollen ist sicherlich der Artikel. Wird halten Informationen über Artikel ebenfalls in einer weiteren Relation fest. Auch in diesem Fall soll ein künstlicher Schlüssel gebildet werden, denn ein Artikel könnte in der Tabelle mehrfach auftreten, beispielsweise weil er von verschiedenen Lieferanten bezogen wird.<br />
ARTIKEL(A#, Artikelbezeichnung, Preis)<br />
<br />
Die Bestellpositionen werden wegen der o.a. Probleme ebenfalls in einer eigenen Tabelle abgebildet.<br />
BESTPOS(B#, P#, A#, Anzahl)<br />
<br />
Die Relation BESTELLUNG enthält nun nur noch folgende Attribute:<br />
BESTELLUNG(B#, K#, Bestelldatum)<br />
<br />
<b>Normalisierungstheorie</b><br />
<ul><li> eine auf der Mengentheorie beruhende Sammlung von Schemata und Regeln zur Aufteilung und Verknüpfung von Tabellen</li>
<li> sie beschreibt die Normalform einer Tabelle und den Weg zur idealen Tabellenstruktur</li>
</ul><br />
Wir haben gesehen, dass bereits ein paar logische Überlegungen zu einem akzeptablen Datenbankentwurf führen können. Bei komplexen Lebenssachverhalten, die beispielsweise in einem unternehmensweiten Datenmodell abgebildet werden müssen, ist jedoch ein systematisches Vorgehen erforderlich. Die Vorgehensweisen zu beschreiben würde den Rahmen dieses Lehrgangs sprengen. Es sei nur darauf hingewiesen, dass beim Datenbankentwurf i.d.R. die Normalisierungstheorie Berücksichtigung findet.<br />
<br />
<b>Ziel der Normalisierung</b><br />
<ul><li>Ermitteln von optimalen Datenstrukturen, die keine Möglichkeit bieten, einmal getroffene Annahmen der Realität zu verletzen</li>
</ul><br />
Rufen wir uns die Zielsetzung beim Datenbankentwurf noch einmal in Erinnerung. Die Normalisierungstheorie beschreibt fünf Normalformen einer Tabelle. In der Praxis können wir normalerweise von einer optimalen Datenstruktur ausgehen, wenn die Tabelle der 3. Normalform genügt. Aus diesem Grunde sollen die Normalformen kurz vorgestellt werden.<br />
<br />
<b>1. Normalform</b><br />
<ul><li>Eine Tabelle befindet sich in der ersten Normalform, wenn jede Eigenschaft elementar ist und sich weder aus nichtelementaren Attributen zusammensetzt noch Wiederholungsgruppen enthält</li>
<li>Jedes Feld enthält nur skalare (atomare) oder elementare Eigenschaften</li>
</ul><br />
Wie sinnvoll es ist, dass eine Tabelle der ersten Normalform genügt, dürfte das Beispiel bewiesen haben. <br />
<br />
<b>2. Normalform</b><br />
<ul><li> Tabelle genügt der ersten Normalform und</li>
<li> jede Nicht-Schlüsselspalte ist vollständig vom (gesamten) Primärschlüssel abhängig</li>
<ul><li>Tabellen sollen nur Daten zu einer Entitätsmenge beinhalten</li>
<li>Entität soll vollständig durch den Primärschlüssel beschrieben sein</li>
</ul>
</ul><br />
Es soll noch einmal das genannte Beispiel herangezogen werden. Hätten wir die Aufteilung in BESTELLUNGEN und BESTELLDETAILS unterlassen und nur den Primärschlüssel erweitert, wäre folgende Tabellenstruktur verblieben:<br />
<br />
BESTELLUNG(B#, P#, K#, A#, Bestelldatum, Anzahl)<br />
<br />
Die Attribute K#, A#, und Anzahl sind funktional vom gesamten Primärschlüssel (also der Kombination aus B# und P#) abhängig. Das Attribut Bestelldatum hängt jedoch funktional nur vom Schlüsselteil B# ab. Insofern läge ein Verstoß gegen die 2. Normalform vor. <br />
<br />
<b>3. Normalform</b><br />
<ul><li> Tabelle genügt der 2. Normalform und</li>
<li> alle Nicht-Schlüsselattribute sind voneinander funktional unabhängig</li>
<li> -keine transitiven Abhängigkeiten</li>
</ul><br />
Im folgenden Beispiel genügt die Relation zwar der 2. Normalform, die Speicherungsform ist dennoch nicht optimal. Beispiel: Es existiert ein Messsystem, mit dem Schadstoffdaten in der Umwelt gemessen und erfasst werden. Die Messergebnisse sollen in einer Datenbank festgehalten werden. Unter anderem sollen Informationen über die Messstelle in einer Tabelle festgehalten werden. Dabei handelt es sich um die Messstellennummer, Angaben zur Lage der Messstelle wie die Gemeindekennziffer, die Ortsbezeichnung der Gemeinde, die Gauß-Krüger-Koordinaten (Rechtswert und Hochwert) sowie das Datum der Inbetriebnahme und das Datum der Außerbetriebnahme.<br />
MESSSTELLE(MS#, GKZ, ORT, RW ,HW, VON, BIS,)<br />
<br />
In diesem Beispiel besteht eine solche transitive, d.h. indirekte Abhängigkeit zwischen den Attributen GKZ und Ort. Das Attribut Ort ist genau genommen nicht funktional abhängig von der MS#, sondern von der Gemeindekennziffer. Die Tabelle genügt nicht der 3. Normalform. Diese Relation beschreibt also nicht nur eine Entitätsmenge. Außerdem werden hier die Daten redundant gespeichert. Für jede Messtelle in Düsseldorf wird in diesem Fall die Aussage „der Ort mit der Gemeindekennziffer 05111000 trägt die Ortsbezeichnung Düsseldorf“ festgehalten. <br />
Die Lösung für die Probleme besteht in einer Aufteilung der Daten auf zwei Tabellen:<br />
MESSSTELLE(MS#, GKZ, RW ,HW, VON, BIS,)<br />
GEMEINDE(GKZ, ORT)<br />
<br />
<b>4. Normalform</b><br />
<ul><li> Tabelle genügt der 3. Normalform und</li>
<li> weist keine paarweise auftretenden mehrwertigen Abhängigkeiten auf</li>
</ul><br />
Nun ist es möglich Relationen zu kreieren, welche die 3. Normalform respektieren, aber trotzdem zu Problemen Anlass geben. Die Definition der 4. und 5. Normalform wird lediglich der Vollständigkeit halber angegeben, da sie in der Praxis kaum von Bedeutung ist und eine eingehende Erläuterung aus Zeitgründen nicht möglich ist.<br />
<br />
<b>5. Normalform</b><br />
Eine Tabelle ist in der 5. Normalform, wenn sie unter keinen Umständen aufgrund einer Verschmelzung einfacherer Relationen mit unterschiedlichen Schlüsseln konstruiert werden kann.<br />
<br />
<b>Referentielle Beziehungen</b><br />
Beziehungen zwischen Tabellen werden über Datenwerte hergestellt<br />
Master- / Detailtabelle<br />
Kardinalitäten<br />
<ul><li>1:1</li>
<li>1:n</li>
<li>n:m</li>
</ul><br />
Aus den bisherigen Beispielen lässt sich also ableiten<br />
- Die Tabellen in einer relationalen Datenbank stehen miteinander in Beziehung.<br />
- Die Beziehungen zwischen den Tabellen werden über die Datenwerte in den Primär-/Fremdschlüsselspalten abgebildet.<br />
- Die Tabellen mit den Fremdschlüsseln enthalten Details zu den Entitäten, die über die Fremdschlüssel referenziert werden. Die Tabellen mit den Fremdschlüsseln werden demzufolge als Detailtabelle (Childtable) bezeichnet. Die Tabelle mit den zugeordneten Primärschlüsseln bezeichnet man analog als Mastertabelle (Parenttable).<br />
<br />
Betrachten wir die Beziehungen zwischen den Tabellen näher:<br />
<br />
Die Kardinalität beschreibt in der Datenbanktechnik die Komplexität oder den Grad einer Beziehung (engl: Relationship) zwischen zwei Entitätstypen in einem Entity-Relationship-Diagramm (ER-Diagramm). D.h. die Kardinalität eines Beziehungstyps (Relationship-Typs) gibt an, mit wie vielen anderen Entitäten eine Entität eines bestimmten Entitätstyps in einer konkreten Beziehung stehen muss bzw. kann.<br />
<br />
<b>1:1-Beziehung</b><br />
<ul><li>zu jedem Datensatz in einer Tabelle gibt es genau einen Datensatz in einer anderen Tabelle</li>
<li>eine Entität des einen Entitätstyps steht mit höchstens einer Entität des anderen Entitätstyps in Beziehung und umgekehrt </li>
</ul><br />
In der Literatur findet man beide Definitionen, wobei ich der ersten den Vorzug gebe. Legt man diese zugrunde, gibt es kaum Gründe, die Daten auf mehrere Tabellen aufzuteilen. Wenn jede Zeile der einen Tabelle mit genau einem Satz der anderen Tabelle korrespondiert, kann man sie genau so gut in einer Tabelle zusammenfassen. Ein Grund sie dennoch aufzuteilen, sind Restriktionen aufgrund des ausgewählten RDBMS. So kann beispielsweise das DBMS nur eine bestimmte Zahl von Spalten in einer Tabelle verwalten. Handelt es sich um eine Entität mit einer größeren Anzahl von Attributen, ist man gezwungen, diese auf mehrere Tabellen zu verteilen (Beispiel Kläranlagenkataster).<br />
<br />
Legt man die zweite Definition zugrunde ist denkbar, dass Attribute nur für bestimmte Kategorien der betrachteten Entität vorliegen. Würde man sie in einer Tabelle zusammenfassen, blieben viele Datenfelder bei allen anderen Kategorien leer. In diesem Fall bietet sich die Aufteilung an. Die gemeinsamen Attribute könnten in einer Tabelle abgebildet werden, während die speziellen Attribute der betroffenen Kategorien in einer weiteren Tabelle gespeichert würden.<br />
<br />
<b>1:n-Beziehung</b><br />
<ul><li> ein Datensatz in einer Tabelle ist mit einem, keinem oder mehreren Datensätzen in einer anderen Tabelle verknüpft</li>
</ul><br />
<b>n:m-Beziehung</b><br />
<ul><li> ein Datensatz in einer Tabelle-1 ist mit einem, keinem oder mehreren Datensätzen in einer Tabelle-2 verknüpft</li>
<li> ein Datensatz in der Tabelle-2 ist mit einem, keinem oder mehreren Datensätzen in der Tabelle-1 verknüpft</li>
</ul><br />
Erweitern wir das Beispiel noch einmal. Nehmen wir an, dass ein Artikel tatsächlich von mehreren Lieferanten geliefert werden könnte, wobei ein Lieferant i.d.R. mehrere Artikel liefert. Nehmen wir weiter an, dass die Informationen über Lieferanten ebenfalls in unserer Datenbank festgehalten werden sollen. Es existieren also folgende Tabellen<br />
<br />
ARTIKEL(A#, Bezeichnung, Preis, Bestellnr)<br />
<br />
LIEFERANT(L#, Firma, PLZ, Ort, Straße, ...)<br />
<br />
Die RDBMS unterstützen diese n:m Beziehung nicht. Um diesen Sachverhalt in der Datenbank abzubilden, muss noch eine zusätzliche Tabelle eingefügt werden. Um darzustellen, dass ein Artikel von einem bestimmten Lieferanten bezogen wird, enthält diese Tabelle nun die Zuordnung von A# zu L#. Die Beziehung zwischen den Tabellen ARTIKEL und LIEFERANT wird nun über diese zusätzliche Tabelle dargestellt, welche die n:m Beziehung in 1:n Beziehungen zwischen ARTIKEL und ARTLIEF und LIEFERANT und ARTLIEF auflöst.<br />
<br />
ARTLIEF(A#, L#)<br />
<br />
In diesem Fall wird in der Literatur auch von Beziehungsmengen gesprochen. Der Primärschlüssel dieser Tabelle setzt sich nun aus den Primärschlüsseln der Artikel und Lieferantentabelle zusammen. In der Praxis werden i.d.R. noch weitere Attribute in dieser Relation festgehalten (z.B. Rabattsatz etc.). Diese werden auch als Beziehungsattribute bezeichnet.<br />
<br />
<b>Referentielle Integrität</b><br />
Werte für Fremdschlüssel in einer Detailtabelle können nur gespeichert und verwendet werden, wenn ein entsprechender Eintrag in den Primärschlüsselspalten der Mastertabelle existiert<br />
Regeln für das Löschen von Primärschlüsseln in der Mastertabelle, solange noch entsprechende Fremdschlüssel in der Detailtabelle existieren<br />
<ul><li>restricted</li>
<li>cascade</li>
<li>set null</li>
</ul><br />
Damit die Datenbank die Realität korrekt abbildet, muss auch die Richtigkeit der Beziehungen zwischen den Tabellen sichergestellt werden. Dabei geht es darum, dass keine verwaisten Zeilen in den abhängigen Tabellen auftreten können. Das bedeutet, dass zu jeder Zeile in einer Detailtabelle auch eine korrespondierende Zeile in der Mastertabelle existieren muss.<br />
<br />
Die RDBMS‘e stellen zur Sicherstellung der referentiellen Integrität enstprechende Funktionen zur Verfügung, d. h. man kann in der Datenbank entsprechende Integritätsregeln hinterlegen.Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-53633345237898821922009-11-12T06:59:00.000-08:002009-11-12T06:59:10.840-08:00Linux Shell Übungen #3 - Ordner anlegenExistiert im aktuellen Verzeichnis das Verzeichnis ordner nicht, so soll es angelegt werden. Außerdem soll im Verzeichnis ordner eine Datei dat angelegt werden, nachdem mit cd in das neue Verzeichnis gewechselt worden ist.<br />
<br />
a) Nach Abarbeitung der Befehlsfolge, soll das aktuelle Verzeichnis wieder das Ursprungsverzeichnis sein.<br />
<br />
<div style="text-align: center;"><b>test -d ordner || (mkdir ordner ; cd ordner ; touch dat)</b><br />
<b> </b><br />
<b>test -d ordner || { mkdir ordner ; cd ordner ; touch dat ; cd ..;}</b><br />
</div><br />
<br />
b) Wie oben mit folgendem Unterschied: Nach Abarbeitung der Befehlsfolge, soll das aktuelle Verzeichnis das Verzeichnis ordner sein.<br />
<br />
<div style="text-align: center;"><b>test -d ordner || { mkdir ordner ; cd ordner ; touch dat ;}</b><br />
</div>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-56734259456968612022009-11-12T06:54:00.000-08:002009-11-12T06:56:15.981-08:00Linux Shell Übungen #2<div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><u><b>1. Aufgabe</b></u></span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Lassen Sie sich den Inhalt der Variablen HOME anzeigen.</span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Geben Sie aus, welche Shell aktuell von Ihnen verwendet wird.</span></span></span><br />
</div><div style="margin-bottom: 0cm;"><span style="font-family: Courier New,monospace;"><span style="font-size: x-small;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">Was passiert, wenn Sie </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>exec date</b></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"> aufrufen?</span></span></span></span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Inhalt Home: </span></span></span> <br />
</div><ul><li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">exec date -> Beendigung des Befehlsfensters</span></span></span></li>
<li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Aktuelle Shell wird beendet/ueberlagert.</span></span></span></li>
<li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">exec ksh -> funktioniert.</span></span></span></li>
</ul><div lang="de-DE" style="margin-bottom: 0cm;"><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><u><b>2. Aufgabe</b></u></span></span></span><br />
</div><div style="margin-bottom: 0cm;"><span style="font-family: Courier New,monospace;"><span style="font-size: x-small;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">Belegen Sie die Variable </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>a</b></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"> mit </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>89</b></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"> und die Variable </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>b </b></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">mit </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>Hallo</b></span></span></span></span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Starten Sie eine Subshell! Was erhält man bei Eingabe des Befehls?</span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><b>echo $a; echo $b</b></span></span></span><br />
</div><div style="text-align: left;"><blockquote><ul><li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><b>Subshell starten: exec bash</b></span></span></span></li>
<li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><b>echo $a -> leer</b></span></span></span></li>
<li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><b>echo $b -> leer</b></span></span></span></li>
<li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><b>Raus aus subshell: exit</b></span></span></span></li>
</ul></blockquote></div><div lang="de-DE" style="margin-bottom: 0cm;"><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><u><b>3. Aufgabe</b></u></span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Sie möchten anstatt der aktuellen Shell die Korn-Shell benutzen. Wie lautet der Befehl?</span></span></span><br />
</div><blockquote><ul><li><b><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">exec ksh</span></span></span></b></li>
<li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">(Überprüfung: <b>ps -f</b>)</span></span></span></li>
</ul></blockquote><div lang="de-DE" style="margin-bottom: 0cm;"><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><u><b>4. Aufgabe</b></u></span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Sie haben folgenden Befehl ausgeführt:</span></span></span><br />
</div><div lang="en-GB" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><b>grep 'schul500' /etc/passwd >/dev/null</b></span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Wie können Sie herausfinden, ob nun das Suchmuster schul500 in der Datei /etc/passwd vorkommt? Es wird davon ausgegangen, dass die Datei /etc/passwd existent und lesbar ist.</span></span></span><br />
</div><ul><li><span style="font-family: Courier New,monospace;"><span style="font-size: x-small;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">Wenn echo </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>$? = 1 </b></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><span style="font-weight: normal;">ist, wurde kein Ergebniss gefunden,</span></span></span></span></span></span></span></li>
<li><span style="font-family: Courier New,monospace;"><span style="font-size: x-small;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>bei $? = 0 </b></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><span style="font-weight: normal;">wurde etwas gefunden (zB bei grep).</span></span></span></span></span></span></span></li>
<li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">$? = 2 -> Datei existiert nicht</span></span></span></li>
</ul><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Probieren Sie auch den Befehl:</span></span></span><br />
</div><div lang="en-GB" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><b>grep 'schul500' /etc/paswd >/dev/null 2>&1</b></span></span></span><br />
</div><div lang="en-GB" style="margin-bottom: 0cm;"><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><u><b>5. Aufgabe</b></u></span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">Legen Sie unter dem <b>Home-Directory</b> ein Verzeichnis unixshell an.</span></span></span><br />
</div><div style="margin-bottom: 0cm;"><span style="font-family: Courier New,monospace;"><span style="font-size: x-small;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">In einer Variablen </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>US</b></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"> soll der vollständige Pfadname dieses Verzeichnisses stehen.</span></span></span></span></span></span><br />
</div><blockquote><div lang="de-DE" style="margin-bottom: 0cm; margin-left: 0.85cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">US=~/unixshell</span></span></span><br />
</div><div lang="de-DE" style="margin-bottom: 0cm; margin-left: 0.85cm;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;">cd $US</span></span></span><br />
</div></blockquote><div lang="de-DE" style="margin-bottom: 0cm;"><br />
<br />
</div><div style="margin-bottom: 0cm;"><span style="font-family: Courier New,monospace;"><span style="font-size: x-small;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">Was ist zu tun, damit die Variable </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><b>US</b></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"> nach jedem Login und in den Subshells zur Verfügung steht?</span></span></span></span></span></span><br />
</div><ul><li><span style="font-family: Courier New,monospace;"><span style="font-size: x-small;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">.profile (vorhanden? </span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE"><i><b>ls -la </b></i></span></span></span></span><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">in ~ durchführen)</span></span></span></span></span></span></li>
<li><span style="font-family: Courier New,monospace;"><span style="font-size: x-small;"><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><span lang="de-DE">Folgenden Eintrag hinzufügen:</span></span></span></span></span></span></li>
<li><span style="color: black;"><span style="font-family: Courier,Courier New,monospace;"><span style="font-size: x-small;"><b>US=/home/schul100/unixshell</b></span></span></span></li>
</ul>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0tag:blogger.com,1999:blog-8308690029353943826.post-24962430393451650252009-11-12T06:31:00.000-08:002009-11-12T06:33:03.920-08:00Übung Linux-Shell #1<b>1. Aufgabe: </b><br />
Erzeugen Sie eine Datei namens *<br />
<br />
<div style="text-align: center;"><b>touch \*</b> <br />
</div><br />
Löschen Sie die Datei *<br />
<br />
<div style="text-align: center;"><b>rm \*</b><br />
<br />
<div style="text-align: left;">Da es sich bei dem Sternchen um ein Sonderzeichen handelt, muss davor als Escape-Zeichen das backslash benutzt werden.<b><br />
</b><br />
</div></div><div style="text-align: center;"><br />
</div><div style="text-align: left;"><b> 2. Aufgabe:<br />
</b>Folgendes soll auf dem Bildschirm erscheinen:<br />
<i>Juengste Datei im aktuellen Ordner lautet: Dateiname der jüngsten Datei.</i><br />
<br />
</div><div style="text-align: center;"><b>echo "Juengste Datei im aktuellen Ordner lautet: `ls -tr | tail -1`"</b><br />
</div>Geisterbahnbesitzerhttp://www.blogger.com/profile/04918422512874454984noreply@blogger.com0