Podstawy linii poleceń – Część 2

Przydatne komendy¶

W tym rozdziale przedstawię kilka przydatnych komend, o których istnieniu warto wiedzieć. Nie musisz znać na pamięć szczegółów ich użycia – zawsze możesz zajrzeć tutaj, lub skorzystać z argumentu /?, aby dowiedzieć się więcej o danej komendzie.

Komenda cd oraz katalog roboczy¶

Komendę cd, czyli change directory, już poznaliśmy. Jest to jedna z cześciej używanych komend. Powoduje ona zmianę katalogu roboczego na ten wskazany jako argument:

Katalog roboczy jest katalogiem "bazowym" wykonywania komend w linii poleceń.

Dla przykładu, jeżeli będziesz chciał skompilować klasę Java za pomocą kompilatora javac, to kompilator ten domyślnie będzie szukał pliku, który mu wskażesz, w aktualnym katalogu roboczym linii poleceń. Jeżeli utworzyłbym plik MojaKlasa.java w katalogu:

C:\Users\Przemek\Desktop\programowanie

to poniższa próba kompilacji klasy zawartej w pliku MojaKlasa.java zakończyłaby się niepowodzeniem, gdyby moim katalogiem roboczym był inny katalog:

Jeżeli zmienimy katalog roboczy za pomocą komendy cd na podkatalog programowanie, to kompilacja tym razem zakończy się sukcesem:

Kolejny przykład – jeżeli skorzystasz z komendy cd, aby przejść do pewnego katalogu, to ten katalogu musi znajdować się w aktualnym katalogu roboczym. Innymi słowy, katalog, do którego chcesz przejść, musi być podkatalogiem katalogu roboczego – spójrz na poniższą strukturę katalogów:

Users
|
`-- Przemek
    |
    |-- AppData
    |
    `-- Desktop
        |
        |-- dokumenty
        |
        |-- ksiazki
        |
        `-- programowanie

Gdyby moim katalogiem roboczym w linii poleceń był katalog Desktop, to mógłbym z niego przejść bezpośrednio do katalogów: dokumenty, ksiazki, lub programowanie. Gdyby tym katalogiem był katalog Przemek, to mógłbym przejść bezpośrednio do katalogów AppData lub Desktop.

Możesz zastanawiać się teraz, czy w takim razie można przejść do katalogu, który jest kilka poziomów niżej – np. z katalogu Users do katalogu dokumenty. Tak – wystarczy podać ścieżkę do konkretnego katalogu z uwzględnieniem jego katalogów nadrzędnych, rozdzielonych znakiem backslash \:

Bardzo przydatnym skrótem podczas nawigowania między katalogami jest Tab – powoduje on automatyczne dokończenie wpisywanej przez nas nazwy katalogu. Możemy użyć go kilkukrotnie, aby wybrać katalog, który nas interesuje, jeżeli za pierwszym razem dopasowany został inny katalog o podobnej nazwie. Użycie tego skrótu obrazuje poniższa animacja:

Katalog nadrzędny¶

Katalog-rodzic aktualnego katalogu, w którym się znajdujemy, czyli katalog nadrzędny, określamy w specjalny sposób – za pomocą dwóch kropek ..

Dzięki użyciu .. możemy przejść do katalogu wyżej:

Z .. możemy korzystać wielokrotnie. Dla przykładu, użycie ..\.. oznacza "katalog nadrzędny katalog nadrzędnego", czyli katalog dwa poziomy wyżej. Spójrzmy na przykład – pierwsze .. oznacza katalog nadrzędny katalogu Desktop, czyli katalog Przemek, a drugie .. oznacza katalog nadrzędny katalogu Przemek, czyli Users – i do tego katalogu właśnie przejdziemy:

Możemy też przeplatać nazwy katalogów i użycie .. aby dotrzeć do interesującego nas katalogu:

Aktualny katalog¶

Aktualny katalog także oznaczamy w specjalny sposób – za pomocą jednej kropki. Czasem możemy mieć potrzebę wskazać lokalizację do pewnego pliku, a użycie .\ na początku jednoznacznie świadczy o tym, że chodzi nam o lokalizację względną do aktualnego katalogu roboczego.

Przechodzenie na inne dyski¶

Często nasze komputery posiadają kilka dysków. Próba przejścia do katalogu na innym dysku za pomocą komendy cd nie skutkuje powodzeniem:

Aby zmienić dysk, na którym pracujemy z poziomu linii poleceń, należy napisać po prostu identyfikator tego dysku wraz z dwukropkiem – bez żadnej komendy:

Innym sposobem jest dodanie argumentu /d do komendy cd, który spowoduje, że dysk zostanie zmieniony:

Komenda dir¶

Ciężko byłoby zapamiętać nazwy wszystkich plików i katalogów na dysku, do których moglibyśmy chcieć się odnieść w linii poleceń. Na szczęście mamy do dyspozycji komendę dir, która zwraca listę katalogów i plików w podanym jako argument katalogu. Jeżeli nie podamy argumentu, to zwróci ona listę katalogów i plików w aktualnym katalogu roboczym:

Zauważ, że na zwróconej liście są także . (aktualny katalog) oraz .. (wskazanie na katalog nadrzędny).

Jeżeli podamy jako argument ściężkę do katalogu, to komenda dir zwróci jego zawartość:

Przydatne argumenty modyfikujące sposób działania komendy dir to /b oraz /s. Pierwszy pokazuje same nazwy plików i katalogów, bez dodatkowych informacji, a drugi pokazuje pliki i katalogi także we wszystkich podkatalogach (oraz podkatalogach podkatalogów itd.). Przykład użycia obu tych argumentów:

Komenda more¶

Jeżeli wywołamy komendę, która zwraca dużo danych, zostaną one na raz wypisane do okna linii poleceń. Czasami możemy mieć potrzebę przeglądać wyniki komendy bądź zawartość pliku strona po stronie.

Komenda more oferuje taką funkcjonalność. Przekazujemy jej dane do wyświetlenia bądź wskazujemy plik. Jeżeli dane nie zmieszczą się na jednym ekranie, na dole zobaczymy napis -- MORE --, a kolejną stronę danych będziemy mogli zobaczyć po naciśnięciu Spacji. Możemy też przeglądać wpisy linia po linii naciskając Enter. Aby zakończyć przeglądanie przedwcześnie, należy nacisnąć q (małe Q).

Spójrzmy na przykład użycia more do wyświetlenia zawartości długiego pliku:

Komenda more może także otrzymać dane ze standardowego wejścia, przekazane jej za pomocą przekierowania z innej komendy (o tych zagadnieniach opowiemy sobie w kolejnych rozdziałach):

Komenda echo¶

Komenda echo wypisuje przekazany jej jako argument tekst:

Dodatkowo, komenda ta może być stosowana do wypisywania wartości zmiennych systemowych. Zmienne systemowe przechowują wartości używane przez system operacyjny oraz różne aplikacje.

Jedną z najistotniejszych, z punktu widzenia programistów, zmiennych systemowych jest zmienna path. Określa ona ścieżki do programów, do których mamy dostęp m. in. z linii poleceń. Aby odnieść się do wartości zmiennej systemowej, otaczamy ją znakami procentu %. Możemy w ten sposób wypisać wartość zmiennej path za pomocą komendy echo:

Komenda echo stosowana jest także w skryptach do wypisywania tekstu na ekran linii poleceń, w tym wartości zmiennych zdefiniowanych w skryptach. Może ona także przyjąć argument off lub on, który powoduje wyłączenie bądź włączenie wypisywania wywołanych komend. Kiedy to może być przydatne – zobaczymy w rozdziale o pisaniu skryptów.

Komenda set¶

Komenda set służy do przypisywania wartości zmiennym – zarówno systemowym, jak i zmiennym w skryptach, które możemy pisać dla linii poleceń.

Aby przypisać zmiennej pewną wartość, podajemy jej nazwę oddzieloną od wartości znakiem równości:

W powyższym przykładzie zmieniłem wartość zmiennej systemowej java_home na nowa_wartosc.

Ustawiając wartość zmiennej możemy pobrać jej aktualną wartość i dodać ją do nowej wartości. Jest to przydatne, jezeli np. chcemy dodać do zmiennej path lokalizację do pewnego programu, zachowując tym samym dotychczasowe wpisy zawarte w tej zmiennej:

Aby dodać nową wartość na koniec zmiennej systemowej path, komendzie set przekazałem aktualną wartość tej zmiennej za pomocą składni %nazwa_zmiennej%, po której nastąpiła ścieżka D:\programowanie\app\gradle\bin.

Komenda clip¶

Komenda clip jest przydatna, gdy potrzebujemy skopiować wynik wykonania pewnej komendy do schowka, tzn. abyśmy mogli go potem wkleić do dowolnego edytora za pomocą skrótu Ctrl + v.

Dla przykładu, możemy skopiować wartość zmiennej systemowej wypisanej za pomocą komendy echo:

Gdy teraz skorzystamy ze skrótu Ctrl + v np. w programie Notepad++, wklejony zostanie następujący tekst:

C:\Windows\system32;C:\Windows;
  C:\Windows\System32\WindowsPowerShell\v1.0\;
  C:\Program Files\Git\cmd;
  C:\Program Files\Java\jdk-12.0.2\bin;
  D:\programowanie\app\apache-maven-3.6.3\bin;
  D:\programowanie\app\groovy-2.5.9\bin;
  D:\programowanie\app\gradle\bin

Możemy w ten sam sposób skopiować wynik działania innych komend, np. komendy dir.

Komenda cls¶

Komenda cls (clear screen) służy do wyczyszczenia okna linii poleceń ze wszystkich komend (oraz wyników ich działania), której do tej pory wykonaliśmy. Przydaje się, gdy chcemy "na czysto" popatrzeć na wyniki kolejnej komendy, którą wywołamy.

Załóżmy, że moje okno linii poleceń wygląda następująco:

Po zatwierdzeniu Enterem komendy cls, którą zacząłem pisać powyżej, całe okno linii poleceń będzie wyglądało następująco:

Komenda tree¶

Komenda tree zwraca czytelnie sformatowane drzewo wszystkich podkatalogów katalogu przekazanego jako argument, lub katalogu roboczego, jeżeli nie podamy żadnego katalogu:

Możemy przekazać argument /f, który spowoduje wyświetlenie także plików zawartych w katalogach:

Komenda where¶

Komenda where szuka plików, których nazwa pasuje do podanego wzorca. Pliki wyszukiwane są w podanym przez nas katalogu. Możemy przekazać argument /r aby komenda where szukała także we wszystkich podkatalogach:

Zauważ, że jako drugi argument podałem kropkę – ten argument to katalog, w którym komenda where ma rozpocząć szukanie. Kropka oznacza "aktualny katalog", czyli katalog, w którym w tej chwili znajdujemy się w linii poleceń – w tym przypadku, kropka oznacza katalog D:\kursjava_przyklady\rozwiazania_do_zadan.

Powyższa komenda szuka wszystkich plików o rozszerzeniu .java. Gwiazdka * na początku wzorca nazwy pliku oznacza "dowolny ciąg znaków".

Komenda findstr¶

Aby wyszukać pliki, w których znajduje się pewien ciąg znaków, skorzystaj z komendy findstr. Przydatnymi argumentami są:

• /s – wyszukiwanie we wszystkich podkatalogach,
• /i – wyszukiwanie bez uwzględnienia wielkości liter, tzn. frazy np. tekst i TEKST będą uznawane za takie same – domyślnie, frazy te uznawane są za różne.

Poniższy przykład wywołania komendy findstr wyszukuje tekst Hello we wszystkich plikach z rozszerzeniem .java we wszystkich podkatalogach, bez uwzględnienia wielkości znaków w szukanej frazie Hello:

Jako wynik komenda zwraca ścieżkę do pliku, w którym znaleziono szukaną frazę, oraz linię, w której ta fraza została znaleziona.

Komenda type¶

Komenda type wyświetla na ekranie linii poleceń zawartość pliku podanego jako argument:

Komendy mkdir i rmdir¶

Komenda mkdir tworzy katalog o podanej nazwie, a rmdir usuwa go. Możesz podać kilka oddzielonych od siebie nazw, aby utworzyć hierarchię katalogów.

Komenda:

Spowoduje utworzenie katalogu o nazwie pewien_katalog, w którym znajdzie się katalog drugi, a ten z kolei będzie zawierał katalog trzeci.

Komenda rmdir domyślnie usuwa katalog tylko w przypadku, gdy jest on pusty:

Katalog nie został usunięty, ponieważ poprzednią komendą mkdir utworzyliśmy w nim zagnieżdżone katalogi. Aby usunąć katalog i wszystkie jego pliki i podkatalogi, użyj argumentu /s:

W trakcie działania komenda poprosiła mnie o potwierdzenie, czy aby na pewno chcę usunąć katalog pewien_katalog i całą jego zawartość – potwierdziłem wpisując znak Y i zatwierdzając Enterem.

Komenda del¶

Komenda rmdir z poprzedniego rozdziału dedykowana jest dla katalogów. Aby usuwać pliki, korzystamy z komendy del:

Komendy ping i ipconfig¶

Komenda ping wysyła zapytanie do komputera określonego przez adres IP lub nazwę. Przydaje się, gdy chcemy sprawdzić, czy np. mamy dostęp do Internetu:

Możesz dodać argument -n liczba, aby komenda ping wykonała podaną liczbę zapytań, np. -n 10 spowoduje wysłanie 10 zapytań.

Innym przydatnym zastosowaniem komendy ping jest sprawdzenie, czy z naszego komputera jesteśmy w stanie dostać się do innego komputera bądź maszyny wirtualnej. Przydaje się ona np. gdy mamy zainstalowaną aplikację do tworzenia wirtualnych maszyn (np. VirtualBox) i chcemy sprawdzić, czy mamy dostęp do maszyny wirtualnej, lub czy ona ma dostęp do naszego komputera.

Aby jednak wiedzieć, jaki adres przekazać komendzie ping, możesz skorzystać z komendy ipconfig, która zwraca listę adresów skojarzonych z Twoim komputerem (lub maszyną wirtualną):

Zaznaczony powyżej adres można przekazać jako argument do komendy ping z poziomu maszyny wirtualnej, aby sprawdzić, czy ma ona dostęp do naszego "głównego" komputera.

Komenda help¶

Komenda help wywołana bez żadnych argumentów zwraca listę dostępnych komend, dedykowanych dla systemu Windows:

Mi wyświetliły się 84 komendy. Możesz przekazać dowolną komendę jako argument do komendy help, aby otrzymać o niej szczegółowe informacje:

Komenda title¶

Komenda title powoduje ustawienie tytułu okna linii poleceń na to podane jako argument. Jeżeli potrzebujesz otworzyć kilka okien linii poleceń, to możesz skorzystać z tej komendy, aby nadać im nazwy, dzięki czemu łatwiej będzie Ci identyfikować konkretne okna na pasku zadań.

Zauważ, że tytuł powyższego okna zmienił się na "Okno z katalogiem Programowanie" z domyślnego "Wiersz polecenia".

Komenda exit¶

Komenda exit powoduje zamknięcie okna linii poleceń. Czasem wygodniej jest napisać exit i wcisnąć Enter, niż za pomocą myszy kliknąć na X w prawym górnym rogu okna, aby je zamknąć.

Zmienne systemowe a linia poleceń¶

Zmienne systemowe to nazwane wartości zdefiniowane w systemie operacyjnym.

Jedną z kluczowych zmiennych systemowych dla programistów jest zmienna o nazwie path. Ta zmienna określa, które z zainstalowanych w naszym systemie programów będziemy mogli używać z poziomu linii poleceń.

Dla przykładu, jednorazowo, gdy otrzymamy nowy komputer lub zainstalujemy nową wersję systemu Windows, w zmiennej path ustawiamy ścieżkę do katalogu, w którym znajduje się zainstalowane przez nas JDK, czyli Java Development Kit. Jest to zestaw programów, które programiści Java potrzebują do kompilowania i uruchamiania napisanych przez siebie aplikacji. Jeżeli ustawisz w path ścieżkę do swojej instalacji JDK, to z linii poleceń będziesz mógł m. in. kompilować programy Java za pomocą aplikacji o nazwie javac (kompilator Java) oraz uruchamiać skompilowane programy za pomocą programu java (Maszyna Wirtualna Java).

Aby sprawdzić w linii poleceń, jakie zmienne systemowe są ustawione i jakie wartości mają przypisane, możesz wywołać komendę set bez żadnych argumentów:

Powyżej zaprezentowałem tylko kilka ze zmiennych systemowych, jakie wyświetla komenda set.

Aby wyświetlić wartość jednej konkretnej zmiennej, skorzystaj z komendy echo, której przekażesz nazwę zmiennej otoczoną znakami procenta %:

Zmiana wartości zmiennej systemowej¶

Jeżeli chcesz zmienić wartość zmiennej systemowej, masz dwie opcje.

Ustawianie wartości zmiennej w linii poleceń¶

Możesz użyć komendy set, by zmienić wartość zmiennej tylko na rzecz aktualnie uruchomionej linii poleceń – zmiana ta nie będzie widoczna w innych otwartych oknach linii poleceń, a gdy zamkniesz okno linii poleceń, w którym dokonałeś zmiany, nie będzie ona nigdzie zapamiętana. Ustawianie wartości zmiennej systemowej widzieliśmy w jednym z poprzednich rozdziałów przy okazji omawianiu komendy set:

Powyżej ustawiamy wartość zmiennej path – nowa wartość to złączenie aktualnej wartości tej zmiennej z nowym wpisem: D:\programowanie\app\gradle\bin. Aktualną wartość zmiennej pobieramy za pomocą składni %nazwa_zmiennej%.

Globalne ustawienie wartości zmiennej¶

Możesz na stałe, globalnie zmienić wartość zmiennej systemowej jeżeli w Panelu Sterowania klikniesz na System, następnie na Zaawansowane ustawienia systemu po lewej stronie, i wreszcie klikniesz przycisk Zmienne środowiskowe... w oknie, które się pojawi. Znajdziesz tam listę zmiennych systemowych i ich wartości, a także będziesz mógł je edytować bądź dodać nowe.

Panel sterowania możesz otworzyć klikając na lupę na pasku dolnym, obok znaku Windows, i wpisując Panel sterowania. Możesz też po prostu wpisać Zmienne, by od razu przejść do edycji zmiennych systemowych:

Zazwyczaj będziesz korzystać właśnie z tej globalnej zmiany wartości zmiennych systemowych. Jest tylko jedna rzecz, o której musisz pamiętać: globalne zmiany wartości zmiennych systemowych nie są widoczne w aktualnie otwartych oknach linii poleceń – musisz otworzyć nowe okno linii poleceń, aby widzieć zmianę.

Dla przykładu, załóżmy, że otwieram linię poleceń i chcę korzystać w niej z programu o nazwie gradle, ale ścieżki do tego programu nie ma w zmiennej systemowej path. Otwieram więc okno edycji zmiennych systemowych i dopisuję do zmiennej path ścieżkę:

D:\programowanie\app\gradle\bin

Wracam do linii poleceń i nadal nie mogę korzystać z programu o nazwie gradle – muszę zamknąć okno linii poleceń i ponownie je otworzyć, by zmiana wprowadzona globalnie do zmiennej systemowej path była widziana w linii poleceń.

Standardowe wejście i wyjście (standard in / standard out)¶

Niektóre komendy, z których korzystamy z linii poleceń, oczekują pewnych argumentów, na podstawie których wykonują swoje zadanie, lub w trakcie działania proszą nas o podanie pewnych danych. Czasem komendy te zamiast działać na argumentach lub czekać na dane od użytkownika, mogą wczytać dane ze standardowego wejścia, a zmiast wypisać wynik działania na ekran, mogą wysłać go na standardowe wyjście.

Standardowe wejście¶

Standardowe wejście to źródło pewnych danych, na których komenda ma zadziałać.

Poznana wcześniej komenda more służy do przeglądania danych strona po stronie w linii poleceń. Zamiast przekazywać tej komendzie nazwę pliku jako argument, możemy przekazać jej dane ze standardowego wejścia:

Zawartość pliku LiczbaZnakowWPliku.java została przekazana nie jako nazwa pliku, lecz za pomocą mechanizmu standardowego wejścia do komendy more za pomocą znaku mniejszości <.

Czym różni się taki sposób przekazywania danych od podania argumentu? Dzięki standardowemu wejściu możemy do komendy przekierowywać dane z innej komendy. Przekierowanie metod jest tematem kolejnego rozdziału.

Ponadto, komendy, które oczekują od użytkownika wprowadzenia danych w oknie linii poleceń, mogą automatycznie odczytać je ze standardowego wejścia. Spójrz na poniższy program napisany w języku Java – prosi on użytkownika o podanie imienia i wypisuje powitanie. Imię odczytywane jest ze standardowego wejścia w metodzie getString:

import java.util.Scanner;

public class Powitanie {
  public static void main(String[] args) {
    System.out.println("Podaj imie: ");
    String imie = getString();

    System.out.println("Witaj " + imie);
  }

  public static String getString() {
    return new Scanner(System.in).next();
  }
}

Jeżeli uruchomimy powyższy program nie podając źródła standardowego wejścia, to domyślnie będzie nim okno konsoli – program poprosi nas o podanie imienia, a my będzie mogli je wpisać, bezpośrednio w oknie konsoli, zatwierdzając Enterem:

Tekst Przemek został wpisany przeze mnie – program czekał, aż podam pewną wartość.

Ponownie uruchomimy powyższy program, lecz tym razem wskażemy plik, którego zawartość ma być źródłem standardowego wejścia. Utworzyłem plik dane.txt z jednym słowem:

Abrakadabra

Ponowne uruchomienie programu Powitanie:

Zauważ, że tym razem program nie czekał na podanie przeze mnie imienia. Zamiast tego, zostało ono odczytane ze standardowego wejścia, którym, w tym przypadku, była treść pliku dane.txt.

Ważną cechą działania na standardowym wejściu jest to, że dajemy użytkownikom naszych programów możliwość działania w dwóch trybach: interaktywnym, w którym podajemy na bieżąco wartości, których program wymaga do działania, oraz w trybie, gdzie program sam odczytuje wymagane przez niego dane, które przekazaliśmy mu przekierowując źródło standardowego wejścia.

Standardowe wyjście¶

Standardowe wyjście to "miejsce", gdzie wynik działania komendy ma zostać przekazany.

Standardowe wyjście często przydaje się, gdy chcemy zapisać do pliku wynik działania komendy, której wywołanie skutkowałoby wypisaniem na ekran dużej ilości danych. Możemy zamiast tego przekierować wynik do pliku – wszystko, co komenda wypisałaby na ekran, zamiast tego zostanie zapisane w podanym przez nas pliku. Dzięki temu możemy później przeanalizować takie dane lub porównać je z wynikami wywołania kolejnej komendy. Spójrz na poniższy przykład:

Komenda dir wypisuje zawartość plików i katalogów w aktualnym katalogu. Zazwyczaj produkuje ona sporo danych – ale tym razem nic nie zostało wypisane na ekran. Zamiast tego, skorzystaliśmy z przekierowania wyniku komendy do pliku za pomocą znaku większości >, po którym nastąpiła nazwa pliku. Po wykonaniu tej komendy, na moim pulpicie pojawił się plik lista_plikow.txt o następującej treści:

Gdybym nie skorzystał z przekierowania standardowego wyjścia, to powyższą treść pliku zobaczyłbym na ekranie linii poleceń.

Przekierowanie wykonania komend (pipe) oraz łączenie komend (command chaining)¶

Zamiast wypisywać na ekran wynik działania komendy, możemy przekazać te dane jako standardowe wejście do innej komendy. Innymi słowy, wynik działania pewnej komendy stanie się wejściem kolejnej komendy. Takie łączenie komend wykonujemy za pomocą znaku | (pipe).

Móglibyśmy na przykład wynik komendy tree przekierować do komendy more, dzięki czemu będziemy mogli przeglądać strukturę katalogów strona po stronie:

Możemy także wynik pewnej komendy w łatwy sposób wstawić do schowka, abyśmy mogli go potem wkleić do dowolnego edytora za pomocą skrótu Ctrl + v:

Po wywołaniu powyższej komendy, gdy otworzę np. Notepad++, po użyciu skrótu Ctrl + v do edytora wklejony zostanie wynik, która normalnie komenda dir wypisałaby na ekran.

Jeżeli masz potrzebę, możesz wielokrotnie przekierować wynik kolejnych komend:

Powyżej listujemy wszystkie pliki i podkatalogi, następnie sortujemy ich nazwy za pomocą komendy sort, a na końcu przekazujemy je do komendy more, by przeglądać wyniki strona po stronie.

Łączenie komend (command chaining)¶

Poza przekierowaniem wyniku komend, możemy także zlecić wykonanie kilku komend jedna po drugiej, rozdzielając je pojedynczym lub podwójnym znakiem & (ampersand).

Jeżeli użyjemy pojedynczego znaku, kolejne komendy zostaną wykonane niezależnie od tego, czy poprzedzająca je komenda zakończyłą się sukcesem:

Zauważ powyżej, że pierwsza z komend to cd xyz. Katalog xyz nie istnieje, więc wynik pierwszej komendy, zaznaczony powyżej, to System nie może odnaleźć określonej ścieżki. Kolejna komenda, dir, została wykonana pomimo, że pierwsza nie zakończyła się sukcesem.

W przypadku podwójnego znaku &, następna komenda wykonana zostanie tylko wtedy, gdy poprzedzająca ją komenda zakończy się sukcesem:

Łączenie komend przydaje się w sytuacjach, gdy chcesz wykonać kilka komend bez potrzeby uruchamiania każdej z nich z osobna, jedna po drugiej.

Kopiowanie i wklejanie z/do linii poleceń¶

Aby kopiowanie i wklejanie opisane poniżej za pomocą skrótów klawiaturowych Ctrl + c i Ctrl + v było możliwe, upewnij się, że w Twojej linii poleceń została włączona ta funkcjonalność. Po kliknięciu prawym przyciskiem myszy na tytuł okna linii poleceń, wybierz Właściwości. Zaznacz pole Włącz skróty klawiaturowe z klawiszem Ctrl i kliknij przycisk OK:

Kopiowanie¶

Czasem możemy mieć potrzebę skopiować zawartość linii poleceń lub wynik wywołania komendy. Mamy kilka sposobów, aby to osiągnąć.

Komenda clip¶

Możemy skorzystać z poznanej komendy clip, która kopiuje do schowka dane ze swojego standardowego wejścia, które możemy przekazać do niej z innej komendy za pomocą przekierowania znakiem | (pipe) – spójrzmy na przykład:

Komenda tree zamiast wypisać swój wynik na ekran, przekazała go do komendy clip za pomocą znaku przekierowania |. Komenda clip otrzymane dane umieściła w schowku – mógłbym teraz te dane wkleić do dowolnego edytora tekstu za pomocą skrótu Ctrl + v.

Zapis wyniku komendy do pliku¶

Jeżeli w wyniku działania komendy na ekranie pojawia się dużo danych, możemy po prostu zapisać je do pliku za pomocą przekierowania standardowego wyjścia, korzystając ze znaku >. Przykład:

Wynik działania komendy dir został zapisany do pliku lista_plikow_i_katalogow.txt, zamiast być wyświetlony na ekranie. Plik ten nie musiał wcześniej istnieć – zostanie dla nas utworzony. Możemy otworzyć go w dowolnym edytorze i sprawdzić zapisane tam dane.

Skróty klawiaturowe¶

Innym sposobem na skopiowanie fragmentu treści okna linii poleceń jest zaznaczanie go kursorem myszy, a następnie użycie skrótu Ctrl + c lub, po prostu, naciśnięcie klawisza Enter:

Gdy zaznaczysz pewny obszar tekstu w linii poleceń, jego kolor i tło zmieni się, jak widać to na powyższym listingu – zaznaczyłem fragment wyniku komendy dir /b. Jeżeli teraz użyję skrótu Ctrl + c lub nacisnę Enter, to zaznaczenie zniknie (fragment powróci do poprzedniego koloru), a w schowku znajdzie się zaznaczony przeze mnie wcześniej tekst i będę go mógł wkleić do edytora tekstu za pomocą skrótu Ctrl + v.

Wklejanie¶

Aby wkleić zawartość schowka do okna linii poleceń, możesz skorzystać ze skrótu Shift + Insert lub Ctrl + v.

Miej jednak na uwadze, że wklejanie tekstu, który zawiera kilka oddzielonych od siebie linii tekstu, spowoduje, że te linie zostaną potraktowane jako komendy do wykonania – zazwyczaj nie jest to zamierzone działanie. Upewnij się, że kopiujesz jedną linię tekstu, którą chcesz następnie wkleić do okna linii poleceń.

Przydatne skróty i konfiguracja linii poleceń¶

W tym rozdziale przedstawię przydatne skróty klawiaturowe oraz informacje o konfigurowaniu okna linii poleceń.

Skróty klawiaturowe w linii poleceń¶

Korzystając z linii poleceń mamy do dyspozycji kilka bardzo przydatnych skrótów klawiaturowych.

Ostatnio używane komendy¶

Prawdopodobnie najważniejszymi i najczęściej używanymi skrótami klawiaturowymi użytkowników linii poleceń są strzałka w górę ↑ oraz strzałka w dół ↓.

Jeżeli wywołasz kilka komend w linii poleceń, to możesz później za pomocą strzałki w górę ↑ przejść po kolei przez używane wcześniej komendy – zostaną ona automatycznie umieszczone w linii poleceń i będziesz mógł wywołać je ponownie lub zmodyfikować. Strzałka w górę ↑ powoduje przejście do poprzedniej komendy, a strzałka w dół do następnej ↓.

Sprawdź działanie tych skrótów w praktyce. Wywołaj kilka komend w linii poleceń, a potem użyj strzałek, aby zobaczyć te bardzo przydatne skróty w akcji.

Historia komend¶

Innym sposobem, aby odnieść się do ostatnio używanych komend, jest skorzystanie z klawisza F7. Spowoduje to otworzenie małego okna z listą ostanio wywoływanych komend:

Możesz strzałkami ↑ ↓ nawigować pomiędzy komendami, a po naciśnięciu Entera komenda zostanie wybrana i wykonana. Jeżeli nie chcesz wywołać żadnej komendy z listy, naciśnij klawisz Escape.

Dopełnianie nazw plików i katalogów¶

Innym bardzo często stosowanym skrótem jest Tab. Jego użycie powoduje dopełnienie wpisywanej przez nas nazwy pliku bądź katalogu. Dzięki temu nie musimy wpisywać pełnej nazwy – wystarczy wpisać kilka pierwszych liter, a następnie nacisnąć klawisz Tab – nazwa zostanie dopełniane za nas automatycznie.

Jeżeli w katalogu jest kilka plików bądź katalogów o tej samej nazwie, możesz użyć klawisza Tab ponownie, aby przejść przez dostępne pliki, aż wyświetli się ten szukany przez Ciebie. Wypróbuj ten skrót w linii poleceń, aby zobaczyć, jak funkcjonuje.

Pełny ekran¶

Jeżeli chcesz szybko zmienić rozmiar okna linii poleceń na pełny ekran, to skorzystaj ze skrótu Alt + Enter. Tym samym skrótem powodujesz powrót okna do poprzedniej wielkości.

Anulowanie wpisywania komendy¶

Jeżeli wpisujesz komendę i postanowisz, że nie chcesz jej wywołać lub chcesz wpisać inną komendę, możesz albo nacisnąć Escape, aby skasować treść wpisywanej komendy, albo Ctrl + c, aby anulować kontynuację wpisywania komendy.

Przerywanie komendy¶

Aby przerwać komendę, która aktualnie się wykonuje, skorzystaj ze skrótu Ctrl + c. Jeżeli to nie pomoże, użyj skrótu Ctrl + d.

Konfigurowanie okna linii poleceń¶

Okno linii poleceń możesz skonfigurować na wiele sposóbów otwierając okno Właściwości. Kliknij prawym przyciskiem myszy na tytuł okna linii poleceń i wybierz Właściwości.

Możesz przejrzeć dostępne tam zakładki i poeksperymentować z różnymi ustawieniami.

Wygląd linii poleceń¶

Przydatna może być zmiana rodzaju, wielkości, oraz koloru czcionki, a także kolor tła okna linii poleceń w zakładkach Czcionka i Kolory. Możesz dostosować wygląd okna, aby był najczytelniejszy dla Ciebie. Zmiany kolorów widoczne są dopiero po otwarciu nowego okna.

Rozmiar okna¶

Możesz zmienić na stałe rozmiar okna linii poleceń w zakładce Układ. Możesz także ustawić stałe miejsce, gdzie okno linii poleceń ma się pokazywać na ekranie, gdy je uruchamiasz, wypełniając w zakładce Układ wartości pól Pozycja okna (wcześniej jednak musisz odznaczyć pole Wybór pozycji okna przez system).

Przezroczyste tło okna linii poleceń¶

Okno lini poleceń może mieć ustawiony poziom nieprzezroczystości. Przydaje się to, jeżeli mamy czasem otwarte pod oknem linii poleceń inne okna, w których znajduje się coś, co może się nam przydać podczas pracy z linią poleceń.

Domyślnie wartość ta wynosi 100%, więc okno jest całkowicie nieprzezroczyste. Ja ustawiłem tę wartość na 85%, dzięki czemu jestem w stanie widzieć inne okna znajdujące się pod spodem linii poleceń.

Aby zmienić poziom nieprzezroczystości, otwórz okno z Właściwościami i przejdź do zakładki Kolory – na dole okna znajdziesz suwak, którym możesz ustawić tę wartość:

Przykład okna linii poleceń z nieprzezroczystością ustawioną na 85%:

Proste skrypty .cmd¶

Poza wywoływaniem komend pojedynczo, możemy także tworzyć skrypty korzystające z komend.

Skrypty mogą wykonywać dowolne zadania, zależnie od naszych potrzeb. Możemy nawet korzystać w nich z instrukcji warunkowych, pętli, oraz funkcji. Skrypty mogą przyjmować argumenty, na podstawie których będą wykonywały swoje zadanie.

Skrypty zapisujemy jako pliki tekstowe z rozszerzeniem .cmd. Możemy pisać je w dowolnym edytorze tekstowym, takim jak Notepad++. Takie skrypty uruchamia się albo poprzez dwukrotne kliknięcie pliku, w którym są zawarte, albo poprzez linię poleceń wpisując po prostu ich nazwę i zatwierdzając Enterem – musimy jednak być w katalogu, w którym plik ze skryptem się znajduje. Ewentualnie możemy ścieżkę do katalogu ze skryptem dodać do zmiennej systemowej path, aby móc z niego korzystać z dowolnego katalogu.

Gdy w skrypcie wykonujesz pewne komendy, to są one wypisywane na ekran – czasem zależy nam tylko na wyniku komendy i chcemy ukryć samo jej wywołanie. Aby to osiągnąć, korzystamy z instrukcji @echo off.

W skryptach możemy umieszczać komentarze – są to linie, które zaczynają się od dwóch dwukropków :: lub słowa REM.

Jeżeli skrypt wykonuje pewne zadanie i nie czeka na żadne dane od użytkownika, to okno linii poleceń od razu zniknie po zakończeniu działania skryptu (jeżeli skrypt został uruchomiony przez dwukrotne kliknięcie pliku). Możemy w takim skrypcie dodać instrukcję pause, która spowoduje, że skrypt będzie czekał na naciśnięcie dowolnego klawisz, zanim zakończy działanie.

Poniżej znajduje się przykład prostego skryptu, którego używam do sprawdzenia, czy w którymś z moich repozytoriów Gita nie ma plików, których jeszcze nie zacommittowałem:

@echo off

cd /d D:\programowanie\projekty\javacourse
echo -------------------------
echo Kurs Java
echo -------------------------
git status -s
echo:

cd D:\programowanie\projekty\kurs_maven
echo -------------------------
echo Kurs Maven
echo -------------------------
git status -s
echo:

cd D:\programowanie\projekty\my-docs
echo -------------------------
echo Moje dokumenty
echo -------------------------
git status -s
echo:

pause

Na początku skryptu wyłączam wyświetlanie na ekranie wywoływanych komend za pomocą @echo off – interesuje mnie tylko wynik ich działania. Następnie, przechodzę do katalogu z repozytorium za pomocą komendy cd. W kolejnych liniach korzystam z komendy echo, aby wyświetlić informację tekstową o repozytorium, które jest aktualnie sprawdzane. Komenda git status -s to odpytanie Gita o status repozytorium – czy są w nim aktualnie jakieś niezacommittowane pliki. Po komendzie git używam komendy echo:, aby wypisać pustą linię. W kolejnych liniach robię to samo dla innych repozytoriów. Na końcu skryptu dodałem instrukcję pause, dzięki czemu po uruchomieniu skryptu, gdy wykona on swoje zadanie, poczeka, aż nacisnę dowolny klawisz, dzięki czemu będę mógł przeanalizować dane wyświetlone przez Gita.

Przykładowy wynik działania tego skryptu jest następujący:

Kurs Java
-------------------------
 M "artykuly/podstawy_linii_polecen/Podstawy linii polecen.odt"
?? artykuly/podstawy_linii_polecen/img/linia_polecen_przezroczystosc.png
?? artykuly/podstawy_linii_polecen/img/ustawianie_nieprzezroczystosci.png

-------------------------
Kurs Maven
-------------------------

-------------------------
Moje dokumenty
-------------------------

Press any key to continue . . .