5 Linux-Befehle, die Ihr Leben als Programmierer verändern werden

Die Befehlszeilenschnittstelle ist das A und O für die meisten Technikexperten, insbesondere für Entwickler und Systemadministratoren. Ganz gleich, ob Sie Skripte schreiben, Server konfigurieren oder Aufgaben automatisieren, wenn Sie sich mit diesen 5 Linux-Befehle auskennen, können Sie stundenlange Arbeit sparen.

Für viele mag Linux auf den ersten Blick entmutigend erscheinen, aber sobald Sie das Potenzial der Befehlszeilenschnittstelle (CLI) ausschöpfen, werden Sie feststellen, dass es der beste Freund eines Programmierers ist. Von der Verzeichnisnavigation über die Dateimanipulation bis hin zum Debugging kann die Beherrschung dieser einfachen, aber leistungsstarken Linux-Befehle Ihren Arbeitsablauf drastisch verbessern.

In diesem Artikel stellen wir Ihnen 5 Linux-Befehle vor, die Ihnen als Entwickler das Leben erleichtern können. Dies sind nicht nur „nice-to-know“-Verknüpfungen – sie sind bahnbrechend, die Ihnen Zeit sparen und Ihre Interaktionen mit dem Terminal viel effizienter machen.

Erstellen mehrerer Kombinationen von Ordnern mit und geschweiften Klammern mkdir{}

Das Organisieren von Dateien und Verzeichnissen ist eine häufige Aufgabe für Entwickler, insbesondere wenn es um die Verwaltung von Projekten oder die Einrichtung komplexer Verzeichnisstrukturen geht. Damit kommen wir zum ersten der 5 Linux-Befehle. Normalerweise ist das Erstellen mehrerer Verzeichnisse mit vielen sich wiederholenden Eingaben verbunden. Es gibt jedoch einen mächtigen Trick mit dem Befehl, mit dem Sie mehrere Verzeichnisse auf einmal erstellen können, indem Sie geschweifte Klammern verwenden .mkdir{}

Das Problem

Angenommen, Sie möchten eine Ordnerstruktur für verschiedene Umgebungen (Entwicklung, Test und Produktion) für mehrere Dienste in Ihrem Projekt erstellen. Traditionell können Sie dies manuell tun, was wie folgt aussehen könnte:

mkdir dev
mkdir test
mkdir prod

Dies wird umständlich, wenn Ihre Struktur komplexer wird. Wenn Sie z. B. Ordner für beide und Dienste in allen drei Umgebungen benötigen, wird der Vorgang mühsam.backendfrontend

Die Lösung: mit Zahnspange mkdir{}

Anstatt jedes Verzeichnis einzeln zu erstellen, können Sie all dies in einem einzigen Befehl kombinieren, indem Sie und geschweifte Klammern verwenden. Auf diese Weise können Sie effizient Kombinationen von Verzeichnissen erstellen.mkdir{}

Zum Beispiel:

mkdir -p {dev,test,prod}/{backend,frontend}

Hier ist eine Aufschlüsselung der Geschehnisse:

• Das Flag weist an, dass bei Bedarf übergeordnete Verzeichnisse erstellt werden sollen (d.h. es werden keine Fehler ausgegeben, wenn die übergeordneten Verzeichnisse noch nicht existieren).-pmkdir
• Mit den geschweiften Klammern können Sie mehrere Optionen angeben, die automatisch kombiniert werden.{}mkdir
• Die erste Gruppe erstellt Verzeichnisse für verschiedene Umgebungen.{dev,test,prod}
• Die zweite Gruppe erstellt Verzeichnisse für verschiedene Dienste.{backend,frontend}

Was passiert hinter den Kulissen

Wenn dieser Befehl ausgeführt wird, wird die folgende Ordnerstruktur erstellt:

dev/
  backend/
  frontend/
test/
  backend/
  frontend/
prod/
  backend/
  frontend/

Warum dieser Trick ein Game-Changer ist

Diese Methode spart viel Zeit und reduziert menschliche Fehler, insbesondere wenn Sie große Projekte mit komplexen Ordnerstrukturen einrichten. Anstatt jede Kombination manuell einzugeben, können Sie sie in einem prägnanten Befehl definieren.

Navigieren Sie zurück mit cd -anstatt wiederholt cd .. zu verwenden

Als Programmierer kommt es häufig vor, dass Sie in tief verschachtelten Verzeichnissen arbeiten. Es kann z. B. sein, dass Sie aus dem Stammverzeichnis Ihres Projekts in Unterverzeichnisse für Code, Konfigurationsdateien oder Protokolle wechseln. Wenn es jedoch an der Zeit ist, zum Ausgangspunkt zurückzukehren, kann das manuelle Zurücknavigieren durch mehrmaliges Tippen frustrierend und fehleranfällig werden.cd ..

Das Problem

Stellen Sie sich vor, Sie arbeiten in einem verschachtelten Verzeichnis wie diesem:

/home/user/projects/webapp/src/frontend/components

Um zum Projektstamm zurückzukehren, müssen Sie normalerweise mehrmals eingeben, wie folgt:cd ..

cd ..
cd ..
cd ..
cd ..

Das sind vier separate Befehle, nur um zu . Das ist nicht nur mühsam, sondern kann auch leicht den Überblick darüber verlieren, woher Sie kommen./home/user/projects/

Die Lösung: cd -

Hier ist eine einfachere und schnellere Alternative: Verwenden Sie den Befehl, um sofort zu Ihrem vorherigen Verzeichnis zurückzukehren, unabhängig davon, wie tief Sie in eine verschachtelte Struktur eingedrungen sind.cd -

Wie es funktioniert

• Der Befehl navigiert nicht in der Verzeichnisstruktur nach oben, wie . Stattdessen werden Sie in das letzte Verzeichnis zurückgeführt, in dem Sie sich befanden, fast wie ein „Zurück“-Button in einem Webbrowser.cd -cd ..

Nehmen wir zum Beispiel an, Sie haben im Stammverzeichnis Ihres Projekts begonnen und sind dann in das verschachtelte Verzeichnis verschoben worden. Anstatt mehrmals zu tippen, um zurückzukehren, können Sie jetzt einfach Folgendes eingeben:/home/user/projects/webapp//home/user/projects/webapp/src/frontend/componentscd ..

cd -

Und Sie sind sofort wieder in ./home/user/projects/webapp/

Was passiert hinter den Kulissen

Der Befehl speichert das vorherige Verzeichnis im Speicher, sodass bei der Verwendung das aktuelle Verzeichnis gegen das letzte ausgetauscht wird. Es ist eine äußerst effiziente Möglichkeit, zwischen zwei Verzeichnissen hin und her zu navigieren, insbesondere wenn Sie zwischen einem Arbeitsverzeichnis und einem tief verschachtelten Verzeichnis hin- und herspringen.cd -

Praktischer Anwendungsfall

Dieser Trick ist besonders nützlich, wenn Sie debuggen oder an mehreren Teilen eines Projekts arbeiten. Wenn Sie häufig zwischen dem Stammverzeichnis des Projekts und einem tiefen Unterverzeichnis wechseln müssen, erspart Ihnen dies das Tippen langer Pfade oder das Navigieren nach oben.cd -

Erstellen Sie schnell mehrere Dateien mit und einem Zahlenbereich touch

Das Erstellen mehrerer Dateien ist eine häufige Aufgabe für Entwickler, unabhängig davon, ob Sie Testdateien, Platzhalter oder Protokolle generieren. Während Sie normalerweise Dateien einzeln erstellen, wird dies bei einer großen Anzahl von Dateien manuell umständlich. Glücklicherweise bietet Linux eine Möglichkeit, mehrere Dateien in einem einzigen Befehl mit und einem Zahlenbereich in geschweiften Klammern zu erstellen.touch{}

Das Problem

Stellen Sie sich vor, Sie müssen 100 nummerierte Dateien für eine Reihe von Testfällen erstellen, z. B. , , bis hin zu . Wenn Sie dies manuell mit einzelnen Befehlen tun, würde das in etwa so aussehen:test1.txttest2.txttest100.txttouch

touch test1.txt
touch test2.txt
touch test3.txt
...
touch test100.txt

Wie Sie sich vorstellen können, ist dies mühsam und zeitaufwändig. Aber es gibt einen besseren Weg!

Die Lösung: mit Nummernkreis und geschweiften Klammern touch{}

Sie können den Befehl mit einem Zahlenbereich in geschweiften Klammern verwenden, um schnell mehrere Dateien auf einmal zu erstellen. Und so funktioniert es:touch{}

touch test{1..100}.txt

Was passiert hier

• Der Befehl wird verwendet, um neue Dateien zu erstellen. Normalerweise würden Sie es wie folgt verwenden: .touchtouch filename.txt
• Indem Sie einen Nummernbereich in geschweiften Klammern hinzufügen, weisen Sie die Shell an, Dateien mit den Nummern von 1 bis 100 zu erstellen.{1..100}
• Das Ergebnis ist die Erzeugung von , , , bis hin zu – in einem einzigen Befehl.test1.txttest2.txttest3.txttest100.txt

Beispiel

Schauen wir es uns genauer an. Ausgeführte:

touch test{1..10}.txt

Erstellt die folgenden Dateien in Ihrem Verzeichnis:

test1.txt
test2.txt
test3.txt
...
test10.txt

Warum dieser Trick ein Game-Changer ist

Mit dieser Methode können Sie sofort mehrere Dateien generieren, sodass Sie nicht jede Datei einzeln manuell erstellen müssen. Dies ist besonders nützlich in Szenarien, in denen Sie Platzhalterdateien zum Testen oder Protokollieren benötigen, oder bei der Automatisierung von Prozessen, die mehrere Dateien als Eingabe erfordern.

Praktischer Anwendungsfall

Sie können diesen Trick z. B. verwenden, um schnell Protokolldateien zum Testen einer Anwendung zu generieren, die eine große Anzahl von Dateien verarbeitet. Anstatt jede Datei manuell zu erstellen, können Sie sie alle mit einem Befehl generieren und sich auf das Schreiben und Testen Ihres Codes konzentrieren.

Dateiaktualisierungen in Echtzeit mit tail -f

Als Programmierer, insbesondere bei der Arbeit mit Backend-Systemen, müssen Sie Protokolldateien häufig auf Fehler, Systemverhalten oder Debugging überwachen. In solchen Fällen kann es ineffizient sein, eine Protokolldatei immer wieder manuell zu überprüfen. Glücklicherweise verfügt der Befehl über eine Option, um Aktualisierungen automatisch in Echtzeit zu verfolgen, sodass Sie Änderungen überwachen können, sobald sie auftreten.tail

Das Problem

Angenommen, Sie arbeiten an einer Anwendung und müssen die Protokolldatei überwachen, um alle neuen Fehler zu verfolgen, die protokolliert werden. Normalerweise können Sie den Befehl verwenden, um die letzten Zeilen der Datei wie folgt zu lesen:error_file.logtail

tail error_file.log

Dadurch erhalten Sie zwar den aktuellen Status der Datei, sie wird jedoch nicht in Echtzeit aktualisiert. Wenn sich die Datei ändert, müssen Sie den Befehl erneut ausführen, um die neuen Zeilen anzuzeigen. Dies ist alles andere als ideal, insbesondere bei der Fehlerbehebung von Live-Systemen oder der Überwachung von Protokollen für Echtzeitereignisse.

Die Lösung: für Echtzeit-Updatestail -f

Mit dem Befehl können Sie die Änderungen in der Protokolldatei verfolgen, sobald sie auftreten. Auf diese Weise können Sie neue Zeilen sehen, die an die Datei angehängt werden, ohne den Befehl erneut ausführen zu müssen.tail -f

tail -f error_file.log

Was passiert hier

• Der Befehl selbst zeigt die letzten 10 Zeilen einer Datei an.tail
• Die Option steht für „follow“, wodurch das Terminal geöffnet bleibt und kontinuierlich neue Zeilen angezeigt werden, wenn sie der Datei hinzugefügt werden.-f

Dies ist besonders nützlich, wenn Sie Protokolldateien während der Ausführung Ihrer Anwendung überwachen, da Sie Fehlermeldungen oder Ausgaben in Echtzeit sehen können.

Beispiel

Angenommen, Sie überwachen die Protokolldatei eines Webservers, um eingehende Anforderungen und Fehler anzuzeigen:

tail -f /var/log/nginx/access.log

Wenn neue Anfragen eingehen, werden diese live in Ihrem Terminal angezeigt. Es ist nicht erforderlich, den Befehl zu aktualisieren oder erneut auszuführen – er folgt der Datei kontinuierlich auf Aktualisierungen.

Praktischer Anwendungsfall

Eine der praktischsten Anwendungen ist das Debuggen. Stellen Sie sich vor, Sie versuchen, die Ursache für ein zeitweilig auftretendes Problem in Ihrer Anwendung zu finden. Wenn Sie das Fehlerprotokoll der Anwendung in Echtzeit verfolgen, können Sie neue Fehlermeldungen sehen, sobald sie erscheinen, und sofort Maßnahmen ergreifen.tail -f

Sie können z. B. Folgendes ausführen:

tail -f /var/log/app/error.log

Wenn Ihre Anwendung abstürzt, wird die Fehlermeldung in Echtzeit angezeigt, sodass Sie ohne Verzögerung eine Fehlerbehebung durchführen können.

Bonus-Tipp: Kombinierbar mit grep

Wenn Sie eine Protokolldatei in Echtzeit verfolgen möchten, sich aber nur für bestimmte Einträge interessieren, können Sie mit kombinieren. Zum Beispiel:tail -fgrep

tail -f error_file.log | grep "ERROR"

Dieser Befehl zeigt nur die Zeilen an, die das Wort „ERROR“ enthalten, und hilft Ihnen, die Protokollausgabe nach relevanten Informationen zu filtern.

Überprüfen Sie die letzten Befehle mit history 5

Als Entwickler wiederholen wir oft bestimmte Befehle während einer Arbeitssitzung – sei es beim Kompilieren von Code, beim Verwalten von Dateien oder beim Neustart von Diensten. Und damit kommen wir zum letzten der 5 Linux-Befehle. Es kann schwierig sein, sich an die genaue Syntax eines Befehls zu erinnern, den Sie zuvor verwendet haben, oder Ihre Schritte zurückzuverfolgen, insbesondere wenn Sie stundenlang im Terminal gearbeitet haben.

Glücklicherweise verfolgt Linux jeden Befehl, den Sie in einer Sitzung ausführen. Mit dem Befehl können Sie eine Liste Ihrer zuvor ausgeführten Befehle anzeigen, und eine effiziente Verwendung kann Ihnen viel Zeit und Mühe sparen.history

Das Problem

Nehmen wir an, Sie arbeiten schon eine Weile und haben einen komplexen Befehl ausgeführt, den Sie jetzt wiederverwenden müssen. Sie können sich die genaue Syntax nicht ganz merken und es ist mühsam, manuell durch das Terminal zu scrollen, um es zu finden.grepfind

Die Lösung: Abrufen der letzten Befehlshistory 5

Der Befehl zeigt eine Liste der Befehle an, die Sie zuvor in Ihrer aktuellen Shellsitzung ausgeführt haben. Standardmäßig wird der gesamte Befehlsverlauf angezeigt, aber Sie können die Anzahl der angezeigten Befehle begrenzen, indem Sie eine Zahl angeben.history

Zum Beispiel:

history 5

Dadurch werden die letzten fünf Befehle angezeigt, die Sie ausgeführt haben, sodass Sie sie schnell abrufen und erneut ausführen können.

Was passiert hier

• history Allein druckt die gesamte Historie der Befehle aus der Sitzung aus.
• Indem Sie eine Zahl hinzufügen (z. B. ), beschränken Sie die Ausgabe auf die letzten fünf Befehle, sodass Sie sich auf die letzten Aufgaben konzentrieren können, die Sie ausgeführt haben.history 5

Wenn Ihre letzten fünf Befehle beispielsweise wie folgt lauten:

  123  ls
  124  cd src/
  125  mkdir newdir
  126  touch newfile.txt
  127  history 5

Beim Laufen wird Folgendes angezeigt:history 5

  123  ls
  124  cd src/
  125  mkdir newdir
  126  touch newfile.txt
  127  history 5

Warum dieser Trick nützlich ist

Wenn Sie vergessen haben, wie Sie einen Befehl ausgeführt haben, müssen Sie es nicht noch einmal herausfinden. Es eignet sich auch hervorragend zum Abrufen komplexer Befehle, z. B. Befehle mit langen Flags oder Optionen, die Sie nicht erneut aus dem Speicher eingeben möchten.history

Praktischer Anwendungsfall

Angenommen, Sie debuggen ein Programm und führen mehrere verschiedene Befehle aus, um Protokolle zu kompilieren, zu überprüfen und den Dienst neu zu starten. Anstatt sich jeden Befehl zu merken oder im Terminal zurückzuscrollen, können Sie einfach Folgendes ausführen:

history 5

Sie erhalten eine Liste Ihrer letzten fünf Befehle, sodass Sie jeden von ihnen mit minimalem Aufwand abrufen und erneut ausführen können.

Bonus-Tipp: Erneutes Ausführen von Befehlen

Sie können jeden Befehl aus dem Verlauf schnell erneut ausführen, indem Sie das Ausrufezeichen () gefolgt von der Befehlsnummer verwenden. Wenn Sie z. B. den Befehl von oben (Befehlsnummer 125) erneut ausführen möchten, geben Sie einfach Folgendes ein:!mkdir newdir

!125

Dies erspart Ihnen die erneute Eingabe des gesamten Befehls und kann insbesondere bei der Arbeit mit langen Befehlen eine echte Zeitersparnis sein.

Fazit

Die Beherrschung der Linux-Befehlszeilenschnittstelle ist für Entwickler unerlässlich, und die Tricks, die wir hier behandelt haben, sind leistungsstarke Tools, die Sie in Ihrem Toolkit haben sollten. Von der effizienten Verwaltung von Dateien und Ordnern über das Navigieren in Verzeichnissen bis hin zum Abrufen von Befehlen können diese 5 Linux-Befehle Ihren Arbeitsablauf erheblich optimieren und die Produktivität steigern:

• mkdir mit geschweiften Klammern, um mehrere Ordner auf einmal zu erstellen.
• cd - , um schnell zu Ihrem vorherigen Verzeichnis zurückzukehren.
• touch mit einem Bereich, um mehrere Dateien gleichzeitig zu erstellen.
• tail -f um Protokolldateien in Echtzeit zu verfolgen.
• history 5 , um die letzten Befehle abzurufen und erneut auszuführen.

Dies sind nur einige Beispiele für die Leistungsfähigkeit, die 5 Linux-Befehle bieten können. Indem Sie diese 5 Linux-Befehle in Ihren täglichen Arbeitsablauf integrieren, können Sie sich mehr auf das Programmieren und weniger auf sich wiederholende Aufgaben konzentrieren, was Sie zu einem effizienteren und produktiveren Programmierer macht.

Weitere interessante Themen: Softwareentwickler oder Software-Ingenieur?