Skip to content

Commit 0179c99

Browse files
lean-devlean-dev
committed
feat: Add articles for io channels, search and filter.
1 parent 42d19bd commit 0179c99

10 files changed

Lines changed: 669 additions & 0 deletions

File tree

‎astro.config.mjs‎

Lines changed: 12 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -41,6 +41,18 @@ export default defineConfig({
4141
label: 'Dateien',
4242
autogenerate: { directory: 'basics/dateien' },
4343
},
44+
{
45+
label: 'Ein-/Ausgabe',
46+
autogenerate: { directory: 'basics/io' },
47+
},
48+
{
49+
label: 'Filter',
50+
autogenerate: { directory: 'basics/filter' },
51+
},
52+
{
53+
label: 'Suchen',
54+
autogenerate: { directory: 'basics/suchen' },
55+
},
4456
],
4557
},
4658
{

‎docusaurus/docs/basics/shell-intro/substitutions.md‎

Whitespace-only changes.

‎src/content/docs/basics/filter/befehle.mdx‎

Lines changed: 180 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,180 @@
1+
---
2+
title: Filter-Befehle
3+
sidebar:
4+
order: 2
5+
---
6+
7+
import { Aside, Tabs, TabItem } from '@astrojs/starlight/components';
8+
9+
## Anzeigen & Zählen
10+
11+
### `cat` – Inhalt ausgeben
12+
13+
`cat` gibt den Inhalt einer oder mehrerer Dateien nach stdout aus. Ohne Argument liest es von stdin:
14+
15+
```bash
16+
cat datei.txt # Datei ausgeben
17+
cat datei1.txt datei2.txt # mehrere Dateien hintereinander
18+
cat datei1.txt datei2.txt > zusammen.txt # zusammenführen
19+
```
20+
21+
Als Filter in einer Pipeline:
22+
23+
```bash
24+
cat /etc/passwd | grep root
25+
```
26+
27+
<Aside type="tip">
28+
Wenn nur eine Datei verarbeitet wird, ist `cat file | befehl` oft unnötig – `befehl file` funktioniert genauso. Der Einsatz von `cat` ergibt Sinn, wenn mehrere Dateien kombiniert werden oder die Pipeline-Logik es erfordert.
29+
</Aside>
30+
31+
### `head` und `tail` – Anfang und Ende
32+
33+
```bash
34+
head datei.txt # erste 10 Zeilen (Standard)
35+
head -n 20 datei.txt # erste 20 Zeilen
36+
head -n -5 datei.txt # alles außer den letzten 5 Zeilen
37+
38+
tail datei.txt # letzte 10 Zeilen (Standard)
39+
tail -n 20 datei.txt # letzte 20 Zeilen
40+
tail -n +5 datei.txt # ab Zeile 5 bis zum Ende
41+
```
42+
43+
`tail -f` folgt einer wachsenden Datei in Echtzeit – unverzichtbar für Log-Monitoring:
44+
45+
```bash
46+
tail -f /var/log/syslog
47+
tail -f /var/log/nginx/access.log
48+
```
49+
50+
<Aside type="tip">
51+
`tail -f` wartet auf neue Zeilen und gibt sie sofort aus. Beenden mit `Strg`+`C`. Ideal um einem laufenden Dienst beim Schreiben von Logs zuzusehen.
52+
</Aside>
53+
54+
### `wc` – zählen
55+
56+
`wc` (*Word Count*) zählt Zeilen, Wörter und Zeichen:
57+
58+
```bash
59+
wc datei.txt
60+
# 42 318 2104 datei.txt
61+
# ^ ^ ^
62+
# | | Bytes
63+
# | Wörter
64+
# Zeilen
65+
```
66+
67+
Einzelne Werte:
68+
69+
```bash
70+
wc -l datei.txt # nur Zeilen
71+
wc -w datei.txt # nur Wörter
72+
wc -c datei.txt # nur Bytes
73+
74+
ls /etc | wc -l # Anzahl Einträge in /etc
75+
```
76+
77+
### `less` – seitenweiser Pager
78+
79+
`less` zeigt langen Output seitenweise an – nützlich wenn eine Ausgabe nicht auf den Bildschirm passt:
80+
81+
```bash
82+
less datei.txt
83+
ls -la /etc | less
84+
cat /var/log/syslog | less
85+
```
86+
87+
Navigation wie in `man`: `Space`/`b`, `/suche`, `q` zum Beenden.
88+
89+
---
90+
91+
## Sortieren & Filtern
92+
93+
### `sort` – sortieren
94+
95+
```bash
96+
sort datei.txt # alphabetisch aufsteigend
97+
sort -r datei.txt # absteigend
98+
sort -n zahlen.txt # numerisch (nicht lexikografisch)
99+
sort -h größen.txt # menschenlesbare Größen (1K, 2M, ...)
100+
sort -u datei.txt # sortieren und Duplikate entfernen
101+
sort -t: -k3 -n /etc/passwd # Feld 3, :-getrennt, numerisch sortieren
102+
```
103+
104+
```bash
105+
ls -1 /etc | sort -r | head -5 # letzte 5 Einträge alphabetisch
106+
```
107+
108+
### `uniq` – Duplikate entfernen
109+
110+
`uniq` entfernt **aufeinanderfolgende** identische Zeilen. Fast immer in Kombination mit `sort`:
111+
112+
```bash
113+
sort datei.txt | uniq # sortieren, dann Duplikate entfernen
114+
sort datei.txt | uniq -c # mit Häufigkeit voranstellen
115+
sort datei.txt | uniq -d # nur Duplikate anzeigen
116+
sort datei.txt | uniq -u # nur Unikate anzeigen (kein Duplikat)
117+
```
118+
119+
Typischer Einsatzfall – häufigste Einträge in einem Log:
120+
121+
```bash
122+
cat access.log | cut -d' ' -f1 | sort | uniq -c | sort -rn | head -10
123+
# → Top-10 IP-Adressen nach Anzahl der Zugriffe
124+
```
125+
126+
<Aside type="note">
127+
`uniq` prüft nur *benachbarte* Zeilen. `a, b, a` – hier wird kein Duplikat erkannt. Deshalb immer zuerst `sort`, dann `uniq`.
128+
</Aside>
129+
130+
---
131+
132+
## Ausschneiden & Ersetzen
133+
134+
### `cut` – Felder ausschneiden
135+
136+
`cut` extrahiert Spalten aus strukturiertem Text:
137+
138+
```bash
139+
# -d Trennzeichen, -f Feldnummer(n)
140+
cut -d: -f1 /etc/passwd # Benutzernamen (Feld 1, getrennt durch :)
141+
cut -d: -f1,3 /etc/passwd # Benutzername und UID
142+
cut -d, -f2-4 daten.csv # Felder 2 bis 4 einer CSV
143+
144+
# -c Zeichenpositionen
145+
cut -c1-10 datei.txt # erste 10 Zeichen jeder Zeile
146+
```
147+
148+
```bash
149+
cat /etc/passwd | cut -d: -f1 | sort
150+
# → alle Benutzernamen alphabetisch
151+
```
152+
153+
### `tr` – Zeichen übersetzen und löschen
154+
155+
`tr` (*Translate*) ersetzt oder löscht einzelne Zeichen. Es liest nur von stdin:
156+
157+
```bash
158+
echo "hallo welt" | tr 'a-z' 'A-Z' # → HALLO WELT
159+
echo "hallo welt" | tr ' ' '_' # → hallo_welt
160+
echo "hallo welt" | tr -s ' ' # mehrfache Leerzeichen zusammenführen (-s squeeze)
161+
echo "hallo123" | tr -d '0-9' # Ziffern löschen (-d delete) → hallo
162+
cat datei.txt | tr -d '\r' # Windows-Zeilenenden entfernen
163+
```
164+
165+
<Tabs>
166+
<TabItem label="Zeichenbereiche">
167+
```bash
168+
tr 'a-z' 'A-Z' # Kleinbuchstaben → Großbuchstaben
169+
tr 'A-Z' 'a-z' # Großbuchstaben → Kleinbuchstaben
170+
tr '0-9' 'a-j' # Ziffern → Buchstaben
171+
```
172+
</TabItem>
173+
<TabItem label="Sonderzeichen">
174+
```bash
175+
tr ' ' '\n' # Leerzeichen → Zeilenumbruch (ein Wort pro Zeile)
176+
tr '\n' ' ' # Zeilenumbrüche → Leerzeichen (alles in eine Zeile)
177+
tr -d '\r' # Carriage Returns entfernen (Windows → Unix)
178+
```
179+
</TabItem>
180+
</Tabs>

‎src/content/docs/basics/filter/index.mdx‎

Lines changed: 21 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,21 @@
1+
---
2+
title: Filter-Kommandos
3+
sidebar:
4+
order: 1
5+
label: Einführung
6+
---
7+
8+
Als **Filter** bezeichnet man in Unix/Linux Programme, die Daten von stdin lesen, verarbeiten und nach stdout schreiben – sie filtern, transformieren oder zählen Textdaten im Datenstrom.
9+
10+
Filter sind die Bausteine von Pipelines. Jeder einzelne Filter macht eine Sache gut; zusammengesetzt lösen sie komplexe Aufgaben:
11+
12+
```bash
13+
cat zugriffe.log | grep "ERROR" | sort | uniq -c | sort -rn | head -10
14+
# → die 10 häufigsten Fehlermeldungen im Log, absteigend sortiert
15+
```
16+
17+
Die wichtigsten Filter-Kommandos:
18+
19+
- [Anzeigen & Zählen](befehle#anzeigen--zählen) – `cat`, `head`, `tail`, `wc`, `less`
20+
- [Sortieren & Filtern](befehle#sortieren--filtern) – `sort`, `uniq`
21+
- [Ausschneiden & Ersetzen](befehle#ausschneiden--ersetzen) – `cut`, `tr`

‎src/content/docs/basics/io/index.mdx‎

Lines changed: 50 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,50 @@
1+
---
2+
title: Ein-/Ausgabe
3+
sidebar:
4+
order: 1
5+
label: Die drei Kanäle
6+
---
7+
8+
import { Aside } from '@astrojs/starlight/components';
9+
10+
Jedes Linux-Programm hat beim Start automatisch drei geöffnete **Kommunikationskanäle**:
11+
12+
| Kanal | Nummer | Name | Standard |
13+
|---|---|---|---|
14+
| **stdin** | 0 | Standard-Eingabe | Tastatur |
15+
| **stdout** | 1 | Standard-Ausgabe | Terminal |
16+
| **stderr** | 2 | Standard-Fehlerausgabe | Terminal |
17+
18+
Das Entscheidende: Ein Programm *weiß nicht*, woher seine Eingabe kommt oder wohin seine Ausgabe geht. Es liest von stdin und schreibt nach stdout – egal ob dahinter eine Tastatur, eine Datei oder ein anderes Programm steckt. Dieses Prinzip ist die Grundlage für Umleitungen und Pipes.
19+
20+
## stdout und stderr in der Praxis
21+
22+
Auf den ersten Blick landen beide Kanäle auf dem Terminal – sie sehen gleich aus:
23+
24+
```bash
25+
ls /etc/hosts
26+
# /etc/hosts ← stdout
27+
28+
ls /gibt/es/nicht
29+
# ls: cannot access '/gibt/es/nicht': No such file or directory ← stderr
30+
```
31+
32+
Der Unterschied wird sichtbar, sobald man die Ausgabe umleitet: stdout und stderr lassen sich unabhängig voneinander lenken – Fehlermeldungen können so von der normalen Ausgabe getrennt werden.
33+
34+
## stdin in der Praxis
35+
36+
Viele Befehle lesen von stdin, wenn keine Datei als Argument angegeben wird:
37+
38+
```bash
39+
cat
40+
# wartet auf Tastatureingabe, gibt jede Zeile direkt zurück
41+
# Beenden: Strg+D
42+
```
43+
44+
Das macht sie zu **Filtern** – sie können Daten aus einer Datei, von der Tastatur oder aus einer Pipe verarbeiten, ohne dass der Befehl selbst geändert werden muss.
45+
46+
<Aside type="note">
47+
Diese drei Kanäle sind in der Unix-Philosophie tief verankert: *"Write programs that do one thing and do it well. Write programs to work together. Write programs to handle text streams."* – Doug McIlroy, einer der Väter von Unix.
48+
</Aside>
49+
50+
Wie die Kanäle umgeleitet und verbunden werden, zeigen die nächsten beiden Artikel.

‎src/content/docs/basics/io/pipes.mdx‎

Lines changed: 83 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -0,0 +1,83 @@
1+
---
2+
title: Pipes
3+
sidebar:
4+
order: 3
5+
---
6+
7+
import { Aside } from '@astrojs/starlight/components';
8+
9+
Eine **Pipe** (`|`) verbindet den stdout eines Befehls direkt mit dem stdin des nächsten – ohne eine temporäre Datei. Die beiden Programme laufen dabei gleichzeitig; der erste produziert Daten, der zweite verarbeitet sie sofort.
10+
11+
```bash
12+
befehl1 | befehl2
13+
```
14+
15+
## Einfache Beispiele
16+
17+
```bash
18+
ls /etc | sort -r # Verzeichnisinhalt umgekehrt sortieren
19+
cat /etc/passwd | wc -l # Anzahl Zeilen in /etc/passwd zählen
20+
echo "hallo welt" | tr 'a-z' 'A-Z' # in Großbuchstaben umwandeln
21+
```
22+
23+
## Pipelines – mehrere Befehle verketten
24+
25+
Mehrere Pipes lassen sich zu einer **Pipeline** verketten. Die Daten fließen von links nach rechts durch jeden Befehl:
26+
27+
```bash
28+
cat /etc/passwd | cut -d: -f1 | sort | head -5
29+
# → erste 5 Benutzernamen alphabetisch sortiert
30+
```
31+
32+
Schritt für Schritt:
33+
1. `cat /etc/passwd` – gibt die Datei aus
34+
2. `cut -d: -f1` – schneidet das erste `:`-getrennte Feld heraus (Benutzername)
35+
3. `sort` – sortiert alphabetisch
36+
4. `head -5` – zeigt nur die ersten 5 Zeilen
37+
38+
```bash
39+
ls -lh /var/log/*.log | sort -k5 -h | tail -5
40+
# → die 5 größten Log-Dateien nach Größe sortiert
41+
```
42+
43+
<Aside type="tip">
44+
Beim Entwickeln einer langen Pipeline schrittweise vorgehen: Erst `befehl1` ausführen und Ausgabe prüfen, dann `befehl1 | befehl2`, usw. So sieht man an jeder Stelle, was die Pipeline bisher produziert.
45+
</Aside>
46+
47+
## Pipes und stderr
48+
49+
Die Pipe verbindet **nur stdout** – stderr fließt weiterhin direkt auf das Terminal:
50+
51+
```bash
52+
ls /etc /nichtvorhanden | wc -l
53+
# ls: cannot access '/nichtvorhanden': No such file or directory ← stderr aufs Terminal
54+
# 212 ← stdout durch Pipe an wc
55+
```
56+
57+
Sollen auch Fehlermeldungen durch die Pipe fließen:
58+
59+
```bash
60+
ls /etc /nichtvorhanden 2>&1 | grep "No such"
61+
# ls: cannot access '/nichtvorhanden': No such file or directory
62+
```
63+
64+
## Pipe vs. Umleitung
65+
66+
```
67+
Umleitung: befehl > datei.txt
68+
69+
┌─────────┐ stdout ┌───────────┐
70+
│ befehl │ ─────────►│ datei.txt │
71+
└─────────┘ └───────────┘
72+
73+
74+
Pipe: befehl1 | befehl2
75+
76+
┌──────────┐ stdout stdin ┌──────────┐
77+
│ befehl1 │ ─────────────────►│ befehl2 │
78+
└──────────┘ └──────────┘
79+
```
80+
81+
<Aside type="note">
82+
Pipes sind oft schneller als der Umweg über eine temporäre Datei (`befehl1 > tmp.txt && befehl2 < tmp.txt`), weil keine Disk-I/O anfällt. Bei sehr großen Datenmengen ist das ein spürbarer Unterschied.
83+
</Aside>

0 commit comments

Comments
 (0)