Linux. Programowanie w powłoce. Praktyczny przewodnik [3rd ed.] 9788324675722 [PDF]

Zitiervorschau

Tytuł oryginału: A Practical Guide to Linux Commands, Editors, and Shell Programming (3rd Edition) Tłumaczenie: Robert Górczyński z wykorzystaniem fragmentów książki „Fedora i Red Hat Enterprise Linux. Praktyczny przewodnik. Wydanie VI” w tłumaczeniu Grzegorza Kowalczyka, Grzegorza Kostka, Lecha Lachowskiego i Adama Bąka ISBN: 978-83-246-7572-2 Authorized translation from the English language edition, entitled: A PRACTICAL GUIDE TO LINUX COMMANDS, EDITORS, AND SHELL PROGRAMMING, Third Edition; ISBN 013308504X; by Mark G. Sobell; published by Pearson Education, Inc; publishing as Prentice Hall. Copyright © 2013 Mark G. Sobell. All rights reserved. No part of this book may be reproduced od transmitted in any form or by any means, electronic or mechanical, including photocopying, recording or by any information storage retrieval system, without permission from Pearson Education, Inc. Polish language edition published by HELION S.A., Copyright © 2013. Wszelkie prawa zastrzeżone. Nieautoryzowane rozpowszechnianie całości lub fragmentu niniejszej publikacji w jakiejkolwiek postaci jest zabronione. Wykonywanie kopii metodą kserograficzną, fotograficzną, a także kopiowanie książki na nośniku filmowym, magnetycznym lub innym powoduje naruszenie praw autorskich niniejszej publikacji. Wszystkie znaki występujące w tekście są zastrzeżonymi znakami firmowymi bądź towarowymi ich właścicieli. Autor oraz Wydawnictwo HELION dołożyli wszelkich starań, by zawarte w tej książce informacje były kompletne i rzetelne. Nie biorą jednak żadnej odpowiedzialności ani za ich wykorzystanie, ani za związane z tym ewentualne naruszenie praw patentowych lub autorskich. Autor oraz Wydawnictwo HELION nie ponoszą również żadnej odpowiedzialności za ewentualne szkody wynikłe z wykorzystania informacji zawartych w książce. Wydawnictwo HELION ul. Kościuszki 1c, 44-100 GLIWICE tel. 32 231 22 19, 32 230 98 63 e-mail: [email protected] WWW: http://helion.pl (księgarnia internetowa, katalog książek) Drogi Czytelniku! Jeżeli chcesz ocenić tę książkę, zajrzyj pod adres http://helion.pl/user/opinie/lippp3_ebook Możesz tam wpisać swoje uwagi, spostrzeżenia, recenzję. Pliki z przykładami omawianymi w książce można znaleźć pod adresem: ftp://ftp.helion.pl/przyklady/lippp3.zip

Printed in Poland.   

Poleć książkę na Facebook.com Kup w wersji papierowej Oceń książkę

 

Księgarnia internetowa Lubię to! » Nasza społeczność

OPINIE O POPRZEDNICH WYDANIACH KSIĄŻKI LINUX. PROGRAMOWANIE W POWŁOCE. PRAKTYCZNY PRZEWODNIK „Ta książka jest znakomitym wyborem dla każdego, kto chce »zajrzeć pod maskę« systemu Linux i zacząć z niego efektywnie korzystać w codziennej pracy. Jedną z najbardziej frustrujących cech systemowego podręcznika man jest brak jakichkolwiek przykładów. Książka Marka Sobella jest tego całkowitym przeciwieństwem; doskonale opisuje przeznaczenie danego polecenia i natychmiast podpiera ten opis kilkoma prostymi, łatwymi do zrozumienia przykładami praktycznymi, dzięki którym samodzielne rozpoczęcie tworzenia skryptów powłoki wydaje się być zadaniem wręcz trywialnym. Tak jak w przypadku innych książek Sobella, również i ta jest prosta, przejrzysta i przyjemna w odbiorze. To naprawdę świetna książka i z pewnością pozostanie na mojej półce w zasięgu ręki przez długi czas”. — Ray Bartlett autor książek podróżniczych „Muszę przyznać, że ta książka jest naprawdę znakomita i zasłużyła na jedno z najbardziej eksponowanych miejsc na mojej półce. Książka omawia prawdziwe »wnętrze« systemu Linux — wiersz poleceń i jego narzędzia — i robi to naprawdę znakomicie. Jej najsilniejszą stroną jest ogromna liczba praktycznych przykładów oraz zestawienie poleceń i narzędzi powłoki. Tę książkę można śmiało polecić każdemu użytkownikowi systemu Linux, niezależnie od jego doświadczenia. Mark Sobell i wydawnictwo Prentice Hall zrobili naprawdę dobrą robotę!”. — Dan Clough inżynier elektronik i użytkownik Slackware Linux „Zupełnie niepodobnie do innych książek o systemie Linux ta książka niemal całkowicie pomija omawianie graficznego systemu użytkownika i przechodzi od razu do konkretów, pokazując potęgę wiersza poleceń i oddając ją w Twoje ręce”. — Bjorn Tipling inżynier oprogramowania ask.com „Ta książka jest najlepszym kompendium wiedzy o systemie Linux spośród dziesiątek książek o systemie Linux, jakie zdarzyło mi się przeczytać. Kupienie tej książki było prawdziwym uśmiechem losu. Jeżeli naprawdę chcesz się dowiedzieć, jak działa powłoka systemu z wierszem poleceń, gdzie drzemie prawdziwa potęga systemów klasy UNIX/Linux, to ta książka jest jednym z najlepszych źródeł informacji, jakie możesz znaleźć”. — Chad Perrin pisarz, TechRepublic „Kilka lat temu przeszedłem z systemu Windows XP na Linux, a po wypróbowaniu kilku różnych dystrybucji zdecydowałem się wreszcie na dystrybucję Linux Mint. Obawiałem się, że taka zmiana w wieku 69 lat będzie trudnym doświadczeniem, ale dzięki lekturze wielu materiałów i pomocy lokalnej grupy użytkowników systemu Linux swobodnie posługuję się graficznym interfejsem użytkownika w systemie Linux. Zapragnąłem więc poznać powłokę w systemie Linux i kilka miesięcy temu kupiłem książkę Linux. Programowanie w powłoce. Praktyczny przewodnik. Dzięki twojej książce poznałem podstawy używania powłoki w systemie Linux. Jako względnie początkujący użytkownik w świecie systemu Linux przekonałem się, że twoja książka to doskonały i łatwy w lekturze przewodnik, który bez wątpliwości polecam innym użytkownikom”. — John Nawell CQLUG (Central Queensland Linux User Group)

„Mam drugie wydanie książki Linux. Programowanie w powłoce. Praktyczny przewodnik i jestem jej ogromnym fanem. Korzystałem z niej podczas pracy jako inżynier w dziale pomocy Cisco. Jeśli tylko pojawi się wydanie trzecie książki, natychmiast je kupię. W pracy intensywnie korzystam z powłoki i obsługuję dosłownie 1000 komputerów (IMS). Dzięki drugiemu wydaniu książki poznałem wiele narzędzi. Chciałbym, aby nowe wydanie książki pojawiło się najszybciej, na ile to możliwe. Styl twoich książek doskonale pasuje do mojego stylu uczenia się”. — Robert Lingenfelter inżynier działu pomocy, VoIP/IMS

OPINIE O INNYCH KSIĄŻKACH MARKA SOBELLA „Ponieważ pracuję w środowisku dydaktycznym, mogę powiedzieć, że książka p. Sobella to dokładnie to, czego mi było potrzeba, i jest wielką pomocą dla każdego, kto zarządza systemami Linux w środowiskach biznesowych i edukacyjnych. Jego styl pisania jest bardzo przejrzysty. W każdym rozdziale aż do końcowych ćwiczeń przedstawia konkretne rozwiązania, które według mnie są bardzo zbliżone do rzeczywistych problemów, z jakimi na co dzień boryka się każdy użytkownik i administrator systemu. Dla każdego studenta informatyki ta książka z pewnością będzie znakomitym kompendium wiedzy i uzupełnieniem materiału ze studiów. Ilość podawanych w książce informacji jest doskonale wyważona i autor przedstawia poszczególne tematy bez zbędnego dryfowania w stronę niepotrzebnych komentarzy, dygresji i opisów. Ta książka to obowiązkowa pozycja dla każdego, kto zarządza systemami Linux w środowisku sieciowym, oraz każdego, kto zarządza serwerami linuksowymi. Szczerze mogę polecić tę książkę również tym wszystkim, którzy mają zamiar »przesiąść« się z używanego dotychczas systemu operacyjnego na system Linux”. — Mary Norbury dyrektor IT Barbara Davis Center University of Colorado, Denver Z recenzji zamieszczonej na portalu slashdot.org „Miałem okazję korzystać z Twoich książek o systemie UNIX wiele lat temu, kiedy byłem studentem w Cal Poly w San Luis Obispo (Kalifornia). Muszę powiedzieć, że Twojej książki są wśród najlepszych! To naprawdę znakomite książki, które omawiają wiele teoretycznych i praktycznych zagadnień związanych z systemem operacyjnym”. — Benton Chan inżynier IS „Książka znacznie przekroczyła moje i tak wygórowane oczekiwania, których nabrałem po przeczytaniu wielu jej recenzji. Twoja książka posiada pewną bardzo rzadko spotykaną cechę — tej książki nie czyta się jak książki technicznej; zamiast tego można ją »pochłaniać« jak dobrą opowieść! Naprawdę przyjemnie się ją czyta i ciężko ją odłożyć na półkę. Czy ja to naprawdę powiedziałem?! :-)”. — David Hopkins projektant procesów biznesowych „Dziękuję za Twoją ciężką pracę i za książkę, która jest jej efektem. Książek, które naprawdę pomagają użytkownikom stać się lepszymi, bardziej wydajnymi administratorami, jest naprawdę niewiele. Mamy nadzieję (tutaj w Rosji), że w kolejnych wydaniach nadal będziesz pomagał nam lepiej zrozumieć funkcjonowanie systemów Linux/UNIX”. — Anton Petukhov „Mark Sobell napisał książkę, która jest zarówno bardzo przejrzysta, jak i bardzo kompletna pod względem merytorycznym”. — Jeffrey Bianchine adwokat, pisarz, dziennikarz

„Znakomite kompendium wiedzy, doskonale napisana i przydatna zarówno dla administratora systemu Linux, jak i użytkownika komputera PC planującego zainstalować najnowszą, stabilną dystrybucję systemu Linux. Nie daj się wystraszyć ogromnym rozmiarom tej książki. Autor po prostu starał się umieścić w niej jak najwięcej informacji na temat zagadnień, z którymi możesz spotkać się jako administrator systemu”. — Wes Boudville projektant „Linux. Programowanie w powłoce. Praktyczny przewodnik. Wydanie III to naprawdę wspaniała książka. Dziękuję!”. — C. Pozrikidis University of California, San Diego „Ta książka zawiera najlepszy przegląd zagadnień związanych z systemem Linux, jaki udało mi się do tej pory znaleźć… Książka jest bardzo pomocna i łatwa do przyswojenia dla każdego, niezależnie od tego, czy jest to użytkownik tradycyjnego systemu UNIX, nowy, zagorzały wielbiciel systemu Linux czy nawet użytkownik systemu Windows. Każdy temat jest omawiany w prosty, przejrzysty i kompletny sposób, a wyjaśniając poszczególne zagadnienia, autor nie zakłada, że użytkownik już o tym wie. Ta książka znakomicie sprawdza się jako kompendium wiedzy o systemie Linux, zwłaszcza dzięki rozbudowanemu, 70-stronicowemu słownikowi i jest bardzo dobrze poindeksowana. Jej dobrze zaprojektowany układ powoduje, że użytkownik może się skoncentrować na prostych zadaniach, bez konieczności brnięcia w trudne zagadnienia dopóty, dopóki nie jest na to gotowy”. — Cam Marshall Marshall Information Service LLC członek Front Range UNIX Users Group [FRUUG] Boulder, Colorado „Ogólnie rzecz biorąc, to jest właśnie TA książka, którą powinieneś kupić, jeżeli jesteś nowym użytkownikiem systemu Linux i dopiero wchodzisz w świat systemów Fedora/RHEL. Żadna inna książka nie omawia z taką łatwością tak dużej ilości różnorodnych zagadnień”. — Eugenia Loli-Queru redaktor naczelny OSNews.com „Jestem szczęśliwym posiadaczem jednej z Pańskich książek, Linux. Programowanie w powłoce. Praktyczny przewodnik. Wydanie III. Myślę, że jest to jeden z najbardziej kompletnych, i jak tytuł wskazuje, najbardziej praktycznych podręczników systemu Linux, jakie kiedykolwiek czytałem. W sprawach systemów operacyjnych uważam się za nowicjusza i niemal na okrągło sięgam do tej książki, chcąc wykonać takie czy inne zadanie”. — Albert J. Nguyen „Dziękuję za napisanie książki, która pomogła mi uciec od systemu Windows XP i nigdy nawet nie dotknąć systemu Windows Vista. Książka jest naprawdę wspaniała; codziennie znajduję w niej nowe idee i ciekawe polecenia. System Linux zaczyna się naprawdę robić coraz bardziej przyjazny dla użytkownika”. — James Moritz „Jestem naprawdę pod wrażeniem sposobu, w jaki Mark Sobell potrafi omawiać tak rozbudowane i złożone zagadnienia w tak prosty i zrozumiały sposób. Jego przykłady praktycznego zastosowania poszczególnych poleceń są bardzo przydatne zarówno dla początkującego, jak i nawet zaawansowanego administratora systemu, stanowiąc gotowy zestaw przepisów na wykonanie codziennych zadań w systemie Linux. Mark to naprawdę obdarzony talentem autor książek technicznych!”. — George Vish II starszy konsultant Hewlett-Packard Company „Ogólnie rzecz biorąc, to naprawdę dobra, kompletna książka o systemie Linux, która będzie znakomitym źródłem wiedzy dla użytkowników na każdym poziomie zaawansowania”. — John Dong członek Ubuntu Forum Council szef zespołu Backports

„Sekcje szybkiego startu naprawdę pozwalają na szybkie zainstalowanie i uruchomienie serwera, pozwalając na delektowanie się szczegółami książki nieco później”. — Scott Mann Aztek Networks „Naprawdę bardzo bym chciał używać takich książek jako podręczników do nauki nie tylko o systemie Linux, ale ogólnie o komputerach i sprawach z nimi związanych. Książka jest kompletna i doskonale napisana, z dobrymi przykładami znakomicie ilustrującymi najważniejsze zagadnienia związane z zastosowaniem komputerów”. — Nathan Eckenrode New York Local Community Team „System Ubuntu nabiera popularności z taką samą szybkością, z jaką nabierał jej przemyt alkoholu w czasie wielkiej prohibicji, stąd to naprawdę miłe dowiedzieć się, że dobrze znany autor napisał książkę o najnowszej i najlepszej wersji tego systemu. Książka zawiera nie tylko zagadnienia związane z systemem Ubuntu, ale również porusza wiele tematów związanych z ogólnym zastosowaniem komputerów, co z pewnością bardzo pomoże przeciętnemu użytkownikowi lepiej zrozumieć, co tak naprawdę dzieje się w jego komputerze. Dobra robota, Mark!”. — Daniel R. Arfsten projektant, Pro/ENGINEER „Codziennie przeglądam duże ilości technicznych informacji o systemie Linux i naprawdę rzadko książki techniczne są w stanie wywrzeć na mnie jakieś wrażenie; zazwyczaj wolę korzystać z dokumentacji online. Książki Marka Sobella są tutaj chlubnym wyjątkiem. Są bardzo przejrzyście napisane, technicznie dokładne, kompletne i podczas czytania sprawiają naprawdę niezłą frajdę”. — Matthew Miller starszy analityk, administrator BU Linux Project Boston University Office of Information Technology „Jest to dobrze napisane, przejrzyste i kompletne źródło informacji dla każdego użytkownika systemu Linux, niezależnie od tego, czy używa systemu Linux po raz pierwszy i chce go lepiej poznać, czy też korzysta z tej książki jako kompendium wiedzy przy realizacji jakiegoś złożonego zadania, jak na przykład instalacja i konfiguracja serwera. Rzeczywista wartość tej książki daleko przerasta koszt jej zakupu i naprawdę będzie ona znakomitym uzupełnieniem książek o systemie Linux na Twojej półce”. — Linc Fessenden gospodarz LinuxLink TechShow tllts.org „Autor wykonał kawał dobrej roboty, szczegółowo opisując zagadnienia związane z funkcjonowaniem tego systemu operacyjnego. Mam bardzo duże doświadczenie w pracy z systemami UNIX i Windows i mogę powiedzieć, że ta książka znakomicie wypełnia luki pomiędzy systemami Linux, Windows i UNIX. Szczerze polecam ją zarówno dla początkujących, jak i doświadczonych użytkowników. Dobra robota!”. — Mark Polczynski konsultant technologii informacyjnych „Twoja książka A Practical Guide to Ubuntu Linux®, Third Edition to doskonale opracowana i napisana pozycja, która dostarcza wielu użytecznych informacji. Zasługujesz na nagrodę dla wyjątkowych talentów, niestety nie nazywam się Pulitzer”. — Harrison Donnelly fizyk

„Kiedy po raz pierwszy rozpoczynałem pracę z systemem jakieś 10 lat temu, wszystko było chyba jednak trochę bardziej skomplikowane niż teraz… Obecnie każdy nowy użytkownik ma do dyspozycji ogromną ilość zasobów i dokumentacji dostępnych w sieci, a dodatkowo, jeżeli jest to nowy użytkownik Ubuntu, to może znaleźć dosłownie wszystko, co będzie mu potrzebne w jednym miejscu — znakomitej książce Marka Sobella, A Practical Guide to Ubuntu Linux®. Jestem pewny, że brzmi to nieco jak hiperbola. Wszystko, czego może potrzebować użytkownik? Oczywiście jest to pewne uproszczenie, ale ta książka, składająca się z blisko 1100 stron, obejmuje tak szeroki wachlarz zagadnień, że naprawdę niewiele pozostaje do dodania. Począwszy od instalacji systemu, poprzez zarządzanie, połączenia sieciowe, bezpieczeństwo, tworzenie skryptów powłoki, zarządzanie pakietami i na całej masie innych zagadnień skończywszy — to wszystko jest w tej książce. Oczywiście znajdziesz tutaj również opis środowiska graficznego oraz wiersza poleceń. Tutaj naprawdę nie ma wody; zamiast niej znajdziesz po prostu ogromną ilość przydatnych informacji. W książce znalazło się nawet kilka zrzutów ekranów, ale nie zajmują one zbyt wiele miejsca. Ta książka to naprawdę bogate źródło informacji”. — JR Peck redaktor GeekBook.org „Od dawna chciałem »przesiąść się« na system Linux, ale zawsze jakoś brakowało mi odwagi — tak było, dopóki nie zobaczyłem książki o znajomo brzmiącym tytule A Practical Guide to Red Hat® Linux® na półce w księgarni. Natychmiast kupiłem jeden egzemplarz i teraz z niecierpliwością oczekuję na chwilę, kiedy znowu mój komputer odzyska straconą wolność”. — Carmine Stoffo projektant, przemysł farmaceutyczny „Właśnie czytam książkę A Practical Guide to Red Hat® Linux® i wreszcie zaczynam pojmować prawdziwą potęgę wiersza poleceń. Jestem początkującym użytkownikiem systemu Linux i ta książka to dla mnie prawdziwy skarb”. — Juan Gonzalez „Ogólnie rzecz biorąc, A Practical Guide to Ubuntu Linux® Marka Sobella dostarcza wystarczającej ilości informacji dla każdego początkującego i zaawansowanego użytkownika systemu Linux, aby mogli efektywnie korzystać z tego systemu. Dołączenie dysku Live DVD z wydaniem Ubuntu (Gutsy Gibbon) pozwala na wygodne przetestowanie nowego systemu bez konieczności jego instalacji na dysku. Nie mam żadnych wątpliwości, że pieniądze zapłacone za tę książkę są naprawdę bardzo dobrze wydane”. — Ray Lodato Slashdot www.slashdot.org

Dla mojego bratanka Benjamina. Witamy na świecie!

Spis treści

WSTĘP ......................................................................................................................... 29 1.

WITAMY W SYSTEMACH LINUX I OS X ............................................................................... 43 Historia systemów UNIX oraz GNU-Linux ................................................................................... 45 UNIX — protoplasta systemu Linux .............................................................................................................45 Zastój do roku 1983 .........................................................................................................................................45 Kolejna odsłona, rok 1991 ..............................................................................................................................46 Kod źródłowy jest powszechnie dostępny ....................................................................................................47 Baw się dobrze! .................................................................................................................................................48

Dlaczego Linux jest tak wspaniały? .................................................................................................. 48 Dlaczego Linux jest tak popularny wśród firm produkujących urządzenia oraz wśród programistów? ..........................................................................................................................51 Linux jest przenośny ........................................................................................................................................52 Język C ...............................................................................................................................................................52

Przegląd systemu Linux ..................................................................................................................... 53 Linux posiada interfejs pozwalający na programowanie jądra systemu ..................................................54 Linux może obsługiwać wielu użytkowników .............................................................................................54 Linux jest systemem wielozadaniowym .......................................................................................................54 Linux udostępnia bezpieczny, hierarchiczny system plików ....................................................................54 Powłoka — interpreter poleceń i język programowania ............................................................................55 Ogromna kolekcja użytecznych narzędzi .....................................................................................................57 Komunikacja międzyprocesowa ....................................................................................................................57 Zarządzanie systemem ....................................................................................................................................58

Dodatkowe mechanizmy systemu Linux ........................................................................................ 58 Graficzne interfejsy użytkownika ..................................................................................................................58 Narzędzia (między)sieciowe ...........................................................................................................................59 Tworzenie oprogramowania ..........................................................................................................................59

Podsumowanie rozdziału .................................................................................................................. 60 Ćwiczenia ............................................................................................................................................. 60

12  SPIS TREŚCI

I

ROZPOCZYNAMY PRACĘ Z SYSTEMAMI LINUX I OS X ....................61

2.

WPROWADZENIE DO SYSTEMÓW LINUX I OS X .................................................................. 63 Konwencje używane w tej książce .................................................................................................... 64 Logowanie się przy użyciu terminala (emulatora) ......................................................................... 66 Praca z poziomu wiersza poleceń powłoki ..................................................................................... 68 Z której powłoki korzystasz? ..........................................................................................................................69 Poprawianie błędów ........................................................................................................................................69 Powtarzanie i edytowanie poleceń powłoki .................................................................................................71

Polecenia su i sudo: ograniczanie Twojej władzy — uprawnienia superużytkownika root .... 72 Gdzie szukać dokumentacji systemu? ............................................................................................. 73 Polecenie man — wyświetlanie tematów pomocy ......................................................................................73 Polecenie apropos — wyszukiwanie słów kluczowych ..............................................................................75 Polecenie info — wyświetlanie informacji o narzędziach ..........................................................................76 Opcja --help ......................................................................................................................................................78 Polecenie help powłoki bash ..........................................................................................................................79 Uzyskiwanie pomocy .......................................................................................................................................79

Więcej informacji o logowaniu się do systemu oraz o hasłach .................................................... 82 Co zrobić, kiedy nie możesz się zalogować ..................................................................................................82 Logowanie zdalne — emulatory terminala, SSH i połączenia typu dial-up ............................................83 Zastosowanie konsoli wirtualnych ................................................................................................................83 Wylogowanie z systemu ..................................................................................................................................83 Zmiana hasła użytkownika .............................................................................................................................84

Podsumowanie rozdziału .................................................................................................................. 86 Ćwiczenia ............................................................................................................................................. 87 Ćwiczenia zaawansowane .................................................................................................................. 87

3.

NARZĘDZIA SYSTEMU LINUX ............................................................................................ 89 Znaki specjalne .................................................................................................................................... 90 Podstawowe narzędzia systemowe ................................................................................................... 91 Polecenie ls — wyświetlanie nazw plików ....................................................................................................92 Polecenie cat — wyświetlanie zawartości pliku ...........................................................................................92 Polecenie rm — usuwanie pliku ....................................................................................................................92 Polecenia less i more — wyświetlanie tekstu po jednym ekranie .............................................................93 Polecenie hostname — wyświetlanie nazwy systemu .................................................................................93

Praca z plikami .................................................................................................................................... 93 Polecenie cp — kopiowanie plików ...............................................................................................................93 Polecenie mv — zmiana nazwy pliku ...........................................................................................................94 Polecenie lpr — drukowanie pliku ................................................................................................................95 Polecenie grep — wyszukiwanie łańcuchów tekstu ....................................................................................96 Polecenie head — wyświetlanie początkowych wierszy pliku ...................................................................96 Polecenie tail — wyświetlanie wierszy z końca pliku .................................................................................97 Polecenie sort — wyświetlanie zawartości pliku w określonej kolejności ...............................................97 Polecenie uniq — usuwanie powtarzających się wierszy z pliku ..............................................................98 Polecenie diff — porównywanie zawartości dwóch plików ......................................................................98 Polecenie file — rozpoznawanie zawartości pliku ......................................................................................99

Symbol potoku | — komunikacja między procesami .................................................................... 99 Kolejne cztery narzędzia .................................................................................................................. 100 Polecenie echo — wyświetlanie tekstu na ekranie ....................................................................................100 Polecenie date — wyświetlanie bieżącej daty i czasu ................................................................................101

Spis treści  13

Polecenie script — rejestrowanie sesji powłoki .........................................................................................101 Polecenie unix2dos — konwersja plików Linux i OS X do formatu Windows ....................................102

Kompresowanie i archiwizacja plików .......................................................................................... 102 Polecenie bzip2 — kompresowanie plików ...............................................................................................103 Polecenia bzcat oraz bunzip2 — dekompresowanie plików ...................................................................104 Polecenie gzip — kompresowanie plików ..................................................................................................104 Polecenie tar — pakowanie i rozpakowywanie archiwów .......................................................................105

Lokalizowanie poleceń ..................................................................................................................... 107 Polecenia which i whereis — wyszukiwanie narzędzi ..............................................................................107 Polecenie locate — wyszukiwanie plików ..................................................................................................109

Wyświetlanie informacji o systemie i użytkownikach ................................................................ 109 Polecenie who — wyświetlanie listy zalogowanych użytkowników .......................................................109 Polecenie finger — wyświetlanie listy użytkowników danego systemu ................................................110 Polecenie uptime — wyświetlanie informacji o systemie i jego obciążeniu .........................................111 Polecenie w — wyświetlanie listy zalogowanych użytkowników ...........................................................112 Polecenie free — wyświetlanie informacji o wykorzystaniu pamięci ....................................................112

Komunikacja z innymi użytkownikami ........................................................................................ 113 Polecenie write — wysyłanie wiadomości ..................................................................................................113 Polecenie mesg — blokowanie lub przyjmowanie wiadomości .............................................................114

Poczta elektroniczna ........................................................................................................................ 114 Podsumowanie rozdziału ................................................................................................................ 115 Ćwiczenia ........................................................................................................................................... 117 Ćwiczenia zaawansowane ................................................................................................................ 118

4.

SYSTEM PLIKÓW ...........................................................................................................119 Hierarchiczny system plików .......................................................................................................... 120 Pliki katalogów i pliki zwykłe .......................................................................................................... 121 Nazwy plików .................................................................................................................................................122 Katalog roboczy ..............................................................................................................................................124 Twój katalog domowy ...................................................................................................................................124

Ścieżki do plików i katalogów ......................................................................................................... 125 Ścieżki bezwzględne .......................................................................................................................................125 Ścieżki względne .............................................................................................................................................127

Praca z katalogami ............................................................................................................................ 127 Polecenie mkdir — tworzenie katalogów ...................................................................................................128 Polecenie cd — zmiana katalogu roboczego ..............................................................................................129 Polecenie rmdir — usuwanie katalogów ....................................................................................................131 Korzystanie ze ścieżek ...................................................................................................................................131 Polecenia mv i cp — przenoszenie lub kopiowanie plików .....................................................................132 Polecenie mv — przenoszenie katalogów ...................................................................................................132 Ważne pliki i katalogi domyślne ..................................................................................................................133

Prawa dostępu ................................................................................................................................... 135 Polecenie ls -l — wyświetlanie praw dostępu ............................................................................................135 Polecenie chmod — zmiana praw dostępu ................................................................................................136 Argumenty numeryczne polecenia chmod ................................................................................................138 Atrybuty setuid i setgid — specjalne prawa dostępu ................................................................................139 Prawa dostępu do katalogów ........................................................................................................................140

ACL — lista kontroli dostępu ......................................................................................................... 141 Włączanie obsługi list ACL ..........................................................................................................................142 Praca z regułami dostępu ..............................................................................................................................142 Definiowanie reguł domyślnych dla katalogu ...........................................................................................144

14  SPIS TREŚCI Dowiązania ........................................................................................................................................ 146 Dowiązania symboliczne ..............................................................................................................................149 Polecenie rm — usuwanie dowiązania .......................................................................................................151 Odwołania do dowiązań symbolicznych ....................................................................................................152

Podsumowanie rozdziału ................................................................................................................ 155 Ćwiczenia ........................................................................................................................................... 156 Ćwiczenia zaawansowane ................................................................................................................ 158

5.

POWŁOKA SYSTEMU LINUX ............................................................................................159 Wiersz poleceń .................................................................................................................................. 160 Proste polecenia ..............................................................................................................................................160 Składnia ...........................................................................................................................................................160 Przetwarzanie wiersza poleceń .....................................................................................................................164 Uruchamianie poleceń ..................................................................................................................................166 Edytowanie wiersza poleceń .........................................................................................................................167

Standardowe wejście i standardowe wyjście danych ................................................................... 167 Ekran jako plik ................................................................................................................................................168 Klawiatura i ekran jako standardowe wejście i standardowe wyjście ....................................................168 Przekierowania ...............................................................................................................................................169 Potoki danych .................................................................................................................................................174 Przykłady użycia potoków danych ..............................................................................................................175

Uruchamianie poleceń pracujących w tle ..................................................................................... 179 Generowanie i rozwijanie nazw plików ......................................................................................... 180 Znak specjalny — ? ........................................................................................................................................181 Znak specjalny — * ........................................................................................................................................182 Znaki specjalne — [ ] .....................................................................................................................................183

Wbudowane polecenia powłoki ..................................................................................................... 185 Podsumowanie rozdziału ................................................................................................................ 185 Polecenia i narzędzia omawiane w tym rozdziale .....................................................................................186

Ćwiczenia ........................................................................................................................................... 186 Ćwiczenia zaawansowane ................................................................................................................ 188

II EDYTORY ......................................................................................... 189 6.

EDYTOR VIM .................................................................................................................191 Historia ............................................................................................................................................... 192 Poradnik: jak użyć edytora vim do utworzenia i edytowania pliku .......................................... 193 Uruchamianie edytora vim ...........................................................................................................................193 Tryb komend i tryb wprowadzania .............................................................................................................194 Wprowadzanie tekstu ....................................................................................................................................196 Uzyskiwanie pomocy .....................................................................................................................................196 Zakończenie pracy z edytorem ....................................................................................................................199 Parametr compatible .....................................................................................................................................199

Wprowadzenie do funkcji edytora vim ......................................................................................... 200 Pomoc w internecie .......................................................................................................................................200 Terminologia ..................................................................................................................................................200 Tryby działania ...............................................................................................................................................200 Ekran ................................................................................................................................................................201 Poprawianie tekstu podczas jego wstawiania ............................................................................................202 Bufor roboczy .................................................................................................................................................202

Spis treści  15

Długość wiersza i wielkość pliku .................................................................................................................202 Okna .................................................................................................................................................................202 Blokady plików ...............................................................................................................................................203 Nagłe zakończenie sesji edycji ......................................................................................................................203 Odzyskanie tekstu po awarii .........................................................................................................................204

Tryb komend — poruszanie kursorem ......................................................................................... 205 Przeniesienie kursora o znak ........................................................................................................................206 Przeniesienie kursora do wskazanego znaku .............................................................................................206 Przenoszenie kursora o słowa ......................................................................................................................206 Przenoszenie kursora o wiersze ...................................................................................................................207 Przeniesienie kursora o zdania i akapity ....................................................................................................207 Przeniesienie kursora na ekranie .................................................................................................................207 Wyświetlanie różnych fragmentów bufora roboczego .............................................................................208

Tryb wprowadzania .......................................................................................................................... 208 Wstawianie tekstu ..........................................................................................................................................208 Dodawanie tekstu ...........................................................................................................................................209 Tworzenie nowego wiersza dla tekstu .........................................................................................................209 Zastępowanie tekstu ......................................................................................................................................209 Cytowanie znaków specjalnych w trybie wprowadzania .........................................................................209

Tryb komend — usuwanie i zmiana tekstu .................................................................................. 210 Cofanie zmian .................................................................................................................................................210 Usuwanie znaków ..........................................................................................................................................210 Usuwanie tekstu .............................................................................................................................................210 Zmiana tekstu .................................................................................................................................................211 Zastępowanie tekstu ......................................................................................................................................212 Zmiana wielkości znaków .............................................................................................................................213

Wyszukiwanie i zastępowanie ........................................................................................................ 213 Wyszukiwanie znaku .....................................................................................................................................213 Wyszukiwanie ciągu tekstowego .................................................................................................................213 Zastąpienie jednego ciągu tekstowego innym ...........................................................................................216

Różne polecenia ................................................................................................................................ 218 Złączenie ..........................................................................................................................................................218 Stan ...................................................................................................................................................................218 Kropka .............................................................................................................................................................218

Kopiowanie, przenoszenie i usuwanie tekstu ............................................................................... 219 Bufor ogólnego przeznaczenia .....................................................................................................................219

Odczyt i zapis plików ....................................................................................................................... 221 Odczyt pliku ....................................................................................................................................................221 Zapis pliku .......................................................................................................................................................221 Identyfikacja bieżącego wiersza ...................................................................................................................222

Ustawianie parametrów ................................................................................................................... 222 Ustawianie parametrów w edytorze vim ....................................................................................................222 Ustawianie parametrów w pliku startowym ..............................................................................................222 Plik startowy .vimrc .......................................................................................................................................223 Parametry ........................................................................................................................................................223

Zaawansowane techniki edycji ....................................................................................................... 226 Wykonywanie poleceń powłoki w edytorze vim .......................................................................................228

Jednostki miary ................................................................................................................................. 230 Znak .................................................................................................................................................................230 Słowo ................................................................................................................................................................230 Słowa ograniczone znakami odstępu ..........................................................................................................230 Wiersz ..............................................................................................................................................................231

16  SPIS TREŚCI Zdanie ..............................................................................................................................................................231 Akapit ...............................................................................................................................................................231 Ekran (okno) ...................................................................................................................................................231 Współczynnik powtórzenia ..........................................................................................................................231

Podsumowanie rozdziału ................................................................................................................ 232 Ćwiczenia ........................................................................................................................................... 236 Ćwiczenia zaawansowane ................................................................................................................ 237

7.

EDYTOR EMACS ............................................................................................................239 Historia ............................................................................................................................................... 240 Ewolucja ..........................................................................................................................................................240 emacs kontra vim ...........................................................................................................................................241

Poradnik — rozpoczęcie pracy z edytorem emacs ...................................................................... 242 Uruchomienie edytora emacs ......................................................................................................................242 Zakończenie pracy .........................................................................................................................................244 Wstawianie tekstu ..........................................................................................................................................244 Usuwanie znaków ..........................................................................................................................................244 Przenoszenie kursora .....................................................................................................................................245 Edycja w miejscu położenia kursora ...........................................................................................................247 Zapisywanie i pobieranie bufora ..................................................................................................................247

Podstawowe polecenia edycji .......................................................................................................... 248 Klawisze — notacja i użycie ..........................................................................................................................248 Polecenia i sekwencje klawiszy .....................................................................................................................249 Meta+x — wykonanie polecenia bez przypisania klawiszy .....................................................................249 Argumenty liczbowe ......................................................................................................................................250 Punkt i kursor .................................................................................................................................................250 Przewijanie zawartości bufora ......................................................................................................................250 Usuwanie tekstu .............................................................................................................................................251 Wyszukiwanie tekstu .....................................................................................................................................251 Używanie paska menu za pomocą klawiatury ...........................................................................................253

Pomoc dostępna w edytorze ........................................................................................................... 254 Zaawansowana edycja ...................................................................................................................... 256 Cofanie wprowadzonych zmian ..................................................................................................................256 Punkt, znacznik i region ...............................................................................................................................257 Wytnij i wklej — wklejanie wyciętego tekstu .............................................................................................258 Wstawianie znaków specjalnych .................................................................................................................260 Globalne polecenia dotyczące bufora .........................................................................................................260 Wizytowanie i zapisywanie plików .............................................................................................................262 Bufory ..............................................................................................................................................................264 Okna .................................................................................................................................................................265 Pierwszoplanowe polecenia powłoki ..........................................................................................................267 Polecenia powłoki działające w tle ..............................................................................................................267

Tryby podstawowe — edycja w zależności od języka .................................................................. 268 Wybór trybu podstawowego ........................................................................................................................269 Tryby języków czytelnych dla człowieka ....................................................................................................269 Tryb C ..............................................................................................................................................................272 Dostosowanie wcięć do własnych potrzeb .................................................................................................274 Komentarze .....................................................................................................................................................274 Tryby specjalnego przeznaczenia ................................................................................................................274

Spis treści  17

Więcej informacji ............................................................................................................................. 280 Uzyskanie dostępu do emacs ........................................................................................................................280

Podsumowanie rozdziału ................................................................................................................ 280 Ćwiczenia ........................................................................................................................................... 287 Ćwiczenia zaawansowane ................................................................................................................ 288

III POWŁOKI ......................................................................................... 291 8.

POWŁOKA BOURNE AGAIN SHELL (BASH) ........................................................................293 Kilka słów o powłoce bash .............................................................................................................. 294 Pliki startowe ..................................................................................................................................... 296 Powłoka logowania ........................................................................................................................................296 Powłoki interaktywne (typu non-login) .....................................................................................................297 Powłoki nieinteraktywne ..............................................................................................................................297 Konfiguracja plików startowych ..................................................................................................................297 Polecenie source lub (.) — uruchamianie plików startowych w bieżącej powłoce ..............................298

Polecenia, które są symbolami ........................................................................................................ 299 Przekierowywanie standardowego strumienia błędów ............................................................... 299 Tworzenie i uruchamianie prostych skryptów powłoki ............................................................. 302 Polecenie chmod — tworzenie plików wykonywalnych ..........................................................................302 Znaki #! definiują typ powłoki .....................................................................................................................304 Znak # oznacza początek komentarza ........................................................................................................305 Wykonywanie skryptów powłoki ................................................................................................................305

Operatory sterujące — separacja i grupowanie poleceń ............................................................. 306 Znak średnika i znak nowego wiersza oddzielają polecenia ....................................................................307 Znaki | oraz & — odseparuj polecenia i zrób coś jeszcze… ....................................................................307 Operatory && i || ...........................................................................................................................................308 Znak \ oznacza kontynuację wiersza polecenia .........................................................................................310

Sterowanie zadaniami ...................................................................................................................... 311 Polecenie jobs — wyświetlanie listy zadań .................................................................................................311 Polecenie fg — przenoszenie zadania do pracy na pierwszym planie ...................................................311 Zawieszanie realizacji zadania ......................................................................................................................312 Polecenie bg — przenoszenie zadania do pracy w tle ...............................................................................312

Wykorzystanie stosu katalogów ..................................................................................................... 313 Polecenie dirs — wyświetlanie stosu katalogów ........................................................................................313 Polecenie pushd — umieszczenie nazwy katalogu na stosie ...................................................................314 Polecenie popd — zdejmowanie nazwy katalogu ze stosu ......................................................................315

Parametry i zmienne ........................................................................................................................ 316 Zmienne tworzone przez użytkownika ......................................................................................................318 Polecenie unset — usuwanie zmiennych ...................................................................................................320 Atrybuty zmiennych ......................................................................................................................................320 Zmienne środowiskowe ................................................................................................................................322

Znaki specjalne .................................................................................................................................. 330 Ustawienia językowe ........................................................................................................................ 331 LC_, czyli zmienne ustawień językowych ..................................................................................................331 Polecenie locale — wyświetlanie informacji o ustawieniach językowych .............................................332 Konfiguracja ustawień językowych .............................................................................................................333

Ustawienia czasu ............................................................................................................................... 334

18  SPIS TREŚCI Procesy ............................................................................................................................................... 337 Struktura procesów ........................................................................................................................................337 Identyfikacja procesów ..................................................................................................................................337 Uruchamianie poleceń ..................................................................................................................................339

Historia poleceń ................................................................................................................................ 340 Zmienne, które sterują historią poleceń .....................................................................................................340 Ponowne wykonywanie i modyfikacja poleceń .........................................................................................342 Biblioteka Readline ........................................................................................................................................349

Aliasy .................................................................................................................................................. 355 Zastosowanie apostrofów i cudzysłowu w aliasach ..................................................................................356 Przykłady aliasów ...........................................................................................................................................356

Funkcje ............................................................................................................................................... 358 Sterowanie powłoką bash — opcje ................................................................................................. 361 Opcje wywołania polecenia bash .................................................................................................................361 Opcje powłoki .................................................................................................................................................361

Przetwarzanie wiersza poleceń ....................................................................................................... 365 Podstawianie poleceń z historii ....................................................................................................................366 Podstawianie aliasów .....................................................................................................................................366 Przetwarzanie i skanowanie wiersza polecenia .........................................................................................366 Rozwijanie wiersza polecenia .......................................................................................................................366

Podsumowanie rozdziału ................................................................................................................ 375 Ćwiczenia ........................................................................................................................................... 377 Ćwiczenia zaawansowane ................................................................................................................ 378

9.

POWŁOKA TC SHELL (TCSH) ..........................................................................................381 Skrypty powłoki ................................................................................................................................ 382 Uruchamianie i zamykanie powłoki TC Shell .............................................................................. 383 Pliki startowe ..................................................................................................................................................384

Funkcje wspólne powłok Bourne Again Shell i TC Shell ............................................................ 385 Rozwinięcie wiersza poleceń powłoki (zastępowanie) .............................................................................385 Sterowanie zadaniami ....................................................................................................................................389 Zastępowanie nazw plików ...........................................................................................................................389 Operacje na stosie katalogów .......................................................................................................................390 Zastępowanie poleceń ...................................................................................................................................390

Przekierowanie standardowego strumienia błędów .................................................................... 390 Praca z wierszem poleceń powłoki ................................................................................................. 391 Uzupełnianie słów ..........................................................................................................................................391 Edycja wiersza poleceń powłoki ..................................................................................................................393 Poprawianie pisowni .....................................................................................................................................394

Zmienne ............................................................................................................................................. 395 Zastępowanie zmiennej .................................................................................................................................396 Zmienne w postaci ciągów tekstowych .......................................................................................................396 Tablice zmiennych w postaci ciągów tekstowych .....................................................................................397 Zmienne liczbowe ..........................................................................................................................................397 Specjalne postacie zmiennych ......................................................................................................................400 Zmienne tcsh ..................................................................................................................................................400

Struktury sterujące ............................................................................................................................ 406 if ........................................................................................................................................................................406 goto ...................................................................................................................................................................408 Obsługa przerwań ..........................................................................................................................................409 if...then...else ....................................................................................................................................................409

Spis treści  19

foreach .............................................................................................................................................................410 while .................................................................................................................................................................412 break i continue ..............................................................................................................................................412 switch ...............................................................................................................................................................412

Wbudowane polecenia powłoki ..................................................................................................... 413 Podsumowanie rozdziału ................................................................................................................ 417 Ćwiczenia ........................................................................................................................................... 418 Ćwiczenia zaawansowane ................................................................................................................ 419

IV NARZĘDZIA PROGRAMISTYCZNE .................................................. 421 10. PROGRAMOWANIE POWŁOKI BOURNE AGAIN SHELL .........................................................423 Struktury sterujące ............................................................................................................................ 425 Polecenie if…then ..........................................................................................................................................425 Polecenie if…then…else ...............................................................................................................................428 Polecenie if…then…elif ................................................................................................................................430 Polecenie for…in ............................................................................................................................................436 Polecenie for ...................................................................................................................................................438 Polecenie while ...............................................................................................................................................440 Polecenie until ................................................................................................................................................443 Polecenia break i continue ............................................................................................................................445 Polecenie case .................................................................................................................................................445 Polecenie select ...............................................................................................................................................451 Dokument Here ..............................................................................................................................................453

Deskryptory plików .......................................................................................................................... 454 Otwieranie deskryptora pliku ......................................................................................................................455 Tworzenie duplikatów deskryptorów plików ............................................................................................455 Przykłady użycia deskryptora pliku ............................................................................................................455 Ustalenie, czy deskryptor pliku jest powiązany z terminalem ................................................................457

Parametry ........................................................................................................................................... 459 Parametry pozycyjne .....................................................................................................................................459 Parametry specjalne .......................................................................................................................................464

Zmienne ............................................................................................................................................. 467 Zmienne powłoki ...........................................................................................................................................467 Środowisko, zmienne środowiskowe i dziedziczenie ...............................................................................468 Rozwijanie zmiennych o wartości null i zmiennych, które nie są ustawione .......................................472 Zmienne tablicowe .........................................................................................................................................473 Zmienne w funkcjach ....................................................................................................................................474

Wbudowane polecenia powłoki ..................................................................................................... 475 Polecenie type — wyświetlanie informacji o innych poleceniach ..........................................................476 Polecenie read — pobieranie danych wpisywanych przez użytkownika ...............................................476 Polecenie exec — uruchomienie polecenia lub przekierowanie deskryptora pliku ............................479 Polecenie trap — przechwytywanie i obsługa sygnałów ..........................................................................482 Polecenie kill — przerywanie i zatrzymywanie działania procesu .........................................................485 Polecenie eval — skanowanie, przetwarzanie i wykonywanie polecenia powłoki ...............................485 Polecenie getopts — przetwarzanie opcji wywołania ...............................................................................486 Lista wybranych, wbudowanych poleceń powłoki ...................................................................................488

Wyrażenia .......................................................................................................................................... 489 Obliczanie wyrażeń arytmetycznych ...........................................................................................................490 Obliczanie wyrażeń logicznych (wyrażenia warunkowe) ........................................................................491

20  SPIS TREŚCI Dopasowywanie wzorców tekstu .................................................................................................................492 Operatory ........................................................................................................................................................492

Domniemana kontynuacja polecenia powłoki ............................................................................. 495 Programowanie powłoki ................................................................................................................. 496 Rekurencyjny skrypt powłoki ......................................................................................................................497 Kolejny skrypt powłoki — quiz ...................................................................................................................500

Podsumowanie rozdziału ................................................................................................................ 506 Ćwiczenia ........................................................................................................................................... 507 Ćwiczenia zaawansowane ................................................................................................................ 509

11. PERL — SKRYPTOWY JĘZYK PROGRAMOWANIA ................................................................511 Wprowadzenie do języka Perl ......................................................................................................... 512 Więcej informacji ...........................................................................................................................................513 Pomoc ..............................................................................................................................................................513 Polecenie perldoc ...........................................................................................................................................513 Terminologia ..................................................................................................................................................515 Uruchamianie programów napisanych w języku Perl .............................................................................516 Składnia ...........................................................................................................................................................517

Zmienne ............................................................................................................................................. 519 Zmienne skalarne ...........................................................................................................................................521 Zmienne tablicowe .........................................................................................................................................522 Tablice asocjacyjne .........................................................................................................................................524

Struktury sterujące ............................................................................................................................ 526 Polecenia if i unless ........................................................................................................................................526 Polecenie if…else ...........................................................................................................................................528 Polecenie if…elsif…else ................................................................................................................................528 Polecenia foreach i for ...................................................................................................................................529 Polecenia last i next ........................................................................................................................................530 Polecenia while i until ...................................................................................................................................532

Praca z plikami .................................................................................................................................. 533 Sortowanie ......................................................................................................................................... 537 Procedury ........................................................................................................................................... 538 Wyrażenia regularne ........................................................................................................................ 540 Składnia i operator =~ ...................................................................................................................................540

Moduły CPAN .................................................................................................................................. 545 Przykłady ........................................................................................................................................... 547 Podsumowanie rozdziału ................................................................................................................ 550 Ćwiczenia ........................................................................................................................................... 550 Ćwiczenia zaawansowane ................................................................................................................ 551

12. JĘZYK PROGRAMOWANIA PYTHON ..................................................................................553 Wprowadzenie .................................................................................................................................. 554 Wywoływanie Pythona .................................................................................................................................554 Więcej informacji ...........................................................................................................................................556 Zapis do standardowego wyjścia i odczyt ze standardowego wejścia ....................................................556 Funkcje i metody ............................................................................................................................................557

Zmienne skalarne, listy i słowniki .................................................................................................. 558 Zmienne skalarne ...........................................................................................................................................558 Listy ..................................................................................................................................................................558 Słowniki ...........................................................................................................................................................562

Spis treści  21

Struktury sterujące ............................................................................................................................ 563 if ........................................................................................................................................................................563 if...else ...............................................................................................................................................................564 if...elif...else ......................................................................................................................................................564 while .................................................................................................................................................................565 for .....................................................................................................................................................................565

Odczyt danych z pliku oraz zapis w nim danych ......................................................................... 567 Dane wejściowe i wyjściowe pliku ...............................................................................................................567 Obsługa wyjątków ..........................................................................................................................................568 Pickle ................................................................................................................................................................569

Wyrażenia regularne ........................................................................................................................ 570 Definiowanie funkcji ........................................................................................................................ 572 Używanie bibliotek ........................................................................................................................... 572 Biblioteka standardowa .................................................................................................................................572 Biblioteki niestandardowe ............................................................................................................................573 Biblioteki SciPy i NumPy ..............................................................................................................................573 Przestrzeń nazw ..............................................................................................................................................573 Import modułu ...............................................................................................................................................574 Przykład importowania funkcji ...................................................................................................................574

Funkcje lambda ................................................................................................................................. 576 Listy składane .................................................................................................................................... 576 Podsumowanie rozdziału ................................................................................................................ 577 Ćwiczenia ........................................................................................................................................... 578 Ćwiczenia zaawansowane ................................................................................................................ 578

13. BAZA DANYCH MYSQL .................................................................................................581 Informacje .......................................................................................................................................... 582 Terminologia ..................................................................................................................................................582 Składnia i przyjęte konwencje ......................................................................................................................583 Więcej informacji ...........................................................................................................................................585

Instalacja serwera i klienta MySQL ................................................................................................ 585 Fedora/RHEL (Red Hat Enterprise Linux) ................................................................................................585 Debian/Ubuntu/Mint ....................................................................................................................................585 openSUSE ........................................................................................................................................................586 OS X .................................................................................................................................................................586

Opcje klienta ...................................................................................................................................... 586 Konfiguracja MySQL ....................................................................................................................... 587 Zdefiniowanie hasła dla użytkownika root bazy danych MySQL ..........................................................587 Usunięcie użytkowników anonimowych ...................................................................................................587 Uruchomienie skryptu bezpiecznej instalacji ............................................................................................587 Plik ~/.my.cnf — konfiguracja klienta MySQL .........................................................................................588 Plik ~/.mysql_history — historia klienta MySQL .....................................................................................588

Tworzenie bazy danych ................................................................................................................... 588 Dodawanie użytkowników .............................................................................................................. 589 Przykłady ........................................................................................................................................... 590 Logowanie .......................................................................................................................................................590 Tworzenie tabel ..............................................................................................................................................590 Dodawanie danych ........................................................................................................................................592 Pobieranie danych ..........................................................................................................................................593

22  SPIS TREŚCI Tworzenie kopii zapasowej bazy danych ....................................................................................................594 Modyfikowanie danych .................................................................................................................................595 Utworzenie drugiej tabeli ..............................................................................................................................595 Złączenia ..........................................................................................................................................................596

Podsumowanie rozdziału ................................................................................................................ 600 Ćwiczenia ........................................................................................................................................... 600

14. JĘZYK PRZETWARZANIA WZORCÓW AWK ........................................................................601 Składnia .............................................................................................................................................. 602 Argumenty ......................................................................................................................................... 602 Opcje ................................................................................................................................................... 603 Uwagi .................................................................................................................................................. 604 Podstawy języka ................................................................................................................................ 604 Wzorce .............................................................................................................................................................604 Akcje .................................................................................................................................................................605 Komentarze .....................................................................................................................................................605 Zmienne ...........................................................................................................................................................605 Funkcje ............................................................................................................................................................606 Operatory arytmetyczne ...............................................................................................................................607 Tablice asocjacyjne .........................................................................................................................................607 Polecenie printf ..............................................................................................................................................608 Struktury sterujące .........................................................................................................................................608

Przykłady ........................................................................................................................................... 610 Zaawansowane programowanie gawk ........................................................................................... 623 Polecenie getline — kontrolowanie danych wejściowych .......................................................................623 Koproces — dwukierunkowe wejście-wyjście ...........................................................................................625 Pobieranie danych wejściowych poprzez sieć ............................................................................................626

Podsumowanie rozdziału ................................................................................................................ 627 Ćwiczenia ........................................................................................................................................... 628 Ćwiczenia zaawansowane ................................................................................................................ 628

15. EDYTOR SED .................................................................................................................629 Składnia .............................................................................................................................................. 630 Argumenty ......................................................................................................................................... 630 Opcje ................................................................................................................................................... 630 Podstawy edytora .............................................................................................................................. 631 Adresy ..............................................................................................................................................................631 Polecenia ..........................................................................................................................................................631 Struktury sterujące .........................................................................................................................................633 Miejsce przechowywania ..............................................................................................................................633

Przykłady ........................................................................................................................................... 634 Podsumowanie rozdziału ................................................................................................................ 642 Ćwiczenia ........................................................................................................................................... 642

Spis treści  23

V NARZĘDZIA BEZPIECZNEJ SIECI ..................................................... 643 16. NARZĘDZIE RSYNC SŁUŻĄCE DO BEZPIECZNEGO KOPIOWANIA PLIKÓW ................................645 Składnia .............................................................................................................................................. 646 Argumenty ......................................................................................................................................... 646 Opcje ................................................................................................................................................... 646 Uwagi ...............................................................................................................................................................648 Więcej informacji ...........................................................................................................................................649

Przykłady ........................................................................................................................................... 649 Użycie ukośnika (/) na końcu źródła ..........................................................................................................649 Usuwanie plików ............................................................................................................................................650 Kopiowanie plików do oraz z systemu zdalnego .......................................................................................651 Tworzenie lustrzanej kopii katalogu ...........................................................................................................652 Tworzenie kopii zapasowej ...........................................................................................................................652 Przywracanie plików ......................................................................................................................................654

Podsumowanie rozdziału ................................................................................................................ 655 Ćwiczenia ........................................................................................................................................... 655

17. OPENSSH — BEZPIECZNA KOMUNIKACJA SIECIOWA ........................................................657 Wprowadzenie do OpenSSH .......................................................................................................... 658 Jak działa OpenSSH .......................................................................................................................................659 Pliki ..................................................................................................................................................................659 Więcej informacji ...........................................................................................................................................660

Uruchomienie klientów OpenSSH — ssh, scp i sftp ................................................................... 660 Szybki start — użycie ssh oraz scp do połączenia z serwerem OpenSSH ..............................................661 Konfiguracja klientów OpenSSH .................................................................................................................661 ssh — logowanie lub wykonywanie poleceń w zdalnym systemie .........................................................663 scp — kopiowanie plików ze zdalnego systemu i do niego .....................................................................666 sftp — bezpieczny klient FTP .......................................................................................................................668 Pliki konfiguracyjne ~/.ssh/config oraz /etc/ssh/ssh_config ...................................................................668 Klucze uwierzytelniające — automatyczne logowanie .............................................................................670 ssh-agent — przechowywanie kluczy prywatnych ....................................................................................672

Tunelowanie i przekazywanie portów ........................................................................................... 673 Przekazywanie sesji X11 ................................................................................................................................673 Przekazywanie portów ..................................................................................................................................674

Podsumowanie rozdziału ................................................................................................................ 675 Ćwiczenia ........................................................................................................................................... 675 Ćwiczenia zaawansowane ................................................................................................................ 676

VI POLECENIA SYSTEMU LINUX .......................................................... 677 18. POLECENIA SYSTEMU LINUX ...........................................................................................679 Narzędzia służące do wyświetlania i przeprowadzania operacji na plikach ............................ 679 Narzędzia sieciowe ........................................................................................................................... 681 Narzędzia służące do wyświetlania informacji o stanie systemu i jego zmiany ...................... 681 Narzędzia programistyczne ............................................................................................................. 682 Narzędzia różne ................................................................................................................................ 682 Standardowe przyrostki multiplikatywne ..................................................................................... 683 Najczęściej używane opcje ............................................................................................................... 684 Narzędzie sample .............................................................................................................................. 684

24  SPIS TREŚCI sample aspell at busybox bzip2 cal cat cd chgrp chmod chown cmp comm configure cp cpio crontab cut date dd df diff diskutil ditto dmesg dscl du echo expand/unexpand expr file find finger fmt fsck ftp gawk gcc GetFileInfo grep gzip head join kill killall launchctl less

Krótkie omówienie działania danego narzędzia Sprawdza plik pod kątem błędów językowych Wykonuje polecenie o określonej godzinie Implementuje wiele standardowych narzędzi Kompresuje lub dekompresuje pliki Wyświetla kalendarz Łączy i wyświetla pliki Powoduje zmianę katalogu roboczego Zmienia grupę powiązaną z plikiem Zmienia tryb dostępu (uprawnienia) do pliku Zmienia właściciela pliku i (lub) grupę, z którą powiązany jest dany plik Porównuje dwa pliki Porównuje posortowane pliki Automatycznie konfiguruje kod źródłowy Kopiuje pliki Tworzy archiwum, przywraca pliki z archiwum lub kopiuje hierarchię katalogu Zapewnia obsługę plików crontab Wybiera znaki lub pola z wierszy danych wejściowych Wyświetla lub ustawia systemową datę i godzinę Konwertuje i kopiuje plik Wyświetla informacje o poziomie użycia miejsca na dysku Wyświetla różnice pomiędzy dwoma plikami tekstowymi Sprawdza, modyfikuje i naprawia woluminy lokalne Kopiuje pliki, tworzy i rozpakowuje archiwa Wyświetla komunikaty jądra Wyświetla i zarządza informacjami usługi katalogowej Wyświetla informacje o użyciu dysku przez hierarchię katalogu i (lub) plik Wyświetla komunikat Konwertuje tabulatory na spacje i spacje na tabulatory Oblicza wartość wyrażenia Wyświetla klasyfikację pliku Wyszukuje pliki na podstawie zdefiniowanych kryteriów Wyświetla informacje o użytkownikach W bardzo prosty sposób formatuje tekst Sprawdza i naprawia system plików Pozwala na kopiowanie plików przez sieć Wyszukuje i przetwarza wzorce w pliku Kompiluje kod źródłowy w językach C i C++ Wyświetla atrybuty pliku Wyszukuje wzorce w plikach Kompresuje lub dekompresuje pliki Wyświetla początek pliku Łączy wiersze z dwóch plików na podstawie wspólnego pola Kończy działanie procesu o wskazanym identyfikatorze Zakończenie działania procesu o podanej nazwie Nadzoruje działanie demona launchd Wyświetla pliki tekstowe po jednym ekranie tekstu w danej chwili

685 687 691 694 697 699 700 702 704 706 711 713 715 717 719 723 728 731 733 735 738 740 745 748 750 751 754 757 759 761 764 766 771 773 775 779 785 786 790 792 796 799 801 803 805 807 809

Spis treści  25

ln lpr ls make man mc mkdir mkfs mv nice nl nohup od open otool paste pax plutil pr printf ps renice rm rmdir rsync scp screen sed SetFile sleep sort split ssh sshfs/curlftpfs stat strings stty sysctl tail tar tee telnet test top touch

Tworzy dowiązanie do pliku Drukuje pliki Wyświetla informacje o jednym lub większej liczbie plików Ustala, który fragment programu wymaga ponownej kompilacji Wyświetla dokumentację dla poszczególnych narzędzi Zarządza plikami w środowisku tekstowym (menedżer Midnight Commander) Tworzy katalog Tworzy system plików w urządzeniu Zmienia nazwę lub przenosi plik Zmienia priorytet polecenia Numeruje wiersze zawartości pliku Uruchamia polecenie, które działa po wylogowaniu się Zrzuca zawartość pliku Otwiera pliki, katalogi i adresy URL Wyświetla obiekty, biblioteki i pliki wykonywalne Łączy odpowiadające sobie wiersze plików Tworzy archiwum, przywraca pliki z archiwum lub kopiuje hierarchię katalogów Przeprowadza operacje na plikach typu property list Stronicuje pliki przeznaczone do wydruku Nadaje formatowanie ciągowi tekstowemu i danym liczbowym, a następnie je wyświetla Wyświetla informacje o stanie procesu Zmienia priorytet procesu Usuwa plik (dowiązanie) Usuwa katalog Bezpiecznie kopiuje pliki oraz hierarchię katalogów poprzez sieć Bezpiecznie kopiuje jeden lub więcej plików do lub ze zdalnego systemu Zarządza wieloma oknami tekstowymi Edytuje plik w sposób nieinteraktywny Ustawia atrybuty pliku Tworzy proces, który będzie uśpiony przez określony czas Sortuje i (lub) łączy pliki Dzieli plik na sekcje Bezpiecznie uruchamia program lub powłokę w zdalnym systemie Montuje katalog serwera OpenSSH lub FTP jako katalog lokalny Wyświetla informacje o plikach Wyświetla ciągi tekstowe widocznych znaków treści zawartej w pliku Wyświetla lub ustawia parametry terminala Wyświetla i modyfikuje zmienne jądra w trakcie działania programu Wyświetla ostatnią część pliku Umieszcza pliki w archiwum lub je stamtąd pobiera Przekazuje standardowe wejście do standardowego wyjścia, tworząc kopię w jednym lub większej liczbie plików Łączy się poprzez sieć ze zdalnym komputerem Oblicza wartość wyrażenia Dynamicznie wyświetla informacje o stanie procesu Tworzy plik lub zmienia uprawnienia dostępu do pliku i (lub) datę i godzinę ostatniej modyfikacji pliku

813 815 818 825 830 833 839 840 843 845 847 849 850 854 856 858 860 865 867 869 872 876 877 879 880 881 882 887 888 890 891 899 901 902 905 907 908 912 913 916 921 922 925 928 931

26  SPIS TREŚCI tr tty tune2fs umask uniq w wc which who xargs

Zastępuje wskazane znaki Wyświetla ścieżkę dostępu do terminala Zmienia parametry systemów plików ext2, ext3 i ext4 Określa maskę uprawnień stosowaną podczas tworzenia pliku Wyświetla unikatowe wiersze z pliku Wyświetla informacje o użytkownikach systemu lokalnego Wyświetla liczbę wierszy, słów i bajtów w jednym lub większej liczbie plików Pokazuje ścieżkę dostępu do wskazanego narzędzia Wyświetla informacje o zalogowanych użytkownikach Tworzy listę argumentów i uruchamia polecenie

933 936 937 939 941 943 945 946 948 950

DODATKI ................................................................................................... 953 A

WYRAŻENIA REGULARNE ...............................................................................................955 Znaki ................................................................................................................................................... 956 Separatory .......................................................................................................................................... 956 Proste ciągi znaków .......................................................................................................................... 956 Znaki specjalne .................................................................................................................................. 956 Kropka .............................................................................................................................................................956 Nawiasy kwadratowe .....................................................................................................................................957 Gwiazdki ..........................................................................................................................................................957 Daszki i znaki dolara ......................................................................................................................................958 Cytowanie znaków specjalnych ...................................................................................................................958

Reguły ................................................................................................................................................. 958 Najdłuższe możliwe dopasowanie ...............................................................................................................958 Puste wyrażenia regularne ............................................................................................................................959

Oznaczanie wyrażeń ......................................................................................................................... 959 Ciągi zastępujące ............................................................................................................................... 960 Znak & (ampersand) .....................................................................................................................................960 Cytowane liczby .............................................................................................................................................960

Rozszerzone wyrażenia regularne .................................................................................................. 961 Podsumowanie .................................................................................................................................. 962

B

POMOC .......................................................................................................................965 Rozwiązywanie problemów ............................................................................................................. 966 Wyszukiwanie informacji związanych z systemami Linux i OS X ............................................ 967 Grupy dyskusyjne systemów Linux i OS X ................................................................................................967 Listy dyskusyjne .............................................................................................................................................967

Definiowanie typu terminala .......................................................................................................... 968

C

UAKTUALNIANIE SYSTEMU .............................................................................................971 Narzędzie yum .................................................................................................................................. 972 Używanie yum do instalacji, usuwania i uaktualniania pakietów ..........................................................972 Komendy polecenia yum ..............................................................................................................................974 Polecenie yum — grupy ................................................................................................................................975 Pobieranie pakietów RPM przy użyciu polecenia yumdownloader .......................................................976 Konfiguracja polecenia yum .........................................................................................................................976

Spis treści  27

Narzędzie apt-get .............................................................................................................................. 978 Używanie apt-get do instalacji, usuwania i uaktualniania pakietów ......................................................979 Używanie apt-get do uaktualnienia systemu .............................................................................................980 Inne opcje apt-get ...........................................................................................................................................980 Repozytoria .....................................................................................................................................................981 sources.list — repozytoria przeszukiwane przez apt-get .........................................................................981

BitTorrent .......................................................................................................................................... 982

D

UWAGI DOTYCZĄCE SYSTEMU OS X ................................................................................985 Open Directory ................................................................................................................................. 986 System plików ................................................................................................................................... 987 Niedyskowe systemy plików .........................................................................................................................987 Wielkość liter ..................................................................................................................................................987 /Volumes .........................................................................................................................................................987

Rozszerzone atrybuty ....................................................................................................................... 988 Fork ..................................................................................................................................................................988 Atrybuty pliku ................................................................................................................................................989 Listy ACL .........................................................................................................................................................991

Aktywacja klawisza Meta dla aplikacji Terminal ......................................................................... 993 Pliki startowe ..................................................................................................................................... 993 Zdalne logowanie .............................................................................................................................. 993 Wiele narzędzi nie spełnia wymagań opisanych w dokumencie Human Interface Guidelines ... 993 Instalacja Xcode i MacPorts ............................................................................................................ 993 Implementacja funkcji Linux w systemie OS X ........................................................................... 995

SŁOWNICZEK ................................................................................................................997 SKOROWIDZ ...............................................................................................................1055

28  SPIS TREŚCI

Wstęp

W książce Linux. Programowanie w powłoce. Praktyczny przewodnik. Wydanie III przedstawiono sposób pracy w powłoce systemu operacyjnego Linux. Pierwsze kilka rozdziałów zostało poświęconych podstawom, natomiast pozostała część książki bardziej zaawansowanym tematom omówionym nieco dokładniej. Książka nie jest poświęcona konkretnemu wydaniu bądź dystrybucji systemu Linux, zawarty w niej materiał dotyczy wszystkich najnowszych wersji systemu Linux.

Linux

W książce przedstawiono również informacje dotyczące pracy z systemem UNIX/Linux, na którym zbudowany został OS X. Będziesz mógł więc „spojrzeć pod maskę” tradycyjnego GUI (ang. Graphical User Interface, graficzny interfejs użytkownika), z którym większości osób kojarzy się Macintosh, i dowiesz się, jak używać posiadającego potężne możliwości wiersza poleceń powłoki (ang. Command Line Interface, CLI) bezpośrednio w OS X. Przedstawione w książce odniesienia do systemu Linux pośrednio dotyczą również OS X, a ewentualne różnice pomiędzy wymienionymi systemami są wyraźnie oznaczone.

OS X

Na początku był wiersz poleceń powłoki, w którym użytkownik wydawał systemowi polecenia, po prostu je wpisując. Nie było myszy i ikon pozwalających na stosowanie techniki przeciągnij i upuść. Niektóre programy, np. emacs, implementowały prymitywne okna poprzez wykorzystanie minimalnej grafiki dostępnej w zestawie znaków ASCII. Dzięki temu można było oddzielać poszczególne obszary na ekranie.

Wiersz poleceń powłoki

System Linux powstał i dojrzewał właśnie w takim środowisku, więc naturalne jest, że jego pierwsze narzędzia były uruchamiane z poziomu powłoki. Prawdziwa potęga systemu Linux nadal kryje się w wierszu poleceń powłoki, co wyjaśnia, dlaczego wielu profesjonalistów w swojej pracy korzysta wyłącznie z powłoki. Dzięki przedstawionym w książce jasnym objaśnieniom i wielu przykładom dowiesz się, jak maksymalnie wykorzystać wiersz poleceń powłoki w systemie Linux. Dystrybucja systemu Linux składa się z jądra, narzędzi i aplikacji. Obecnie dostępnych jest wiele dystrybucji, między innymi Ubuntu, Fedora, openSUSE, Red Hat, Debian, Mageia, Arch, CentOS i Mint. Wprawdzie poszczególne dystrybucje na wiele sposobów różnią się między sobą, ale tak naprawdę wszystkie opierają się na jądrze Linux, narzędziach i aplikacjach. Materiał przedstawiony w książce dotyczy komponentów, które znajdują się w większości dystrybucji. Dlatego też znajdujące się w książce informacje są przydatne niezależnie od używanej dystrybucji systemu Linux.

Dystrybucje systemu Linux

Co nowego w tym wydaniu?

Trzecie wydanie książki zawiera wiele nowego i uaktualnionego materiału:

 Nowy rozdział dotyczący programowania w języku Python (patrz rozdział 12.).  Nowy rozdział dotyczący bazy danych MySQL (patrz rozdział 13.).

30  WSTĘP  Nowy rozdział dotyczący narzędzi bezpiecznej komunikacji OpenSSH, między innymi ssh

(patrz rozdział 17.).  Uaktualnione rozdziały (patrz rozdziały 5., 8. i 10.) dotyczące powłoki bash. Te rozdziały

zawierają nowe informacje z zakresu:  Tabela hash oraz wbudowane polecenie hash.  Używanie nawiasów w sekwencjach wyrażeń w celu generowania wartości danego kroku.  Określanie, czy deskryptor pliku jest powiązany z terminalem.  Środowisko, zmienne środowiskowe kontra zmienne lokalne, dziedziczenie i miejsce

wykonywania procesów.  Używanie polecenia eval do przeszukiwania, określania i wykonywania innych poleceń

powłoki.  Operatory kontrolne i niejawna kontynuacja działania poleceń powłoki.  Kwestie dotyczące wersji językowych, analiza narzędzia locale i zmiennych LC_.  Konfiguracja strefy czasowej, zmienna środowiskowa TZ oraz narzędzie tzselect.  W części VI książki przedstawiono wiele nowych narzędzi wiersza poleceń powłoki,

między innymi:  screen — narzędzie służące do zarządzania sesją terminala.  busybox — zestaw narzędzi binarnych.  mc — menedżer plików Midnight Commander.  sshfs/curlftpfs — narzędzia pozwalające na zamontowanie katalogu w serwerze

OpenSSH lub FTP w taki sposób, jakby montowany katalog był katalogiem lokalnym.  expand/unexpand — narzędzia pozwalające na konwersję tabulatorów na spacje

i na odwrót.  join — narzędzie pozwalające na połączenie wierszy z dwóch plików na podstawie

wskazanego pola.  nl — narzędzie pozwalające na numerowanie wierszy pliku.  printf — narzędzie pozwalające na formatowanie ciągów tekstowych i danych liczbowych.

Jeżeli przeczytałeś inną książkę Marka, np.: Fedora i Red Hat Enterprise Linux. Praktyczny przewodnik, A Practical Guide to Ubuntu Linux®, Third Edition lub dowolne nowsze wydanie wymienionych pozycji, to możesz zwrócić uwagę na częściowe pokrywanie się przedstawionego materiału. Wprowadzenie, dodatek poświęcony wyrażeniom regularnym i rozdziały dotyczące narzędzi (rozdział 3. książki, ale już nie część VI), systemu plików, powłoki Bourne Again Shell (bash) i języka Perl są bardzo podobne w wymienionych książkach. Natomiast w niniejszej książce umieszczone są rozdziały, których nie znajdziesz w pozostałych książkach. Wspomniane rozdziały dotyczą edytorów vim i emacs, powłoki TC Shell (tcsh), języków AWK i sed, języka programowania Python, bazy danych MySQL i narzędzia rsync. Ponadto w VI części książki przedstawiono szczegółowy opis 98 najbardziej użytecznych programów narzędziowych w systemach Linux i OS X.

Częściowe pokrywanie się materiału

Ta książka jest przeznaczona dla szerokiego kręgu czytelników. Aby z niej skorzystać, wcale nie musisz być doświadczonym programistą, aczkolwiek pewna ogólna znajomość obsługi komputera z pewnością będzie pomocna. Książka jest przeznaczona dla:

Czytelnicy

 Studentów i uczniów, którzy na swoich zajęciach pracują z systemem Linux lub OS X.  Zaawansowanych użytkowników, którzy chcieliby wykorzystać potężne możliwości systemu

Linux lub OS X oferowane przez wiersz poleceń powłoki.  Zawodowców, którzy używają systemu Linux lub OS X w pracy.

Struktura książki  31

 Początkujących użytkowników Macintosha, którzy chcą poznać system UNIX/Linux,

przekonać się, dlaczego jest tak wychwalany, i nauczyć się wykorzystywania jego możliwości.  Zaawansowanych użytkowników Macintosha, którzy chcą dowiedzieć się, jak wykorzystać pełnię możliwości systemu UNIX/Linux, na podstawie którego powstał OS X.  Użytkowników systemu UNIX, którzy chcą uzupełnić swoją wiedzę o zagadnienia dotyczące

systemów Linux i OS X.  Administratorów systemu, którzy chcą lepiej poznać system Linux lub OS X i jego narzędzia,

z powłoką bash i językami Perl oraz Python włącznie.  Programistów sieciowych, którzy chcą poznać sposób działania systemu Linux oraz języki

programowania Perl i Python.  Studentów informatyki, którzy pracują z systemem Linux lub OS X na uczelni.  Programistów, którzy chcą poznać środowisko programowania w systemach Linux lub OS X.  Technicznej kadry menedżerów, którzy chcieliby pogłębić swoją znajomość systemu Linux

lub OS X. Książka Linux. Programowanie w powłoce. Praktyczny przewodnik. Wydanie III pokazuje, jak używać wiersza poleceń powłoki w systemach Linux i OS X. Niezależnie od tego, jakie masz doświadczenie w pracy z komputerami, niniejsza książka zapewni Ci wiedzę potrzebną do efektywnej pracy z wymienionymi systemami. Po przeczytaniu tej książki będziesz wiedział, jak używać systemów Linux i OS X, a sama książka jeszcze przez wiele miesięcy będzie dla Ciebie cennym podręcznym źródłem wiedzy o tych systemach.

Zalety książki

Dla systemu OS X dostępna jest ogromna ilość bezpłatnego oprogramowania. Ponadto społeczność tworząca oprogramowanie typu shareware pozostaje bardzo aktywna. Dzięki przedstawieniu w książce aspektów UNIX/Linux systemu OS X użytkownicy komputerów Macintosh uzyskują dostęp do dużej ilości bezpłatnego i taniego oprogramowania dostępnego dla systemów Linux i UNIX.

WSKAZÓWKA W tej książce termin Linux odnosi się do systemów Linux i OS X Zarówno Linux, jak i OS X wywodzą się z systemu operacyjnego UNIX. Wprawdzie graficzny interfejs użytkownika jest zupełnie inny w systemach Linux i OS X, ale wiersze poleceń powłoki pozostają bardzo podobne, w pewnych przypadkach wręcz identyczne. W książce przedstawiono wiersz poleceń powłoki systemów Linux i OS X. Aby zachować maksymalną czytelność, termin Linux odnosi się zarówno do systemu Linux, jak i OS X. Jeśli pomiędzy wymienionymi systemami występują różnice, są one wyraźnie zaznaczone.

STRUKTURA KSIĄŻKI Książka, którą trzymasz w ręku, została zaprojektowana i zorganizowana tak, aby ułatwić jej używanie w wielu sytuacjach. Możesz ją przeczytać od deski do deski i tym samym zupełnie od początku poznać wiersz poleceń powłoki systemu Linux. Jeżeli masz już jakieś doświadczenie w pracy z systemem Linux, możesz używać tej książki jako podręcznego kompendium wiedzy, z którego wybierasz interesujące Cię w danej chwili tematy — w spisie treści wyszukujesz interesujący Cię temat, a następnie przechodzisz prosto do niego. Ewentualnie przechodzisz do opisu dowolnego narzędzia z przedstawionych w części VI. Możesz również potraktować tę książkę jako katalog zagadnień związanych z systemem Linux, który możesz przeglądać strona po stronie, zatrzymując się tylko na tematach, które w taki czy inny sposób przyciągnęły Twoją uwagę. W książce znajdziesz wiele odwołań do różnych stron internetowych, na których możesz znaleźć wiele dodatkowych informacji — źródła internetowe możesz potraktować jako swego rodzaju rozszerzenie tej książki.

32  WSTĘP Książka Linux. Programowanie w powłoce. Praktyczny przewodnik. Wydanie III została opracowana w następujący sposób:  Opcjonalne sekcje z informacjami dodatkowymi pozwalają na czytanie tej książki na różnych

poziomach doświadczenia; dzięki nim możesz powrócić do trudniejszych zagadnień, kiedy będziesz do tego przygotowany.  Ramki z ostrzeżeniami przestrzegają przed procedurami, które łatwo mogą pójść nie tak, jak powinny, dzięki czemu będziesz wiedział, na co zwrócić szczególną uwagę, zanim wpadniesz w kłopoty.  Ramki ze wskazówkami pozwalają często zaoszczędzić wiele czasu poprzez zasugerowanie wykonania określonych czynności i procedur w taki czy inny sposób; wskazówki są również cennym źródłem dodatkowych informacji.  Ramki oznaczone etykietą „Bezpieczeństwo” wskazują zagadnienia, których odpowiednia

realizacja może się przyczynić do zwiększenia bezpieczeństwa całego systemu.  Każdy rozdział rozpoczyna się od listy „Cele rozdziału”, czyli listy najważniejszych zadań,

które będziesz potrafił wykonać po przeczytaniu rozdziału.  Zagadnienia teoretyczne są w tej książce często ilustrowane przez przykłady praktyczne.  W rozdziałach znajduje się wiele użytecznych adresów URL wskazujących witryny

zawierające oprogramowanie i informacje dodatkowe.  Indeksy pomagają w szybkim wyszukaniu interesujących Cię informacji. W celu zapewnienia

łatwego dostępu indeks narzędziowy znajduje się na początku i na końcu książki.  Na końcu każdego rozdziału znajdziesz „Podsumowanie”, które pozwoli Ci szybko powtórzyć

i przypomnieć sobie zagadnienia omawiane w rozdziale.  Na końcu każdego rozdziału znajdziesz również „Ćwiczenia”, które pozwolą Ci sprawdzić

nabytą wiedzę i rozszerzyć umiejętności. Odpowiedzi do ćwiczeń zamieszczono na witrynie http://www.sobell.com.  W książce w bardzo szczegółowy sposób zostało opisanych wiele narzędzi GNU, takich jak gcc,

system konfiguracji i kompilacji, polecenia make, gzip, i wiele innych narzędzi, które powstały w ramach projektu GNU.  W wielu miejscach książki znajdziesz odwołania do wielu źródeł dokumentacji, włączając w to dokumentację w systemie lokalnym i w sieci Internet.  Szczegółowo omówiono ważne narzędzia powłoki opracowane przez firmę Apple specjalnie dla

systemu OS X, między innymi diskutil, ditto, dscl, GetFileInfo, launchctl, otool, plutil i SetFile.  W książce znajdziesz także opisy rozszerzonych atrybutów OS X, między innymi tak zwane forks, atrybuty plików, atrybuty flag i listy ACL (ang. Access Control Lists).  W dodatku D, zatytułowanym „Uwagi dotyczące systemu OS X”, zostały przedstawione niektóre różnice pomiędzy systemami OS X i Linux.

KLUCZOWE ZAGADNIENIA OMAWIANE W TEJ KSIĄŻCE W tej sekcji znajdziesz krótkie zestawienie najważniejszych zagadnień omawianych w książce. Dowiesz się, jak materiał przedstawiony w poszczególnych rozdziałach może Ci pomóc w wykorzystaniu potężnych możliwości systemu Linux. Dodatkowe informacje o podziale każdego z rozdziałów znajdziesz w spisie treści.

Kluczowe zagadnienia omawiane w tej książce  33

 Rozdział 1. Witamy w systemach Linux i OS X

W tym rozdziale zaprezentowano podstawowe informacje o systemach Linux i OS X. Przedstawiamy krótką historię systemu Linux, jądro Mach stanowiące podstawę OS X, wyjaśniamy, jak projekt GNU pomógł systemowi Linux w zdobyciu popularności, i objaśniamy najważniejsze cechy systemu Linux odróżniające go od innych systemów operacyjnych.

CZĘŚĆ I — ROZPOCZYNAMY PRACĘ Z SYSTEMAMI LINUX I OS X WSKAZÓWKA Doświadczeni użytkownicy mogą pominąć część I Jeżeli już kiedyś wcześniej używałeś systemu UNIX lub Linux, być może będziesz chciał pominąć niektóre lub nawet wszystkie rozdziały części I. Pamiętaj jednak, że przynajmniej dwóch sekcji nie powinieneś pomijać; są to: „Konwencje używane w tej książce”, która omawia kwestie typografii i innych konwencji przyjętych w książce, oraz sekcja „Gdzie szukać dokumentacji systemu?” (rozdział 2.), która opisuje lokalne i sieciowe źródła, w których możesz znaleźć szczegółową dokumentację systemu Linux. W części I przedstawiamy system Linux, co pozwoli Ci na rozpoczęcie z nim pracy.  Rozdział 2. Wprowadzenie do systemów Linux i OS X W tym rozdziale przedstawione zostały konwencje typograficzne użyte w książce, dzięki którym tekst pozostaje przejrzysty i łatwy do czytania. Znajdują się tutaj także informacje podstawowe oraz objaśnienia, jak logować się do systemu, zmienić hasło, wydawać polecenia w powłoce oraz odszukać dokumentację systemową.  Rozdział 3. Narzędzia systemu Linux

W tym rozdziale opisano wiersz poleceń powłoki (CLI) oraz pokrótce ponad 30 narzędzi działających z poziomu powłoki. Dzięki lekturze tego rozdziału przekonasz się, na czym polega praca z systemem Linux, i poznasz kilka narzędzi używanych w codziennej pracy. Dokładniejsze omówienie narzędzi przedstawiono w części VI książki. Natomiast narzędzia zaprezentowane w rozdziale 3. to między innymi:  grep — pozwala na przeszukiwanie plików pod kątem ciągów tekstowych.  unix2dos — pozwala na konwersję plików tekstowych w formacie Linux na format

Windows.  tar — pozwala na utworzenie archiwów zawierających wiele innych plików.  bzip2 i gzip — pozwalają na kompresję plików, aby zajmowały mniej miejsca na dysku,

a ich przekazywanie poprzez sieć trwało krócej.  diff — pozwala na wyświetlanie różnic pomiędzy dwoma plikami tekstowymi.  Rozdział 4. System plików

W tym rozdziale omówiono następujące tematy: hierarchiczny system plików Linux, pliki, nazwy plików, ścieżki dostępu, praca z katalogami, uprawnienia dostępu, dowiązania twarde i symboliczne. Dzięki poznaniu systemu plików będziesz mógł zorganizować swoje dane i szybciej wyszukiwać potrzebne informacje. Ponadto zyskasz możliwość współdzielenia wybranych plików z innymi użytkownikami i jednoczesnego zachowania pozostałych plików jedynie dla siebie.  Rozdział 5. Powłoka systemu Linux W tym rozdziale dowiesz się, jak używać funkcji oferowanych przez powłokę, aby pracować szybciej i łatwiej. Wszystkie funkcje przedstawione w tym rozdziale działają zarówno w powłoce bash, jak i tcsh. W rozdziale poruszono m. in. następujące zagadnienia:  Używanie opcji wiersza poleceń powłoki w celu modyfikacji sposobu ich działania.  Wprowadzanie niewielkich zmian w poleceniach i przekierowywanie danych wejściowych

poleceń, aby pochodziły z pliku zamiast z klawiatury.

34  WSTĘP  Przekierowywanie danych wyjściowych poleceń do pliku zamiast na ekran.  Używanie potokowania w celu wysyłania danych wyjściowych jednego polecenia

bezpośrednio do innego polecenia, co pozwala na rozwiązanie wielu problemów w powłoce.  Uruchamianie programów w tle. Dzięki temu możesz pracować w jednym programie,

podczas gdy Linux w tle wykonuje zupełnie inne zadanie.  Używanie powłoki w celu generowania nazw plików, co pozwala zaoszczędzić czas potrzebny na ich wprowadzenie. Ponadto uzupełnianie nazw staje się pomocne, gdy nie pamiętasz dokładnej nazwy pliku.

CZĘŚĆ II — EDYTORY W części II zostaną omówione dwa klasyczne edytory tekstowe systemu Linux, które oferują naprawdę potężne możliwości. Większość dystrybucji systemu Linux jest dostarczana wraz z edytorem vim (ang. vi improved, vi rozbudowany), czyli wersją powszechnie używanego edytora vi. Ponadto w większości dystrybucji znajdziesz także popularny edytor GNU o nazwie emacs. Edytory tekstowe pozwalają na tworzenie i modyfikowanie plików tekstowych zawierających kod źródłowy programów, skrypty powłoki, notatki oraz inne dane wejściowe przeznaczone dla programów formatujących tekst. Ponieważ administracja systemem Linux obejmuje edycję tekstowych plików konfiguracyjnych, doświadczeni administratorzy systemów Linux potrafią posługiwać się wymienionymi edytorami tekstowymi.  Rozdział 6. Edytor vim

Na początku rozdziału przedstawiono wprowadzenie do edytora vim, a następnie omówiono wiele jego zaawansowanych funkcji, takich jak obsługa znaków specjalnych w wyszukiwanych ciągach tekstowych, bufory, parametry, markery i wykonywanie poleceń bezpośrednio w edytorze vim. Na końcu rozdziału znajdziesz podsumowanie poleceń edytora vim.  Rozdział 7. Edytor emacs Na początku rozdziału przedstawiono wprowadzenie do edytora emacs, a następnie omówiono wiele jego funkcji, takich jak używanie klawiszy Meta, Alt i Escape. Oprócz tego poruszone zostały tematy przypisania klawiszy, używania buforów, przyrostowego i zwykłego wyszukiwania ciągów tekstowych i wyrażeń regularnych. Szczegółowo przedstawiono powiązania pomiędzy punktem, kursorem, znacznikiem i regionem. Dowiesz się także, jak wykorzystać zalety rozbudowanej pomocy internetowej dostępnej dla edytora emacs. Inne zagadnienia poruszone w rozdziale to m.in. wycinanie i wklejanie, używanie wielu okien i ramek, praca w trybach emacs — zwłaszcza w trybie C, który pomaga programistom w tworzeniu kodu źródłowego w języku C oraz usuwaniu z niego błędów. Na końcu rozdziału znajdziesz podsumowanie poleceń edytora emacs.

CZĘŚĆ III — POWŁOKI W części III dokładnie zajmiemy się powłoką bash; poznasz też powłokę TC Shell (tcsh).  Rozdział 8. Powłoka Bourne Again Shell (bash)

Ten rozdział można potraktować jako kontynuację rozdziału 5. Zostaną omówione bardziej zaawansowane aspekty pracy z powłoką. Użyta w przykładach powłoka Bourne Again Shell — bash — jest praktycznie jedyną powłoką stosowaną w skryptach systemowych. Dzięki lekturze rozdziału 8. dowiesz się jak:  używać plików startowych powłoki, opcji powłoki oraz funkcji pozwalających na dostosowanie powłoki do własnych potrzeb;  używać kontroli zadań do zatrzymywania i przenoszenia zadań do działania w tle bądź

na pierwszym planie;  modyfikować i ponownie wykonywać polecenia, używając do tego listy historii powłoki;

Kluczowe zagadnienia omawiane w tej książce  35

 tworzyć aliasy w celu dostosowania poleceń do własnych potrzeb;  pracować z utworzonymi przez użytkownika oraz kluczowymi zmiennymi w skryptach

powłoki;  zapewniać różne wersje językowe dzięki użyciu narzędzia locale, zmiennych LC_

oraz internacjonalizacji;  przygotowywać funkcje, które są podobne do skryptów powłoki, ale wykonywane znacznie

szybciej;  tworzyć i wykonywać proste skrypty powłoki;  przekierowywać komunikaty błędów, aby były umieszczane w pliku, a nie wyświetlane

na ekranie.  Rozdział 9. Powłoka TC Shell (tcsh)

W tym rozdziale poznasz powłokę tcsh, a także funkcje łączące i dzielące powłoki bash i tcsh. Dzięki lekturze rozdziału 9. dowiesz się jak:  uruchamiać powłokę tcsh i zmienić powłokę domyślną na tcsh;  przekierowywać komunikaty błędów, aby były umieszczane w pliku, a nie wyświetlane

na ekranie;  używać struktur kontrolnych do wpływania na przepływ kontroli w skryptach powłoki;  pracować ze zmiennymi liczbowymi i tablicami w powłoce tcsh;  używać wbudowanych poleceń powłoki.

CZĘŚĆ IV — NARZĘDZIA PROGRAMISTYCZNE W części IV przedstawiamy najważniejsze narzędzia programistyczne intensywnie wykorzystywane podczas administracji systemami Linux i OS X oraz w ogólnych zadaniach programistycznych.  Rozdział 10. Programowanie powłoki Bourne Again Shell Ten rozdział można potraktować jako kontynuację rozdziału 8. Omówione zostaną znacznie bardziej zaawansowane zagadnienia dotyczące programowania powłoki bash, a całość uzupełnią rozbudowane przykłady. W rozdziale 10. omówiono następujące zagadnienia:  struktury kontrolne łącznie z if...then...else i case;  zmienne, atrybuty, wartość null, zmienne niezainicjalizowane, tablice zmiennych i zmienne

w funkcjach;  środowisko, zmienne środowiskowe oraz lokalne, dziedziczenie i miejsce wykonywania

procesów;  wyrażenia arytmetyczne i logiczne (boolowskie);  pewne najużyteczniejsze, wbudowane polecenia powłoki, m.in. exec, trap i getopts. Kiedy opanujesz podstawy dotyczące pracy w systemie Linux, zdobytą wiedzę możesz wykorzystać do tworzenia bardziej skomplikowanych i specjalizowanych programów, używając powłoki jako języka programowania. W rozdziale 10. przedstawiono dwa zadania związane z programowaniem powłoki oraz ich rozwiązania krok po kroku. W rozwiązaniu pierwszego zadania zastosowano rekurencję w celu utworzenia hierarchii katalogów. Z kolei drugie zadanie polega na opracowaniu programu quizu. Podczas rozwiązywania tego zadania dowiesz się, jak przygotować skrypt powłoki zapewniający interakcję z użytkownikiem, oraz przekonasz się, jak skrypt przetwarza dane. (Przykłady zaprezentowane w części VI książki również pokazują wiele funkcji narzędzi, które możesz wykorzystać w skryptach powłoki).

36  WSTĘP  Rozdział 11. Perl — skryptowy język programowania

W tym rozdziale przedstawiono wprowadzenie do popularnego i oferującego duże możliwości języka programowania Perl. W rozdziale poruszono następujące tematy:  narzędzia pomocy w Perl, w tym perldoc;  zmienne i struktury kontrolne w języku Perl;  obsługa plików w Perl;  wyrażenia regularne w Perl;  instalacja i używanie modułów CPAN.

Wiele skryptów administracyjnych w systemie Linux zostało utworzonych właśnie w języku Perl. Po lekturze rozdziału 11. będziesz znacznie lepiej rozumiał wspomniane skrypty, a ponadto zyskasz możliwość samodzielnego tworzenia skryptów w Perl. W rozdziale przedstawiono wiele przykładowych skryptów utworzonych w języku Perl.  Rozdział 12. Język programowania Python

W tym rozdziale omówiono elastyczny i przyjazny język programowania Python. W rozdziale poruszono następujące tematy:  listy i słowniki w Pythonie;  funkcje i metody języka Python, które możesz wykorzystać w celu wykonywania operacji

odczytu i zapisu plików;  używanie pickle w celu przechowywania obiektu na dysku;  importowanie i używanie bibliotek;  definiowanie i używanie funkcji, m.in. zwykłych funkcji oraz funkcji lambda;  wyrażenia regularne w Pythonie;  używanie list rozszerzonych.

Wiele narzędzi systemu Linux powstało w języku Python. W rozdziale 12. przedstawiono podstawy programowania w Pythonie i pewne podstawowe koncepcje programowania zorientowanego obiektowo w tym języku. Dzięki lekturze będziesz rozumiał działanie programów utworzonych w Pythonie, potrafił je czytać, a nawet tworzył własne. W rozdziale przedstawiono wiele przykładowych programów utworzonych w języku Python.  Rozdział 13. Baza danych MySQL W tym rozdziale przedstawiono dość powszechnie używaną relacyjną bazę danych MySQL. W rozdziale poruszono następujące tematy:  terminologia związana z systemami relacyjnych baz danych (RDBMS);  instalacja serwera i klienta MySQL;  tworzenie bazy danych;  dodawanie użytkowników;  tworzenie i modyfikowanie tabel;  wstawianie danych do bazy danych;  tworzenie kopii zapasowej i przywracanie bazy danych z wcześniej utworzonej kopii

zapasowej.  Rozdział 14. Język przetwarzania wzorców AWK

W tym rozdziale dowiesz się, jak wykorzystać oferujący potężne możliwości język AWK do tworzenia programów filtrujących dane, generujących raporty i pobierających dane z internetu. W punkcie dotyczącym programowania zaawansowanego pokazano, jako skonfigurować komunikację dwukierunkową z innym programem z użyciem koprocesu oraz jak pobierać dane wejściowe z internetu zamiast z pliku lokalnego.

Kluczowe zagadnienia omawiane w tej książce  37

 Rozdział 15. Edytor sed

W tym rozdziale przedstawiono nieinteraktywny edytor strumieni sed, który przez wiele aplikacji jest wykorzystywany w skryptach powłoki jako filtr. Z lektury rozdziału dowiesz się, jak używać buforów sed do tworzenia prostych, ale oferujących potężne możliwości programów. W rozdziale znajdziesz wiele przykładów zastosowania edytora sed.

CZĘŚĆ V — NARZĘDZIA BEZPIECZNEJ SIECI W części V przedstawiono dwa narzędzia, które można wykorzystać do pracy ze zdalnymi systemami oraz do bezpiecznego kopiowania plików poprzez sieć.  Rozdział 16. Narzędzie rsync służące do bezpiecznego kopiowania plików

W tym rozdziale prezentujemy narzędzie rsync pozwalające na kopiowanie zwykłych plików lub hierarchii katalogów zarówno lokalnie, jak i pomiędzy systemami lokalnym i zdalnym. Wymienione narzędzie można wykorzystać także do wykonywania kopii zapasowej plików w innym systemie.  Rozdział 17. OpenSSH — bezpieczna komunikacja sieciowa

W tym rozdziale dowiesz się, jak używać narzędzi ssh, scp i sftp do prowadzenia bezpiecznej komunikacji w internecie. Omówiono tutaj temat stosowania kluczy autoryzacji, dzięki którym można bezpiecznie zalogować się w zdalnym systemie bez konieczności podawania hasła. Przedstawiono także narzędzie ssh-agent przechowujące klucze prywatne podczas pracy oraz omówiono temat przekazywania X11, co pozwala na zdalne uruchamianie programów wyposażonych w interfejsy graficzne.

CZĘŚĆ VI — POLECENIA SYSTEMU LINUX System Linux zawiera setki narzędzi. W rozdziałach 14., 15., 16., 17. oraz w części VI dość dokładnie przedstawiono sposób użycia ponad stu najważniejszych narzędzi, dzięki którym możesz rozwiązywać problemy bez konieczności uciekania się do programowania w języku C. Jeżeli masz doświadczenie w pracy z systemem UNIX lub Linux, wówczas ta część książki będzie dla Ciebie niezwykle cennym i łatwym w użyciu przewodnikiem. Z kolei dla początkujących użytkowników stanie się użytecznym suplementem pomagającym w opanowaniu materiału przedstawionego we wcześniejszych częściach książki. Wprawdzie znajdujące się w rozdziałach 14., 15., 16., 17. oraz w części VI opisy narzędzi przedstawiono w formacie podobnym do używanego na stronach podręcznika systemu Linux (man), ale jednak są znacznie łatwiejsze do czytania i zostały napisane bardziej zrozumiałym językiem. Powody dokładnego omówienia poszczególnych narzędzi są różne: używasz ich w codziennej pracy (np. ls i cp), są narzędziami o potężnych możliwościach, które pozostają szczególnie użyteczne w skryptach powłoki (np. sort, paste i test), pomagają w pracy z systemem Linux (np. ps, kill i fsck) lub pozwalają na komunikację z innymi systemami (np. ssh, scp i ftp). Każdy opis narzędzia zawiera pełne objaśnienie najużyteczniejszych opcji danego narzędzia, a także wskazuje ewentualne różnice w jego działaniu na platformach Linux i OS X. Ponadto w punktach „Analiza” i „Uwagi” przedstawiono wskazówki i podpowiedzi pozwalające na pełne wykorzystanie możliwości danego narzędzia. Punkt „Przykłady” zawiera przykłady użycia narzędzia w rzeczywistych sytuacjach, zarówno samodzielnie, jak i w połączeniu z innymi narzędziami np. do wygenerowania raportu, podsumowania danych bądź wyodrębnienia informacji. Spójrz na punkt „Przykłady” w opisach narzędzi find, ftp i sort, a przekonasz się, jak rozbudowane mogą być to punkty. Omówienie pewnych narzędzi, takich jak Midnight Commander (mc) i screen, zawiera obszerne punkty „Analiza” i rozbudowane przykłady.

38  WSTĘP

CZĘŚĆ VII — DODATKI W części VII znajdziesz dodatki, słowniczek i trzy skorowidze.  Dodatek A — Wyrażenia regularne

W tym dodatku wyjaśniono, jak używać wyrażeń regularnych, aby w pełni wykorzystać ukryte możliwości systemu Linux. Wiele narzędzi, m.in. grep, sed, vim, AWK, Perl i Python, akceptuje wyrażenia regularne użyte zamiast zwykłych ciągów tekstowych. Nawet proste wyrażenie regularne może dopasować wiele zwykłych ciągów tekstowych.  Dodatek B — Pomoc

W tym dodatku szczegółowo przedstawiono kroki, które najczęściej prowadzą do rozwiązania problemów napotykanych podczas pracy w systemie Linux.  Dodatek C — Uaktualnianie systemu Z rozdziału dowiesz się, jak używać narzędzi przeznaczonych do pobierania oprogramowania i uaktualniania systemu. W dodatku poruszono następujące tematy:  yum — pobieranie oprogramowania z internetu, uaktualnianie systemu oraz rozwiązywanie

wszelkich problemów związanych z zależnościami pakietów;  apt-get — alternatywne dla yum narzędzie, które również pozwala na uaktualnianie

systemu;  BitTorrent — dobre rozwiązanie w zakresie rozprowadzania ogromnych ilości danych, np.

obrazów instalacyjnych dystrybucji systemu Linux.  Dodatek D — Uwagi dotyczące systemu OS X

W tym dodatku znajduje się krótki opis funkcji systemu OS X, a także podpowiedzi dla użytkowników używających systemu Linux bądź innych odmian systemu UNIX.  Słowniczek Słowniczek zawiera definicję ponad 500 terminów związanych z używaniem systemów Linux i OS X.  Skorowidz

Tutaj umieszczono indeks, dzięki któremu możesz łatwiej i szybciej znaleźć szukane informacje.

Dodatki  39

DODATKI Na stronie domowej autora tej książki (http://www.sobell.com) znajdziesz szereg gotowych do pobrania przykładów i dłuższych programów z oryginalnej, angielskiej wersji tej książki, odwołania do wielu ciekawych stron internetowych poświęconych systemom Linux i OS X, erratę, odpowiedzi do ćwiczeń, komentarze oraz sugestie. Prezentacje w formacie PowerPoint zawierające rysunki przedstawione w książce oraz odpowiedzi do pytań umieszczonych na końcu rozdziałów są dostępne dla nauczycieli prowadzących zajęcia w klasach. Jeśli chcesz otrzymać wspomniane materiały, skontaktuj się z przedstawicielem wydawnictwa Pearson.

PODZIĘKOWANIA Po pierwsze i najważniejsze, na moje podziękowania zasługuje Mark L. Taub, redaktor wydawnictwa Prentice Hall, który wspierał mnie i pomagał w trudnych chwilach pracy nad tą książką. Mark jest prawdziwym unikatem w całej mojej 30-letnie karierze autora książek — to redaktor, który pracuje z narzędziami, o których piszę książki. Ponieważ Mark używa systemu Linux na swoim komputerze domowym, podczas pracy nad tą książką mogliśmy się wymieniać doświadczeniami. Mark, Twoje komentarze i wskazówki były bezcenne; ta książka nie mogłaby powstać bez Twojego udziału. Dziękuję! Podziękowania kieruję do wspaniałych ludzi z wydawnictwa Prentice Hall, z którymi miałem przyjemność pracować: Julie Nahil, kierownik produkcji, która pracowała ze mną dzień po dniu, nadając tej książce ostateczny kształt, podczas gdy John Fuller, redaktor prowadzący, patrzył na całość z szerszej perspektywy i popychał nas we właściwym kierunku. Podziękowania dla Jill Hobbs i Audrey Doyle, korektorów, którzy cyzelowali każdą stronę i pracowicie poprawiali błędy poczynione przez autora. Dziękuję również wszystkim innym pracownikom wydawnictwa Prentice Hall, którzy przyczynili się do powstania tej książki, a byli to: Kim Boedigheimer, która zajmowała się tymi wszystkimi drobnymi, ale jakże istotnymi sprawami, które muszą się wydarzyć, aby książka mogła się pojawić, Heather Fox (specjalista od reklamy), Stephane Nakib (menedżer marketingu), Cheryl Lenser (starszy specjalista od indeksów), Sandra Schroeder (menedżer projektu graficznego), Chuti Prasertsith (projektant okładki) i wszystkim innym, którzy często będąc na drugim planie, ciężko pracowali nad tym, aby niniejsza książka ujrzała światło dzienne. Podziękowania należą się również Denisowi Howe, twórcy portalu The Free On-Line Dictionary of Computing (FOLDOC). Denis wspaniałomyślnie zezwolił mi na używanie w tej książce haseł z jego słownika. Naprawdę powinieneś zajrzeć na stronę http://foldoc.org. Wielkie podziękowania składam również innym osobom Byli to: Max Sobell z firmy Intrepidus Group, który pomógł mi w pracach nad rozdziałem przedstawiającym język Python; Doug Hellmann, starszy programista z DreamHost, któremu dziękuję za jego użyteczne i wnikliwe uwagi dotyczące rozdziału przedstawiającego język Python; Angjoo Kanazawa, student na uniwersytecie University of Maryland, któremu dziękuję za pomocne komentarze. Podziękowania składam również Grahamowi Lee, programiście aplikacji mobilnych i konsultantowi z zakresu bezpieczeństwa oprogramowania, oraz Davidowi Chisnallowi z University of Cambridge — za ich wnikliwe przejrzenie i uwagi dotyczące fragmentów książki poświęconych systemowi OS X. W swoich komentarzach Jeffrey S. Haemer nauczył mnie wielu sztuczek w powłoce bash. Nawet nie miałem pojęcia, na ile sposobów można wykorzystać tę powłokę. Jeffrey, jesteś mistrzem, dziękuję Ci za pomoc.

40  WSTĘP Jennifer Davis (Yahoo! Sherpa Service Engineering Team Lead) dostarczyła dużo użytecznych komentarzy dotyczących wielu sekcji książki i podzieliła się ze mną swoją wiedzą o bazie danych MySQL, co doprowadziło do zmiany wielu aspektów w rozdziale poświęconym MySQL. Wielkie podziękowania składam również wszystkim, którzy czytali pierwsze, robocze wersje tej książki i nadsyłali komentarze, które pozwoliły mi wyprostować pewne nieporozumienia czy wyjaśnić rzeczy, które niepotrzebnie zagmatwałem. Byli to: Michael Karpeles; Robert P.J. Day, Candy Strategies; Gavin Knight, Noisebridge; Susan Lauber, Lauber System Solutions, Inc.; William Skiba; Carlton „Cobolt” Sue; Rickard Kökkö, Bolero AB; oraz Benjamin Schupak. Dziękuję również wszystkim ludziom, którzy pracowali ze mną nad moimi poprzednimi książkami o systemie Linux i przyczynili się do powstania fundamentów, na których powstała niniejsza książka. Byli to: Doug Hughes, Richard Woodbury, inżynier z firmy Google, Max Sobell z firmy Intrepidus Group; Lennart Poettering z firmy Red Hat, Inc.; George Vish II, starszy konsultant do spraw szkoleń z firmy Hewlett-Packard; Matthew Miller, analityk systemowy i administrator projektu BU Linux, prowadzonego przez Boston University Office of Information Technology; Garth Snyder, Nathan Handler, Dick Seabrook (profesor emerytowany), Anne Arundel z Community College, Chris Karr z firmy Audacious Software oraz Scott McCrea, instruktor z ITT Technical Schools, John Dong, Ubuntu Developer i Forums Council Member; Andy Lester, autor książki Land the Tech Job You Love: Why Skill and Luck Are Not Enough; Scott James Remnant, Ubuntu Development Manager i Desktop Team Leader; David Chisnall, Swansea University; Scott Mann, Aztek Networks; Thomas Achtemichuk, Mansueto Ventures; Daniel R. Arfsten, projektant Pro/ENGINEER; Chris Cooper, Senior Education Consultant, Hewlett-Packard Education Services; Sameer Verma, Associate Professor of Information Systems, San Francisco State University; Valerie Chau, Palomar College and Programmers Guild; James Kratzer; Sean McAllister; Nathan Eckenrode, New York Ubuntu Local Community Team; Christer Edwards; Nicolas Merline; Michael Price; Mike Basinger, Ubuntu Community and Forums Council Member; Joe Barker, Ubuntu Forums Staff Member; James Stockford, Systemateka, Inc.; Stephanie Troeth, Book Oven; Doug Sheppard; Bryan Helvey, IT Director, OpenGeoSolutions i wreszcie Vann Scott, Baker College of Flint. Na podziękowania zasłużyli również Jesse Keating, Fedora Project; Carsten Pfeiffer, Software Engineer i KDE Developer; Aaron Weber, Ximian; Cristof Falk, Software Developer firmy CritterDesign; Steve Elgersma, Computer Science Department, Princeton University; Scott Dier, University of Minnesota; Robert Haskins, Computer Net Works; Lars Kellogg-Stedman, Harvard University; Jim A. Lola, Principal Systems Consultant, Privateer Systems; Eric S. Raymond, Cofounder, Open Source Initiative; Scott Mann; Randall Lechlitner, Independent Computer Consultant; Jason Wertz, Computer Science Instructor, Montgomery County Community College; Justin Howell, Solano Community College; Ed Sawicki, The Accelerated Learning Center; David Mercer; Jeffrey Bianchine, adwokat, autor i dziennikarz; John Kennedy oraz Jim Dennis, Starshine Technical Services. Podobnie na podziękowania zasłużyli: Dustin Puryear, Puryear Information Technology; Gabor Liptak, Independent Consultant; Bart Schaefer, Chief Technical Officer, iPost; Michael J. Jordan, Web Developer, Linux Online; Steven Gibson, Owner, SuperAnt.com; John Viega, założyciel i szef, Secure Software; K. Rachael Treu, Internet Security Analyst, Global Crossing; Kara Pritchard, K & S Pritchard Enterprises; Glen Wiley, Capital One Finances; Karel Baloun, Senior Software Engineer, Looksmart; Matthew Whitworth; Dameon D. Welch-Abernathy, Nokia Systems; Josh Simon, Consultant; Stan Isaacs oraz dr Eric H. Herrin II, Vice President, Herrin Software Development. Kolejne podziękowania kieruję do następnej grupy wspaniałych ludzi. Byli to: konsultanci Lorraine Callahan i Steve Wampler; Ronald Hiller, Graburn Technology; Charles A. Plater, Wayne State University; Bob Palowoda; Tom Bialaski, Sun Microsystems; Roger Hartmuller, TIS Labs at Network Associates; Kaowen Liu; Andy Spitzer; Rik Schneider; Jesse St. Laurent; Steve Bellenot; Ray W. Hiltbrand; Jennifer Witham; Gert-Jan Hagenaars oraz Casper Dik.

Podziękowania  41

Niniejsza książka jest oparta na dwóch moich poprzednich książkach o systemie UNIX: UNIX System V: A Practical Guide oraz A Practical Guide to the UNIX System. Wielu ludzi pomagało mi przy pracy nad powstaniem tych książek, stąd moje szczere podziękowania dla nich wszystkich. Byli to m.in.: Pat Parseghian; dr Kathleen Hemenway; Brian LaRose; Byron A. Jeff, Clark Atlanta University; Charles Stross; Jeff Gitlin, Lucent Technologies; Kurt Hockenbury; Maury Bach, Intel Israel; Peter H. Salus; Rahul Dave, University of Pennsylvania; Sean Walton, Intelligent Algorithmic Solutions; Tim Segall, Computer Sciences Corporation; Behrouz Forouzan, DeAnza College; Mike Keenan, Virginia Polytechnic Institute and State University; Mike Johnson, Oregon State University; Jandelyn Plane, University of Maryland; Arnold Robbins i Sathis Menon, Georgia Institute of Technology; Cliff Shaffer, Virginia Polytechnic Institute and State University oraz Steven Stepanek, California State University, Northridge, który zrecenzował tę książkę. Jestem również niesamowicie wdzięczny wszystkim ludziom, którzy pomagali mi przy pracy nad wcześniejszymi wydaniami moich książek o systemie UNIX. Specjalne podziękowania kieruję do Rogera Sippla, Laury King i Roya Harringtona za wprowadzenie mnie w tajniki systemu UNIX. Moja mama, dr Helen Sobel, dostarczała mi bezcennych komentarzy i rad do pierwszych wersji tej książki. Na podziękowania zasłużyli również Isaac Rabinovitch, profesor Raphael Finkel, profesor Randolph Bentson, Bob Greenberg, profesor Udo Pooch, Judy Ross, dr Robert Veroff, dr Mike Denny, Joe DiMartino, dr John Mashey, Diane Schulz, Robert Jung, Charles Whitaker, Don Cragun, Brian Dougherty, dr Robert Fish, Guy Harris, Ping Liao, Gary Lindgren, dr Jarrett Rosenberg, dr Peter Smith, Bill Weber, Mike Bianchi, Scooter Morris, Clarke Echols, Oliver Grillmeyer, dr David Korn, dr Scott Weikart oraz dr Richard Curtis. Biorę pełną odpowiedzialność za wszelkie błędy i nieścisłości, jakie znalazły się w tej książce. Jeżeli znajdziesz jakiś błąd lub po prostu chcesz podzielić się swoimi wrażeniami, napisz do mnie na adres [email protected], a ja spróbuję poprawić błędy lub skorzystać z propozycji w kolejnej edycji tej książki. Na mojej stronie domowej http://www.sobell.com znajdziesz listę znalezionych do tej pory błędów wraz z informacjami o osobach, które je znalazły. Znajdziesz tam również gotowe do pobrania kopie dłuższych skryptów z tej książki oraz odwołania do ciekawych stron internetowych zajmujących się systemem Linux. Znajdziesz mnie również na Twitterze, pod adresem http://twitter.com/marksobell. Mark G. Sobell San Francisco, Kalifornia

42  WSTĘP

1 Witamy w systemach Linux i OS X

W TYM ROZDZIALE: Historia systemów UNIX oraz GNU-Linux UNIX — protoplasta systemu Linux Dlaczego Linux jest tak wspaniały? Przegląd systemu Linux Dodatkowe mechanizmy systemu Linux

CELE ROZDZIAŁU Po przeczytaniu tego rozdziału będziesz mógł:  Dyskutować na temat historii systemów UNIX i Linux oraz projektu GNU  Wyjaśnić, co oznacza pojęcie „wolne oprogramowanie” i omówić najważniejsze postanowienia Powszechnej Licencji Publicznej GNU (ang. General Public License)  Przedstawić charakterystykę systemu Linux oraz podać powody, dla których system Linux jest tak popularny w świecie  Wymienić korzyści wynikające z używania maszyn wirtualnych zamiast fizycznych komputerów

44  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X System operacyjny to oprogramowanie tzw. niskiego poziomu (ang. low-level software), które umożliwia planowanie i wykonywanie zadań, alokowanie przestrzeni pamięci masowej i spełnia rolę interfejsu dla urządzeń zewnętrznych, takich jak drukarki, dyski twarde, monitor, klawiatura czy mysz. System operacyjny składa się z dwóch głównych elementów: jądra systemu (ang. kernel) oraz programów systemowych. Jądro systemu jest odpowiedzialne za alokowanie zasobów komputera, włącznie z zasobami pamięci operacyjnej, przestrzeni dyskowej i cyklami procesora dla wszystkich uruchomionych programów. W skład programów systemowych wchodzą między innymi sterowniki urządzeń, biblioteki systemowe, programy narzędziowe, powłoki (interpretery poleceń), skrypty konfiguracyjne i pliki, aplikacje, serwery i dokumentacja. Programy takie zapewniają poprawną pracę całego systemu, a często spełniają również role na przykład serwerów w konfiguracjach typu klient-serwer. Wiele bibliotek, serwerów i programów narzędziowych zostało utworzonych w ramach projektu GNU, o którym powiemy już za chwilę. Jądro systemu Linux zostało zaprojektowane przez fińskiego studenta, Linusa Torvaldsa, który za pośrednictwem sieci Internet udostępnił wszystkim zainteresowanym kod źródłowy swojego systemu. Torvalds opublikował pierwszą wersję systemu Linux, oznaczoną numerem 0.01, we wrześniu 1991.

Jądro systemu Linux

Stworzenie nowego systemu operacyjnego wymagało ogromnej ilości ciężkiej pracy. Programiści z całego świata szybko podjęli wyzwanie i rozpoczęli modyfikowanie jądra systemu, rozszerzając jego funkcjonalność i tworząc nowe narzędzia i mechanizmy, a także dodając funkcje, które do tej pory były spotykane w takich systemach jak BSD UNIX czy System V UNIX (SVR4). Nazwa Linux powstała jako kombinacja imienia autora — Linus — oraz nazwy systemu UNIX. System operacyjny Linux, który powstał dzięki wspólnej pracy ogromnej rzeszy ludzi na całym świecie, jest produktem sieci Internet i jednocześnie jest wolnym systemem operacyjnym. Oznacza to, że jego kod źródłowy jest dostępny dla każdego zainteresowanego. Każdy użytkownik ma pełne prawo do przeglądania tego kodu, rozpowszechniania i modyfikowania w dowolny sposób. W rezultacie takiego podejścia kod źródłowy systemu Linux jest dostępny całkowicie za darmo — nie musisz płacić za oprogramowanie, kod źródłowy, dokumentację ani wsparcie techniczne (które w tej sytuacji jest świadczone poprzez grupy i listy dyskusyjne oraz inne źródła internetowe). W definicji wolnego oprogramowania (ang. GNU Free Software Definition), stwierdza się, co następuje: „Wolne oprogramowanie” to kwestia wolności, nie ceny. By zrozumieć tę koncepcję, powinieneś myśleć o „wolności słowa”, a nie „darmowym piwie”.1

Darmowe piwo…

W systemie OS X używane jest jądro Mach, które zostało opracowane na uniwersytecie Carnegie Mellon University (CMU) i udostępnione jako bezpłatne oprogramowanie. CMU prowadził prace nad projektem do roku 1994, następnie prace były prowadzone przez inne grupy. Większość oprogramowania OS X jest typu open source: jądro OS X oparte jest na jądrze Mach i kodzie FreeBSD, narzędzia pochodzą z projektów BSD i GNU, programy systemowe powstały w większości na bazie kodu BSD, choć firma Apple opracowała wiele nowych programów.

Jądro Mach

WSKAZÓWKA Linux, OS X i UNIX Linux i OS X są bardzo blisko związane z systemem operacyjnym UNIX. W niniejszej książce opisano systemy Linux i OS X. Aby zachować czytelność, termin „Linux” jest stosowany w odniesieniu zarówno do systemu Linux, jak i OS X. Wszelkie różnice pomiędzy wymienionymi systemami są wyraźnie oznaczone. Z tego samego powodu w tym rozdziale termin „Linux” jest bardzo często stosowany do opisania funkcji zarówno Linux, jak i OS X.

1

Ang. free oznacza „wolny”, „swobodny”, ale może też oznaczać „darmowy” — przyp. tłum.

Historia systemów UNIX oraz GNU-Linux  45

HISTORIA SYSTEMÓW UNIX ORAZ GNU-LINUX W tej sekcji omówimy pewne zagadnienia stanowiące tło dla relacji pomiędzy systemem UNIX a systemem Linux oraz pomiędzy GNU a systemem Linux. Dokładne omówienie historii systemu UNIX znajdziesz na stronie http://www.levenez.com/unix/.

UNIX — PROTOPLASTA SYSTEMU LINUX System UNIX został zaprojektowany przez krąg badaczy, którzy w swoich projektach naukowych chcieli korzystać z nowoczesnych narzędzi i symulacji komputerowych. System będący rezultatem ich pracy pozwalał grupie użytkowników na korzystanie ze współużytkowanych zasobów danych oraz programów, ale jednocześnie zapewniał odpowiedni poziom zabezpieczeń i możliwość bezpiecznego przechowywania prywatnych danych. W rosnącej gwałtownie popularności nowego systemu operacyjnego znaczącą rolę odegrało wiele uniwersytetów i szkół wyższych. Kiedy w roku 1975 system UNIX stał się szeroko dostępny, Bell Labs zaoferowało instytucjom edukacyjnym możliwość zakupu tego systemu po bardzo atrakcyjnych cenach. Dzięki takiemu rozwiązaniu szkoły zaczęły używać systemu UNIX w swoich pracowniach komputerowych i uwzględniać go w programach nauczania, dzięki czemu absolwenci takich szkół po zakończeniu edukacji mogli się wykazać znajomością tego systemu. Ponieważ UNIX był zaawansowanym systemem operacyjnym, studenci szybko oswajali się z pracą w takim złożonym środowisku programistycznym. Później już jako absolwenci trafiali do różnych firm i korporacji, gdzie spodziewali się znaleźć równie zaawansowane rozwiązania. W miarę jak wielu z nich trafiało na coraz wyższe stanowiska w świecie komercyjnym, system UNIX zaczął coraz szybciej przecierać ścieżki i coraz bardziej umacniać swoją pozycję w zastosowaniach biznesowych. Oprócz tego, że Bell Labs udostępniła system UNIX studentom, Computer Systems Research Group (CSRG), czyli informatyczna placówka badawczo-rozwojowa Uniwersytetu Kalifornijskiego Berkeley wprowadziła do tego systemu bardzo wiele znaczących zmian i dodatków. O skali i popularności tych modyfikacji świadczy prosty fakt, że jedna z wersji systemu nosi nazwę Berkeley Software Distribution of the system UNIX (w skrócie BSD UNIX). Inną popularną odmianą systemu UNIX jest UNIX System V (SVR4), który powstał na bazie wersji rozwijanych i wspieranych przez AT&T oraz UNIX System Laboratories. Korzenie OS X sięgają wspomnianego systemu BSD.

Berkeley UNIX (BSD)

ZASTÓJ DO ROKU 1983 Richard Stallman (www.stallman.org) oficjalnie ogłosił rozpoczęcie projektu GNU2, mającego na celu utworzenie wolnego systemu operacyjnego składającego się z jądra i programów systemowych, oraz przedstawił Manifest GNU3, który rozpoczynał się następującymi słowami: „GNU, czyli GNU to Nie Unix (ang. GNU’s Not Unix), jest nazwą kompletnego, kompatybilnego z Uniksem systemu, który piszę, aby potem móc rozdawać go każdemu, kto zechce zacząć go używać”. Kilka lat później, kiedy Stallman zorientował się, że jego słowa mogły zostać nieco inaczej zrozumiane, dodał do oryginalnego tekstu kilka przypisów, w tym jeden odnoszący się do tekstu przedstawionego powyżej:

2

3

Oryginał: http://www.gnu.org/gnu/initial-announcement.html, polską wersję tego dokumentu znajdziesz na stronie http://www.gnu.org/gnu/initial-announcement.pl.html — przyp. tłum. Oryginał: http://www.gnu.org/gnu/manifesto.html, polską wersję tego dokumentu znajdziesz na stronie http://www.gnu.org/gnu/manifesto.pl.html — przyp. tłum.

46  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X „W tym miejscu użycie słów było niedbałe. Tekst miał mówić, że nikt nie będzie musiał płacić za pozwolenie na używanie GNU. Ale słowa nie wyrażają tego jasno, więc ludzie często interpretują ten fragment jako mówiący, że kopie GNU zawsze powinny być dystrybuowane za niewielką opłatą lub za darmo. To nigdy nie było naszą intencją; później manifest wspomina o możliwości istnienia firm świadczących usługi dystrybucji za opłatą. Z czasem nauczyłem się starannie rozróżniać pomiędzy „wolnym” oprogramowaniem i oprogramowaniem „darmowym”. Wolne oprogramowanie to takie oprogramowanie, które użytkownicy mogą swobodnie rozpowszechniać i zmieniać. Niektórzy użytkownicy mogą uzyskać kopie za darmo, a niektórzy za nie płacą — jeśli zebrane w ten sposób środki pomogą ulepszyć oprogramowanie, to tym lepiej. Ważne jest, że każdy, kto ma kopię, może swobodnie współpracować z innymi użytkownikami”. W swoim manifeście, po krótkim wyjaśnieniu założeń projektu oraz podsumowaniu dotychczasowych osiągnięć, Stallman kontynuuje: „Dlaczego muszę napisać GNU Uważam, że złota zasada wymaga, żebym programem, który mi się podoba, podzielił się z innymi, którym też się spodobał. Sprzedawcy oprogramowania chcą podzielić użytkowników i nad nimi zapanować poprzez zmuszanie ich, by zgodzili się nie dzielić zakupionym oprogramowaniem. Odmawiam zerwania solidarności z innymi użytkownikami w taki sposób. Nie mogę z czystym sumieniem podpisać umowy o poufności lub umowy licencyjnej. Przez długie lata pracując w AI Lab [Laboratorium Sztucznej Inteligencji w Massachussets Institute of Technology], starałem się oprzeć takim tendencjom i innym tego typu działaniom, ale w końcu stały się one zbyt daleko posunięte: nie mogłem pozostać w instytucji, w której robi mi się takie rzeczy wbrew mojej woli. Aby nadal używać komputerów z honorem, zdecydowałem się zebrać razem wystarczającą ilość wolnego oprogramowania, żeby obejść się bez programów, które nie są wolne. Odszedłem z AI Lab, żeby odebrać MIT wszelkie prawne preteksty do powstrzymania mnie przed rozdawaniem GNU”.

KOLEJNA ODSŁONA, ROK 1991 Projekt GNU rozwijał się pomyślnie i stopniowo realizował założone cele. Większość systemu operacyjnego GNU, z wyjątkiem jądra, jest już kompletna. Richard Stallman napisał później: „We wczesnych latach 90. poskładaliśmy cały system, z wyjątkiem jądra. Zaczęliśmy również pisać jądro, GNU Hurd4, które działało na mikrojądrze Mach5. Zaprojektowanie jądra było jednak trudniejsze, niż się spodziewaliśmy6. (…) wielu ludzi wierzy, że gdy Linus Torvalds zakończył pisanie jądra systemu Linux, jego przyjaciele zaczęli poszukiwać innego wolnego oprogramowania i szybko okazało się, że bez żadnej szczególnej przyczyny prawie wszystko niezbędne do stworzenia systemu podobnego do systemu UNIX było już dostępne. To, co znaleźli, nie było przypadkowe — był to po prostu system GNU. Dostępne wolne oprogramowanie7 było dołączane do kompletnego systemu, ponieważ Projekt GNU był rozwijany już od 1984 roku. W Manifeście GNU ustaliliśmy jako cel stworzenie wolnego systemu operacyjnego, podobnego do systemu UNIX i noszącego nazwę GNU. Pierwsze ogłoszenie Projektu GNU przedstawia również pierwotne plany dotyczące systemu GNU. W czasie, kiedy prace nad systemem Linux dopiero się rozpoczynały, system GNU był prawie ukończony8”. 4 5 6 7

8

Patrz http://www.gnu.org/software/hurd/hurd.html. Patrz http://www.gnu.org/s/hurd/microkernel/mach/gnumach.html. Patrz http://www.gnu.org/software/hurd/hurd-and-linux.html. Patrz dodatek D lub strona http://www.gnu.org/philosophy/free-sw.html (polską wersję znajdziesz na stronie http://www.gnu.org/philosophy/free-sw.pl.html) — przyp. tłum. Patrz http://www.gnu.org/gnu/linux-and-gnu.html (polską wersję znajdziesz na stronie http://www.gnu.org/gnu/ linux-and-gnu.pl.html) — przyp. tłum.

Historia systemów UNIX oraz GNU-Linux  47

Obecnie „system operacyjny” GNU działa na bazie jądra systemów FreeBSD (http://www.freebsd.org/) oraz NetBSD (http://www.netbsd.org/) z zachowaniem pełnej kompatybilności binarnej z systemem Linux oraz na bazie wczesnych wersji jądra Hurd oraz Darwin (http://developer.apple.com/opensource/) bez zachowania tej kompatybilności.

KOD ŹRÓDŁOWY JEST POWSZECHNIE DOSTĘPNY Tradycje wolnego oprogramowania sięgają daleko wstecz do czasów, kiedy system UNIX był udostępniany za niewielkimi opłatami instytucjom edukacyjnym, co z pewnością przyczyniło się do jego popularności, łatwości przenoszenia na inne platformy i sukcesów. Ta piękna tradycja skończyła się w momencie, kiedy system UNIX został skomercjalizowany i producenci zaczęli traktować jego kod źródłowy jako swoją własność intelektualną, co spowodowało, że kod przestał być dostępny dla każdego. Innym problemem z komercyjnymi wersjami systemu UNIX była ich złożoność. Ponieważ niemal każdy z producentów optymalizował swoją wersję systemu UNIX do działania na określonej architekturze sprzętowej, system operacyjny stawał się coraz trudniejszy w przenoszeniu na inne platformy i coraz bardziej nieporęczny, aby stać się wygodną platformą dla nauczania i eksperymentowania. Dwóch profesorów utworzyło swoje własne, okrojone wersje systemu UNIX, przeznaczone do celów edukacyjnych. Byli to Doug Comer, który był autorem systemu o nazwie XINU, oraz Andrew Tanenbaum, który utworzył system MINIX. Linus Torvalds napisał system Linux między innymi po to, aby zneutralizować niedociągnięcia i błędy, jakie można było znaleźć w systemie MINIX. Za każdym razem był to wybór pomiędzy prostotą kodu źródłowego a efektywnością i funkcjonalnością całego systemu. Tanenbaum wybierał prostotę (dzięki czemu nauczanie studentów przy użyciu tego systemu było łatwiejsze), co jednak oznaczało brak wielu funkcji i mechanizmów, których oczekiwało wielu innych użytkowników. Linux poszedł w zupełnie innym kierunku.

MINIX

System Linux możesz pobrać zupełnie za darmo z sieci Internet. W razie problemów z połączeniem z siecią Internet możesz również w wielu firmach za niewielką opłatą (pokrywającą zazwyczaj tylko koszty nośników i przesyłki) zamówić gotowe nośniki instalacyjne. Jeżeli chcesz, możesz wspomóc finansowo fundację FSF (ang. Free Software Fundation; http://www.fsf.org/) i zamówić tam pakiety oprogramowania, możesz wreszcie kupić całkowicie komercyjne wydania systemu Linux (nazywane dystrybucjami), takie jak Fedora/RHEL, openSUSE, Debian i Ubuntu, gdzie w cenę pakietów wliczona jest dokumentacja, oprogramowanie i wsparcie techniczne. System Linux oraz oprogramowanie GNU są rozpowszechniane na warunkach Powszechnej Licencji Publicznej GNU (ang. GPL — General Public License; www.gnu.org/licenses/licenses.html, polską wersję znajdziesz na stronie http://gnu.org.pl/text/licencja-gnu.html). Licencja GPL stwierdza, że masz prawo do kopiowania, modyfikacji i rozpowszechniania kodu objętego taką licencją. Jeżeli chcesz rozpowszechniać kod, musisz do każdej jego kopii dołączyć kopię tej licencji, czyli inaczej mówiąc, kod i licencja są w takiej sytuacji nierozdzielne. Jeżeli z sieci Internet pobierzesz kod źródłowy aplikacji księgowej, który jest objęty licencją GPL, a następnie dokonasz modyfikacji tego kodu i chcesz rozpowszechniać skompilowaną wersję poprawionej aplikacji, to pamiętaj, że razem z nią musisz dołączyć kompletny kod źródłowy oraz kopię licencji GPL. Ponieważ takie warunki licencji są całkowitym przeciwieństwem sposobu działania normalnych praw autorskich (taka licencja daje Ci prawa, zamiast je ograniczać), to takie prawa przyjęło się określać terminem copyleft9. Pamiętaj, że ten akapit nie jest kompletną, prawniczą wykładnią postanowień licencji GPL; naszą intencją było tylko zarysowanie ogólnej idei sposobu działania takiej licencji. Jeżeli chcesz korzystać z licencji GPL, powinieneś bardzo dokładnie zapoznać się z jej treścią.

GPL

9

Nieprzetłumaczalna gra słów, ang. copyright oznacza prawa autorskie, podczas gdy ang. copyleft oznacza zrzeczenie się roszczeń z tytułu prawa autorskiego. Gra słów odnosi się do członów right (prawo) i left (lewo), oznaczających dwa przeciwstawne kierunki — przyp. tłum.

48  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X

BAW SIĘ DOBRZE! Najważniejsze słowa kluczowe związane z używaniem systemu Linux brzmią jak w tytule: „Baw się dobrze!” (ang. Have fun!). Słowa te pojawiają się zarówno w wielu aplikacjach i programach, jak i w dokumentacji. Kultura systemu UNIX — a obecnie systemu Linux — jest przesiąknięta humorem, który objawia się czasami w najmniej oczekiwanych sytuacjach. Na przykład odpowiednikiem UNIXowego polecenia more (ang. więcej) w systemie GNU jest bardziej rozbudowane i funkcjonalne polecenie less (ang. mniej). W systemie GNU narzędzie do przeglądania dokumentów typu PostScript nosi nazwę ghostscript, a jeden z wielu zamienników popularnego edytora vi nosi nazwę elvis. Na wielu komputerach z procesorem Intel możemy znaleźć nalepkę ze znanym skądinąd logo Intel inside, podczas gdy często na komputerach z systemem Linux możemy zobaczyć bardzo podobną nalepkę z radosnym przesłaniem Linux inside. Warto również wspomnieć, że koszulkę z logo Linus inside często nosił sam Linus Torvalds.

DLACZEGO LINUX JEST TAK WSPANIAŁY? W ostatnich latach Linux jawi się jako silny, dojrzały i innowacyjny system operacyjny, mający swoje korzenie w systemie UNIX. Jego popularność już dawno znacząco przekroczyła wyniki, jakie kiedykolwiek osiągnęli jego UNIX-owi przodkowie. Chociaż na wiele sposobów Linux naśladuje działanie systemu UNIX, to jednak w kilku kluczowych zagadnieniach różnice są bardzo znaczące. Po pierwsze: jądro systemu Linux zostało zaimplementowane zupełnie niezależnie od systemów BSD i System V, po drugie: Linux ciągle się rozwija za sprawą ogromnej rzeszy programistów z całego świata, i wreszcie po trzecie: system Linux powoduje, że ogromne możliwości dotychczasowych implementacji systemu UNIX znalazły się w zasięgu nie tylko użytkowników biznesowych, ale również użytkowników prywatnych. Dzięki sieci Internet tysiące zdolnych programistów może przesyłać swoje poprawki, aktualizacje i nowe rozwiązania do Linusa Torvaldsa, projektu GNU czy twórców jednej z wielu innych, funkcjonujących na rynku dystrybucji systemu Linux. W roku 1985 przedstawiciele firm z sektora informatycznego zebrali się razem po raz pierwszy w celu opracowania standardu POSIX (ang. Portable Operating System Interface for Computer Environments), który jest w dużej mierze oparty na standardzie SVID (ang. UNIX System V Interface Definition) i innych opracowaniach standaryzacyjnych. Wiele z tych prac było inicjowanych przez agendy rządowe Stanów Zjednoczonych, którym potrzebne było standardowe środowisko komputerowe, umożliwiające minimalizację kosztów zakupów, wdrożeń i szkoleń. Opublikowany w roku 1988 standard POSIX jest w zasadzie grupą standardów IEEE, definiujących interfejs API systemu (ang. Application Programming Interface), powłokę oraz interfejsy narzędziowe systemu operacyjnego. POSIX został zaprojektowany z myślą o systemach klasy UNIX, ale w praktyce może odnosić się do każdego kompatybilnego systemu operacyjnego. Nowy standard szybko przyjął się na rynku i dzięki temu twórcy oprogramowania mogą łatwo tworzyć aplikacje, które będą działać na wszystkich zgodnych wersjach systemu UNIX, Linux i innych.

Standardy

Dla systemu Linux istnieje bogaty wybór aplikacji — zarówno płatnych, jak i tych darmowych — jak również ogromna ilość różnego rodzaju narzędzi graficznych, edytorów tekstu, narzędzi sieciowych, narzędzi związanych z bezpieczeństwem systemu, administracją, serwerami sieci WWW i innych. Wiele dużych i znanych firm zajmujących się tworzeniem oprogramowania szybko spostrzegło potencjał i zyski, jaki niesie ze sobą wsparcie systemu Linux, i zaczęło utrzymywać stałe zespoły programistów, których zadaniem jest tylko i wyłącznie projektowanie i tworzenie nowych wersji jądra systemu Linux, środowisk GNOME i KDE oraz innych aplikacji działających pod kontrolą systemu Linux. Na przykład jedną z takich firm mocno zaangażowanych we wsparcie systemu Linux jest IBM (patrz http://www.ibm.com/linux/). System Linux coraz bardziej zbliża się do pełnej zgodności ze standardem POSIX, a niektóre dystrybucje są częściowo lub nawet całkowicie zgodne z tym standardem.

Aplikacje

Dlaczego Linux jest tak wspaniały?  49

Wszystko to wskazuje na fakt, że system Linux już dawno wszedł do głównego nurtu systemów operacyjnych i zaczyna być postrzegany jako poważna i atrakcyjna alternatywa dla innych, popularnych systemów operacyjnych. Innym ważnym aspektem systemu Linux, który przemawia do potencjalnych użytkowników, jest ogromna ilość obsługiwanych urządzeń peryferyjnych i szybkość, z jaką pojawiają się sterowniki nowych urządzeń. Nowy sterownik danego urządzenia dla systemu Linux często pojawia się, jeszcze zanim producent tego urządzenia wypuści na rynek sterowniki dla innych systemów operacyjnych. Niestety w przypadku niektórych typów urządzeń peryferyjnych — a zwłaszcza w przypadku niektórych kart graficznych — wsparcie dla takich urządzeń pojawia się z pewnym opóźnieniem, ponieważ ich producenci nie udostępniają publicznie specyfikacji technicznej czy kodów źródłowych swoich sterowników.

Urządzenia peryferyjne

Kolejną, bardzo istotną z punktu widzenia użytkowników cechą systemu Linux jest ogromna ilość dostępnego oprogramowania — i to nie tylko w postaci kodów źródłowych (które przed użyciem muszą być skompilowane), ale również w postaci łatwych do zainstalowania i gotowych do użycia plików binarnych. Oprogramowanie dla systemu Linux to jednak coś znacznie więcej niż darmowe pakiety. Na przykład znana przeglądarka sieciowa Netscape była dostępna dla systemu Linux od samego początku i posiadała wsparcie dla języka Java, zanim takie wsparcie pojawiło się w wielu innych, komercyjnych produktach. Bliźniacze produkty ze stajni Mozilli, takie jak Thunderbird czy Firefox, są obecnie powszechnie znane i używane do przeglądania zasobów sieci WWW, odczytywania wiadomości poczty elektronicznej czy grup dyskusyjnych, a oprócz tego spełniają jeszcze wiele innych funkcji.

Oprogramowanie

System Linux może działać nie tylko na komputerach opartych na platformie Intel (która obejmuje obecnie również komputery Apple), ale został również przeniesiony na wiele innych platform, takich jak Power PC — włącznie ze starszymi modelami komputerów Apple (ppclinux), Alpha, na którym oparte są komputery Compaq (z domu DEC — ang. Digital Equipment Corporation), MIPS, Motorola 68k, IBM S/390 oraz wiele różnych platform 64-bitowych. Linux nie jest przeznaczony wyłącznie dla komputerów jednoprocesorowych — począwszy od jądra wersji 2.0, znakomicie radzi sobie na platformach wieloprocesorowych (SMP — ang. symmetric multiprocessing). System Linux posiada również wbudowany tzw. scheduler O(1), który bardzo skutecznie zwiększa możliwości skalowania systemów SMP.

Platformy

System Linux obsługuje również programy zwane emulatorami, których zadaniem jest uruchamianie kodu przeznaczonego dla innych systemów operacyjnych. Korzystając z odpowiednich emulatorów, możesz w systemie Linux uruchamiać programy przeznaczone na przykład dla systemu DOS, Windows czy MacOS. Na przykład pakiet Wine (http://www.winehq.org/) to aplikacja typu open-source implementująca Windows API, która działa na bazie serwera X Window System i systemu UNIX/Linux.

Emulatory

Maszyna wirtualna (VM — ang. Virtual Machine) to system, który pozwala na wirtualizację warstwy sprzętowej komputera, tak że z punktu widzenia użytkownika czy oprogramowania działającego w maszynie wirtualnej jest ona widziana jak rzeczywisty komputer fizyczny. Na pojedynczym komputerze fizycznym (komputer gospodarz, ang. host computer) możesz uruchomić wiele różnych maszyn wirtualnych. Oprogramowanie zapewniające wirtualizację jest nazywane monitorem maszyn wirtualnych (VMM — ang. Virtual Machine Monitor) lub hypervisorem. W każdej maszynie wirtualnej może działać inny system operacyjny. Na przykład na danym komputerze gospodarzu możemy uruchomić jednocześnie kilka maszyn wirtualnych, z których jedna będzie działała pod kontrolą systemu Windows 7, druga Ubuntu 12.10, kolejna Ubuntu 13.04 i jeszcze jedna pod kontrolą systemu Fedora 17.

Maszyny wirtualne

Wielozadaniowy system operacyjny pozwala na jednoczesne uruchamianie na danym komputerze wielu programów. Podobnie sytuacja wygląda w przypadku hypervisora, który pozwala na jednoczesne uruchamianie wielu różnych maszyn wirtualnych na jednym komputerze fizycznym.

50  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X Maszyny wirtualne mają wiele zalet w porównaniu z pojedynczymi komputerami dedykowanymi:  Izolacja — każda maszyna wirtualna jest całkowicie izolowana od innych maszyn wirtualnych

działających na tym samym komputerze fizycznym, stąd jeżeli dana maszyna wirtualna ulegnie awarii lub padnie ofiarą ataku czy włamania, nie będzie to miało wpływu na działanie pozostałych maszyn.  Bezpieczeństwo — jeżeli jedna maszyna fizyczna świadcząca wiele usług serwerowych padnie

ofiarą ataku lub włamania, musimy zakładać, że zagrożone są wszystkie serwery tego środowiska. Jeżeli jednak każda usługa serwerowa będzie uruchomiona w osobnej maszynie wirtualnej, to w razie ataku zagrożona jest tylko ta jedna maszyna, a pozostałe usługi serwerowe pozostają bezpieczne.  Zużycie energii — dzięki zastosowaniu maszyn wirtualnych pojedynczy, silny komputer może

zastąpić wiele innych komputerów o mniejszych możliwościach, co w praktyce przekłada się na znaczne ograniczenie zużycia energii.  Projektowanie i wsparcie techniczne — wiele maszyn wirtualnych, z których każda działa pod

kontrolą innej wersji systemu operacyjnego czy nawet pod kontrolą zupełnie innego systemu operacyjnego, może posłużyć do zbudowania laboratorium, w którym zespół programistów może testować działanie tworzonej aplikacji w wielu różnych środowiskach jeszcze przed wypuszczeniem jej na rynek. Poza tym jeżeli jakiś użytkownik zgłosi błąd do działu wsparcia technicznego, to korzystając z takiego laboratorium, możemy z łatwością go odtworzyć dokładnie w takim samym środowisku.  Serwery — w niektórych przypadkach różne usługi serwerowe wymagają różnych wersji

bibliotek systemowych. W takiej sytuacji możemy uruchomić poszczególne serwery na osobnych maszynach wirtualnych działających na tym samym serwerze fizycznym.  Testowanie — korzystając z maszyn wirtualnych, możesz testować najnowsze wersje systemów

operacyjnych i oprogramowania bez obawy o stabilność bazowego systemu produkcyjnego, i to wszystko na jednym komputerze fizycznym.  Połączenia sieciowe — dzięki wirtualizacji możesz testować różne konfiguracje połączeń

sieciowych na jednym komputerze fizycznym.  Piaskownica (ang. sandbox) — każdą maszynę wirtualną możemy traktować jako osobną

piaskownicę, czyli odizolowany obszar (w tym przypadku obejmujący całą maszynę wirtualną), w którym możesz pracować, uruchamiać aplikacje i procesy bez względu na to, jaki będzie rezultat ich działania, i bez obawy o ich wpływ na system bazowy.  Migawki (ang. snapshots) — w każdej chwili możesz wykonać kopię migawkową danej maszyny

wirtualnej i później w razie potrzeby łatwo przywrócić całą maszynę do stanu z chwili wykonania migawki. Xen to aplikacja spełniająca rolę monitora maszyn wirtualnych (VMM), która została zaprojektowana na uniwersytecie Cambridge i obecnie jest rozwijana przez społeczność open-source. Monitor VMM pozwala na jednoczesne uruchamianie na jednym komputerze fizycznym wielu maszyn wirtualnych, z których każda działa pod kontrolą innego systemu operacyjnego. Xen zapewnia izolację poszczególnych maszyn wirtualnych, tak że jeżeli jedna z nich ulegnie awarii, to nie będzie to miało żadnego wpływu na funkcjonowanie pozostałych maszyn. Oprócz tego Xen w minimalnym stopniu obciąża zasoby komputera, zwłaszcza w porównaniu z sytuacją, w której dla każdego z systemów operacyjnych musielibyśmy używać osobnego komputera fizycznego. Więcej szczegółowych informacji na temat Xen znajdziesz na stronie http://www.cl.cam.ac.uk/research/srg/netos/xen/ oraz na stronie http://wiki.xen.org/.

Xen

Dlaczego Linux jest tak wspaniały?  51

Firma VMware Inc. (http://www.vmware.com/) oferuje darmowy VMware Server10, który można pobrać ze strony internetowej firmy i następnie zainstalować na komputerze pracującym pod kontrolą systemu Linux. VMware Server pozwala na zainstalowanie wielu maszyn wirtualnych, z których każda może działać pod kontrolą innego systemu operacyjnego, włączając w to systemy Windows oraz Linux. VMware oferuje również darmową aplikację VMware Player, która pozwala na uruchamianie maszyn wirtualnych utworzonych przez VMware Server.

VMware

KVM, czyli Kernel-based Virtual Machine (patrz http://www.linux-kvm.org/ lub http://libvirt.org/), to maszyna wirtualna typu open-source, która działa jako część jądra systemu Linux.

KVM

Qemu (patrz http://wiki.qemu.org/), napisany przez Fabrice’a Bellarda, to monitor maszyn wirtualnych (VMM) typu open-source, który pozwala na uruchamianie na danym komputerze kodu przygotowanego dla innego typu procesora.

Qemu

VirtualBox (patrz https://www.virtualbox.org/) to monitor maszyn wirtualnych zaprojektowany przez firmę Sun Microsystems i później przejęty przez firmę Oracle. Jeżeli chcesz na swoim komputerze uruchomić wirtualną instancję systemu Windows, możesz rozważyć opcję zainstalowania pakietu VirtualBox.

VirtualBox

DLACZEGO LINUX JEST TAK POPULARNY WŚRÓD FIRM PRODUKUJĄCYCH URZĄDZENIA ORAZ WŚRÓD PROGRAMISTÓW? Dwa trendy w światowym przemyśle komputerowym przygotowały scenę dla rosnącej popularności systemów UNIX i Linux. Po pierwsze, rozwój technologii sprzętowych spowodował potrzebę opracowania systemu operacyjnego, który byłby w stanie skorzystać z możliwości, jakie w owym czasie oferowały rozwiązania sprzętowe. W połowie lat 70. minikomputery zaczęły stawać się coraz poważniejszą konkurencją dla komputerów typu mainframe, ponieważ w wielu wypadkach potrafiły wykonać takie same obliczenia przy znacznie niższych kosztach użytkowania. Nieco później wraz z powstaniem 64-bitowych procesorów o ogromnych możliwościach pojawienie się na rynku tanich i szybkich pamięci RAM oraz dysków twardych o wielkiej pojemności za bardzo umiarkowaną cenę pozwoliło na instalowanie przez producentów wielodostępnych systemów operacyjnych na komputerach klasy desktop. Po drugie, spadające gwałtownie ceny urządzeń sprzętowych spowodowały, że producenci komputerów nie mogli już sobie pozwolić na projektowanie i wdrażanie swoich własnych serwerów operacyjnych. Własny system operacyjny (ang. proprietary operating system) to taki system operacyjny, który jest tworzony przez producenta sprzętu i który jest jego własnością (na przykład firma DEC/Compaq jest twórcą i właścicielem systemu VMS). Współczesnym producentom sprzętu komputerowego potrzebny był gotowy system operacyjny ogólnego przeznaczenia, który mogliby łatwo zaadaptować do swoich potrzeb i zainstalować na produkowanych komputerach.

Własne systemy operacyjne

System operacyjny ogólnego przeznaczenia to system napisany przez inną firmę i sprzedawany (na przykład UNIX, OS X czy Windows) lub przekazywany (Linux) producentowi komputerów w celu zainstalowania. Linux jest systemem operacyjnym ogólnego przeznaczenia, ponieważ może działać na wielu różnych typach komputerów wytwarzanych przez wielu różnych producentów. Oczywiście jeżeli producenci komputerów mogą zapłacić tylko za prace projektowo-wdrożeniowe i uniknąć płacenia jednostkowych kosztów licencji (jak w przypadku Windows, gdzie producent komputerów musi płacić firmie Microsoft za każdą sprzedaną kopię systemu), to na „dzień dobry” znajdują się w znacznie lepszej sytuacji. Z kolei twórcy oprogramowania muszą utrzymywać relatywnie niski poziom kosztów licencji i z reguły nie mogą sobie pozwolić na tworzenie

System operacyjny ogólnego przeznaczenia

10

W roku 2011 firma VMware Inc. zakończyła rozwijanie produktu VMware Server. Obecnie bezpłatną aplikacją VMware pozwalającą na tworzenie i używanie maszyn wirtualnych pozostaje VMware Player. Wymieniony program jest dostępny w wersji dla systemów Linux i Windows — przyp. tłum.

52  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X nowych wersji swoich aplikacji przeznaczonych do działania w wielu własnych systemach operacyjnych różnych producentów. Jak widać, zarówno producenci sprzętu, jak i twórcy oprogramowania potrzebują dobrego systemu operacyjnego ogólnego przeznaczenia. Choć początkowo system UNIX spełniał wymogi producentów sprzętu i oprogramowania stawiane systemowi operacyjnemu ogólnego przeznaczenia, to jednak wraz z upływem czasu dryfował coraz bardziej w stronę specjalizacji. Działo się tak dlatego, że poszczególni producenci dodawali do niego coraz więcej modułów, bibliotek systemowych i narzędzi obsługujących ich specyficzne rozwiązania sprzętowe. W takiej sytuacji Linux zaczął jawić się jako system spełniający oba wymagania: jako system operacyjny ogólnego przeznaczenia, który łatwo potrafi wykorzystać potężne możliwości drzemiące w coraz lepszych rozwiązaniach sprzętowych.

LINUX JEST PRZENOŚNY Przenośny (ang. portable) system operacyjny to taki system, który może być uruchamiany na wielu różnych komputerach. Ponad 95 procent kodu źródłowego systemu Linux jest napisane w języku C, a język C jest z definicji przenośnym i niezależnym od warstwy sprzętowej językiem programowania wysokiego poziomu (sam kompilator języka C został napisany w języku C). Ponieważ system Linux jest przenośny, może zostać łatwo zaadaptowany do działania na innym komputerze i może spełniać specyficzne wymagania takiego komputera. Na przykład system Linux jest często wykorzystywany w różnego rodzaju urządzeniach mobilnych i dedykowanych, takich jak telefony komórkowe, PDA czy dekodery telewizji kablowej. Struktura linuksowego systemu plików pozwala na wykorzystanie w pełni możliwości nowoczesnych i szybkich dysków twardych o ogromnych pojemnościach. Co równie ważne, Linux został od początku zaprojektowany jako wielodostępny system operacyjny, stąd współużytkowanie mocy obliczeniowej komputera przez wielu użytkowników i zdolność do korzystania ze wspólnych zasobów dyskowych są jednymi z najważniejszych cech tego systemu. Ponieważ system Linux jest przenośny i może łatwo wykorzystywać zasoby danego komputera, spotykany jest na wielu różnych platformach sprzętowych, począwszy od prostych implementacji mikroprocesorowych, a na komputerach klasy mainframe skończywszy. Ogromna popularność urządzeń wyposażonych w mikroprocesory również przyczyniła się do rozwoju systemu Linux, a same mikrokomputery stają się coraz szybsze przy zachowaniu relatywnie tej samej ceny. Taka szeroka akceptacja systemu Linux sprzyja zarówno użytkownikom, którzy nie muszą uczyć się obsługi nowego systemu operacyjnego za każdym razem, kiedy kupują nowy komputer, jak i administratorom, którzy bardzo lubią, kiedy całe zarządzane przez nich środowisko programowe jest spójne. Pojawienie się standardowego systemu operacyjnego przyczyniło się do gwałtownego rozwoju całej branży twórców oprogramowania. Teraz producenci oprogramowania mogą pozwolić sobie na przygotowanie jednej wersji aplikacji, która będzie działała na wielu różnych typach komputerów produkowanych przez różne firmy.

JĘZYK C Pierwsza wersja systemu UNIX powstała w roku 1969. Jej autorem był Ken Thompson, który napisał oprogramowanie tego systemu operacyjnego w języku asemblera komputera PDP-7. Język asemblera jest silnie uzależniony od architektury komputera. Programy pisane w takim języku będą poprawnie pracować tylko na jednym typie komputera lub — przy dużym szczęściu — na jednej rodzinie komputerów. Z tego powodu oryginalna, początkowa wersja systemu UNIX nie mogła być łatwo przeniesiona na inne typy komputerów — krótko mówiąc, nie była przenośna. Aby umożliwić przenoszenie systemu UNIX na inne komputery, Thompson opracował na bazie języka BCPL zupełnie nowy, niezależny od platformy sprzętowej język programowania o nazwie B. Nieco później kolejny genialny programista, Dennis Ritchie, opracował na bazie języka B nowy język

Przegląd systemu Linux  53

programowania o nazwie C i przy pomocy Kena Thompsona w roku 1973 utworzył w tym języku kolejną wersję systemu UNIX. Początkowo, język C był zachwalany jako „przenośny asembler”. Nową wersję systemu UNIX można było znacznie łatwiej przenosić i uruchamiać na innych komputerach. Od tego momentu rozpoczął się gwałtowny rozwój i popularność języka C. Geneza jego powstania dosyć jednoznacznie ujawnia powody, dla których jest to narzędzie o tak ogromnych możliwościach. Język C pozwala na pisanie programów, które są zupełnie niezależne od platformy sprzętowej. Tworząc nową aplikację, programista może z łatwością przenieść ją na niemal każdy inny komputer wyposażony w kompilator języka C. Język został również zaprojektowany w taki sposób, aby skompilowany kod wynikowy był bardzo wydajny. Po pojawieniu się języka C programiści chcący uzyskać szybki i efektywny kod programu nie musieli już dłużej sięgać po asembler (aczkolwiek należy pamiętać o tym, że asembler zawsze będzie generował bardziej wydajny kod niż jakikolwiek język wysokiego poziomu). C jest dobrym językiem systemowym — na przykład możesz w nim napisać nowy system operacyjny albo kompilator języka C. Jest to mocno strukturalny język programowania, ale niekoniecznie musi być klasyfikowany jako język wysokiego poziomu. Język C pozwala programiście na bezpośrednią manipulację bitami i bajtami danych, co jest niezbędne w przypadku pisania systemu operacyjnego, ale równocześnie posiada wiele konstrukcji charakterystycznych dla języków wysokiego poziomu, które umożliwiają wydajne programowanie modułowe. W późnych latach osiemdziesiątych ubiegłego wieku amerykański instytut ANSI (American National Standards Institute) opracował standardową wersję języka C, powszechnie znaną pod nazwą ANSI C lub mniej formalnie C89 (ze względu na rok, w którym ten standard został opracowany). Dziesięć lat później opublikowany został standard C99, który do tej pory jest obsługiwany przez gcc, czyli kompilator języka C w projekcie GNU. Oryginalna wersja języka C jest często określana mianem K&R C (inaczej Kernighan & Ritchie C), od nazwisk autorów pierwszej książki opisującej ten język. Inny naukowiec pracujący w Bell Labs, Bjarne Stroustrup, na bazie języka C stworzył język C++, czyli zorientowaną obiektowo wersję języka C. Ponieważ umiejętność programowania obiektowego jest obecnie wymagana przez wielu pracodawców, to w wielu środowiskach język C++ jest znacznie bardziej popularny niż stary, dobry C. Innym językiem obiektowym jest Objective-C, który został użyty do napisania pierwszej na świecie przeglądarki internetowej. Kompilator języka C w projekcie GNU obsługuje standardy C, C++ oraz Objective-C.

PRZEGLĄD SYSTEMU LINUX System operacyjny Linux posiada bardzo wiele unikatowych i potężnych możliwości. Podobnie jak inne systemy operacyjne, spełnia rolę programu sterującego dla komputerów, jednak — tak jak system UNIX — posiada również dobrze przemyślany i zaprojektowany zestaw programów narzędziowych (patrz rysunek 1.1) oraz zestaw narzędzi pozwalających użytkownikom logować się i wykorzystywać takie narzędzia do tworzenia systemów i aplikacji.

Rysunek 1.1. Przekrój przez poszczególne warstwy systemu operacyjnego Linux

54  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X

LINUX POSIADA INTERFEJS POZWALAJĄCY NA PROGRAMOWANIE JĄDRA SYSTEMU Jądro systemu Linux — czyli serce systemu operacyjnego Linux — jest odpowiedzialne za alokowanie zasobów komputera i takie rozplanowanie realizacji zadań użytkowników, aby każde zadanie otrzymywało odpowiednią ilość zasobów systemowych, cykli procesora oraz urządzeń peryferyjnych takich jak dyski twarde, napędy DVD, taśmowe pamięci masowe czy drukarki. Programy porozumiewają się z jądrem systemu poprzez tzw. funkcje systemowe (ang. system calls), czyli specjalne zestawy funkcji o znanych nazwach, spełniające ściśle określone role. Programista może używać jednej funkcji systemowej do wymiany informacji z wieloma rodzajami urządzeń. Na przykład istnieje jedna, uniwersalna funkcja write() pozwalająca na zapisywanie danych do wielu urządzeń. Kiedy program wywołuje funkcję write(), jądro systemu interpretuje kontekst wywołania i przekazuje żądanie do odpowiedniego urządzenia. Taka elastyczność pozwala na współpracę starszych programów z nowymi urządzeniami, które w czasie, kiedy taki program powstawał, po prostu jeszcze nie istniały. Dzięki tej elastyczności możliwe jest również przenoszenie takich programów na nowe wersje systemu operacyjnego bez konieczności modyfikacji kodu programu (zakładając, że nowa wersja systemu operacyjnego wykorzystuje takie same wywołania funkcji systemowych).

LINUX MOŻE OBSŁUGIWAĆ WIELU UŻYTKOWNIKÓW W zależności od platformy sprzętowej oraz rodzaju wykonywanych zadań system Linux może obsługiwać od 1 do ponad 1000 użytkowników, z których każdy może w tym samym czasie uruchamiać inny zestaw programów. Jednostkowy koszt komputera w przeliczeniu na „głowę użytkownika” w przypadku systemów wielodostępnych jest znacznie niższy niż w sytuacji, kiedy dany komputer jest wykorzystywany w danym czasie tylko przez jednego użytkownika. Koszt jest niższy, ponieważ jedna osoba nie jest w stanie w pełni wykorzystać wszystkich zasobów komputera — inaczej mówiąc, jedna osoba nie jest w stanie jednocześnie korzystać ze wszystkich drukarek, zajmować wszystkich zasobów pamięci, generować ciągłe żądania odczytu i zapisu na dyskach, wykorzystywać całą przepustowość łącza do sieci Internet i wykorzystywać jednocześnie wszystkie dostępne terminale. Z drugiej strony, wielodostępny system operacyjny pozwala na wykorzystywanie zasobów komputera przez wielu użytkowników w tym samym czasie. W takiej sytuacji stopień wykorzystania zasobów jest maksymalizowany, a jednostkowy koszt w przeliczeniu na użytkownika może być zminimalizowany — co jest jednym z najważniejszych zadań systemów wielodostępnych.

LINUX JEST SYSTEMEM WIELOZADANIOWYM Linux jest w pełni chronionym, wielozadaniowym systemem operacyjnym, pozwalającym użytkownikom na uruchamianie więcej niż jednego zadania w tym samym czasie. Poszczególne procesy mogą bez przeszkód komunikować się między sobą, ale jednocześnie są dobrze chronione przed innymi procesami, dokładnie tak, jak chronione jest jądro systemu. Możesz uruchomić kilka procesów działających w tle, a jednocześnie prowadzić sesję interakcyjną z procesem, który aktualnie wyświetla informacje na ekranie. W razie potrzeby możesz w każdej chwili przełączyć się do kolejnego lub poprzedniego zadania. Jeżeli korzystasz z serwera X Window System, możesz uruchamiać każdy program w osobnym oknie na tym samym ekranie i jednocześnie obserwować ich działanie. Takie rozwiązanie z pewnością pomaga w zwiększeniu efektywności pracy użytkowników.

LINUX UDOSTĘPNIA BEZPIECZNY, HIERARCHICZNY SYSTEM PLIKÓW Plik to zbiór informacji, takich jak tekst notatki czy raportu, rozliczenie sprzedaży, zdjęcie, utwór muzyczny czy wreszcie program wykonywalny. Poszczególne pliki są przechowywane w pamięci masowej — takiej jak na przykład dysk twardy — i każdy z nich ma przypisany unikatowy identyfikator. System plików systemu Linux posiada odpowiednie struktury, dzięki którym pliki są pogrupowane w katalogach, które spełniają funkcję podobną do pudeł na dokumentację w archiwum. Każdy katalog ma swoją nazwę i może przechowywać inne pliki i katalogi. Z kolei poszczególne katalogi są pogrupowane

Przegląd systemu Linux  55

w innych katalogach i tak dalej, co w rezultacie tworzy strukturę zbliżoną wyglądem do drzewa. Taka struktura ułatwia użytkownikom śledzenie dużej ilości plików poprzez pogrupowanie ich w odpowiednich katalogach. Każdy użytkownik posiada swój jeden, główny katalog domowy, w którym może zakładać dowolną liczbę podkatalogów (patrz rysunek 1.2).

Rysunek 1.2. Struktura systemu plików systemu Linux

Mając na względzie ideę ułatwienia życia administratorom systemów i programistom, jakiś czas temu grupa użytkowników zebrała się dzięki sieci Internet i opracowała założenia systemu plików o nazwie FSSTND (ang. Linux Filesystem Standard), który z czasem zamienił się w system plików FHS (ang. Linux Filesystem Hierarchy Standard). Zanim ten standard został przyjęty, kluczowe programy i pliki systemu Linux w różnych dystrybucjach były zlokalizowane w zupełnie różnych miejscach. Obecnie możesz usiąść przy konsoli niemal dowolnej dystrybucji systemu Linux i możesz oczekiwać, że dany program będący częścią systemu znajdziesz w dobrze znanej i powtarzalnej lokalizacji.

Standardy

Utworzenie dowiązania do pliku pozwala na uzyskanie dostępu do takiego pliku za pomocą dwóch lub więcej nazw. Nazwy alternatywne mogą być zlokalizowane w tym samym katalogu co oryginalny plik lub w zupełnie innym miejscu. Dowiązania powodują, że ten sam plik może pojawiać się w kilku różnych katalogach użytkowników, co pozwala na łatwe udostępnianie takiego pliku. W systemie Windows zamiast określenia dowiązanie do pliku używany jest termin skrót do pliku. Z kolei użytkownicy komputerów Macintosh zapewne spotkali się z określeniem alias. Pamiętaj jednak, że w systemie Linux alias to coś zupełnie innego niż dowiązanie do pliku; polecenie alias jest związane ze skryptami powłoki i umożliwia tworzenie makrokomend.

Dowiązania

Podobnie jak większość wielodostępnych systemów operacyjnych Linux zapewnia użytkownikom ochronę swoich danych przed niepowołanym dostępem innych użytkowników. Pozwala również na selektywne udostępnianie i współużytkowanie danych poprzez proste i efektywne mechanizmy ochronne. Taki poziom zabezpieczeń zapewniany jest poprzez odpowiednie prawa dostępu na poziomie pliku pozwalające na ograniczenie listy użytkowników, którzy będą mogli odczytywać taki plik, zapisywać do niego dane czy go wykonywać (uruchamiać). Linux pozwala również na zaimplementowanie list ACL (ang. Access Control Lists), które dają zarówno użytkownikom, jak i administratorowi systemu możliwość jeszcze bardziej precyzyjnego zdefiniowania praw dostępu do poszczególnych plików i katalogów.

Bezpieczeństwo

POWŁOKA — INTERPRETER POLECEŃ I JĘZYK PROGRAMOWANIA W środowisku tekstowym powłoka, czyli inaczej interpreter poleceń, spełnia rolę interfejsu pomiędzy użytkownikiem a systemem operacyjnym. Kiedy wpisujesz na ekranie dane polecenie, powłoka je interpretuje i wywołuje odpowiedni program. W systemie Linux dostępnych jest całkiem sporo różnych powłok. Cztery najbardziej popularne spośród nich to:

56  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X  Bourne Again Shell (bash), rozszerzona wersja powłoki Bourne Shell (oryginalna powłoka

systemu UNIX).  Debian Almquist Shell (dash, patrz rozdział 8.), pomniejszona wersja powłoki bash ze znacznie okrojoną listą możliwości. Wiele skryptów wywoływanych podczas uruchamiania systemu korzysta z powłoki dash w celu przyspieszenia procesu ładowania całego systemu.  TC Shell (tcsh, patrz rozdział 9.) rozszerzona wersja powłoki C Shell, opracowana jako część

projektu BSD UNIX.  Z Shell (zsh), w której zostały zaimplementowane mechanizmy z wielu różnych powłok,

z powłoką Korn Shell włącznie. Ponieważ każdy użytkownik może mieć swoje własne preferencje co do powłoki, z której korzysta, w systemach wielodostępnych jednocześnie może być wykorzystywanych wiele różnych powłok. Szeroki wybór dostępnych powłok demonstruje jedną z zalet systemu Linux: możliwość dostosowania interfejsu do indywidualnych potrzeb każdego użytkownika. Oprócz interpretowania poleceń wpisywanych z klawiatury i przesyłania ich do systemu operacyjnego powłoka spełnia rolę języka programowania wysokiego poziomu. Odpowiednie sekwencje poleceń powłoki mogą zostać zapisane w pliku tekstowych i wykonane później. W systemie Linux takie pliki nazywane są skryptami powłoki (ang. shell scripts), podczas gdy w systemie Windows ich funkcjonalne odpowiedniki noszą nazwę plików wsadowych (ang. batch files). Taka elastyczność powłoki znakomicie ułatwia wykonywanie złożonych zadań, gdzie rola użytkownika sprowadza się często do wpisania jednego, krótkiego polecenia lub — w przypadku braku gotowego skryptu — do zbudowania przy zaskakująco niewielkim nakładzie pracy rozbudowanych skryptów realizujących często bardzo skomplikowane operacje.

Skrypty powłoki

GENEROWANIE NAZW PLIKÓW Kiedy wpisujesz polecenie, które ma zostać wykonane przez powłokę systemu, możesz wykorzystywać wzorce tekstowe wykorzystujące znaki mające specjalne znaczenie dla powłoki. Takie znaki noszą nazwę symboli wieloznacznych. Cały wzorzec tekstowy utworzony przy użyciu tych symboli nosi nazwę wieloznacznego odwołania do plików (ang. ambigious file reference) i jest swego rodzaju „skrótem”, który powłoka rozwija następnie do pełnych nazw plików pasujących do wzorca. Odwołania wieloznaczne mogą Ci oszczędzić wpisywania dużej ilości znaków, zwłaszcza w przypadku posługiwania się długimi nazwami plików czy długimi seriami zbliżonych do siebie nazw plików. Na przykład powłoka może rozwinąć wzorzec mak* do pełnego make-3.80.taz.gz. Wzorce tekstowe są również bardzo użyteczne w sytuacji, kiedy znasz tylko fragment nazwy pliku lub nie potrafisz jej dokładnie przeliterować.

Symbole wieloznaczne i wieloznaczne odwołania do plików

DOPEŁNIANIE W połączeniu z biblioteką Readline powłoka potrafi automatycznie dopełniać wpisywane nazwy poleceń, plików, ścieżek i zmiennych. Działa to tak, że wpisujesz pierwszych kilka znaków nazwy np. polecenia, naciskasz klawisz Tab i powłoka wyświetla listę elementów, które rozpoczynają się od podanego ciągu znaków, lub automatycznie dopełnia nazwę, jeżeli znajdzie tylko jeden pasujący element. WEJŚCIE I WYJŚCIE NIEZALEŻNE OD URZĄDZENIA Urządzenia (takie jak drukarka czy terminal) oraz pliki przechowywane na dysku z punktu widzenia aplikacji systemu Linux są po prostu plikami. Kiedy wydajesz jakieś polecenie dla systemu Linux, możesz go poinstruować, aby strumień danych wyjściowych tego polecenia był przesyłany do wybranego urządzenia wyjściowego lub pliku. Takie rozwiązanie nazywamy przekierowaniem (ang. redirection) danych wyjściowych.

Przekierowanie

Przegląd systemu Linux  57

W podobny sposób wejście programu, na które zazwyczaj są przesyłane dane z klawiatury, może zostać przekierowane na przykład tak, aby pobierać dane bezpośrednio z pliku na dysku. Wejście i wyjście aplikacji są niezależne od urządzeń peryferyjnych, czyli inaczej mówiąc, mogą być przekierowane na odpowiednie urządzenie wyjściowe lub pobierać dane z wybranego urządzenia wejściowego.

Niezależność od urządzeń

Na przykład popularne polecenie cat domyślnie wyświetla zawartość pliku na ekranie, jednak w razie potrzeby możesz łatwo przekierować strumień danych wyjściowych, tak że zamiast na ekranie, będzie zapisywany bezpośrednio do pliku na dysku twardym komputera.

FUNKCJE POWŁOKI Jedną z najważniejszych cech powłoki jest to, że możesz używać jej jak języka programowania. Ponieważ powłoka jest interpreterem poleceń, skrypty powłoki nie są kompilowane, a poszczególne polecenia skryptu są interpretowane za każdym razem, kiedy skrypt zostanie załadowany z dysku i uruchomiony. Pamiętaj, że ładowanie skryptów i interpretacja poleceń może być dosyć czasochłonnym procesem. W przypadku wielu powłok, z powłoką Bourne Again Shell włącznie, większość obsługiwanych funkcji jest przechowywana w pamięci operacyjnej, dzięki czemu nie muszą one być ładowane za każdym razem, kiedy wykonujesz skrypt. Powłoka zapisuje swoje funkcje w specjalnym wewnętrznym formacie i przechowuje je w pamięci operacyjnej, dzięki czemu nie musi tracić czasu na ponowną interpretację takich poleceń.

STEROWANIE ZADANIAMI Sterowanie zadaniami to mechanizm powłoki, który pozwala użytkownikom na jednoczesne uruchamianie wielu zadań i przełączanie między nimi w miarę potrzeb. Kiedy uruchamiasz nowe zadanie, zazwyczaj działa ono na pierwszym planie i często jest powiązane z terminalem. Dzięki mechanizmowi sterowania zadaniami możesz przenieść takie zadanie do pracy w tle (na drugim planie), a sam możesz uruchomić kolejne zadanie lub na przykład obserwować postępy innego, pierwszoplanowego zadania. Jeżeli zadanie drugoplanowe będzie wymagało Twojej interwencji, możesz ponownie przenieść je na pierwszy plan, gdzie zostanie ponownie powiązane z terminalem. Idea mechanizmu sterowania zadaniami wywodzi się z systemu BSD UNIX, gdzie pojawiła się po raz pierwszy w powłoce C Shell.

OGROMNA KOLEKCJA UŻYTECZNYCH NARZĘDZI W systemie Linux masz do dyspozycji kilkaset programów narzędziowych, często nazywanych poleceniami. Zadaniem takich narzędzi jest wykonywanie funkcji, które są uniwersalne i często wykorzystywane przez użytkowników. Na przykład polecenie sort porządkuje listę (lub grupę list) w kolejności alfabetycznej lub numerycznej i może być wykorzystywane do sortowania list według różnych kryteriów, takich jak numer katalogowy, nazwisko, nazwa miasta, kod pocztowy, numer telefonu, wiek, wzrost, koszt i tak dalej. Polecenie sort to bardzo ważne narzędzie, które jest częścią standardowej dystrybucji systemu Linux. Inne narzędzia pozwalają użytkownikom na tworzenie, wyświetlanie, drukowanie, kopiowanie, wyszukiwanie i usuwanie plików, a jeszcze inne pozwalają na edytowanie, formatowanie i wpisywanie tekstu. Więcej szczegółowych informacji na temat systemu Linux znajdziesz po wykonaniu polecenia man oraz info.

KOMUNIKACJA MIĘDZYPROCESOWA System Linux pozwala użytkownikom na używanie w wierszu poleceń konsoli znaków przekierowania strumienia danych oraz filtrów. Znak przekierowania strumienia danych (ang. pipe) powoduje przesyłanie danych z wyjścia jednego programu na wejście drugiego. Z kolei filtr to specjalny rodzaj znaku przekierowania, który pobiera dane napływające na jego wejście, przetwarza je i przesyła jako strumień danych wyjściowych. Filtry przetwarzają informacje pobierane z wyjścia

Przekierowania strumienia danych i filtry

58  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X innych programów, dokonując odpowiedniej modyfikacji strumienia danych. Strumień danych wyjściowych z filtra staje się następnie strumieniem danych wejściowych dla innego programu. Znaki przekierowania strumienia danych oraz filtry często są ze sobą łączone w celu uzyskania określonego rezultatu. Na przykład możesz użyć przekierowania strumienia danych do przesyłania danych z wyjścia polecenia sort na wejście polecenia head (to filtr, który wyświetla na ekranie pierwszych dziesięć wierszy danych, które napływają na jego wejście). Następnie możesz użyć kolejnego znaku przekierowania danych i przesłać strumień danych z wyjścia polecenia head na wejście kolejnego polecenia, lpr, które wysyła dane na drukarkę. W taki sposób przy użyciu polecenia mieszczącego się w jednym wierszu możesz połączyć ze sobą trzy polecenia, które w efekcie finalnym spowodują posortowanie, odfiltrowanie i wydrukowanie części danych z pliku.

ZARZĄDZANIE SYSTEMEM W systemach linuksowych administrator systemu często jest jego właścicielem i jednocześnie jedynym użytkownikiem. Na takiej osobie spoczywa ciężar wykonywania bardzo wielu zadań. Po pierwsze, administrator musi zainstalować system operacyjny i odpowiednie pakiety oprogramowania, a następnie zazwyczaj zmodyfikować zawartość wielu plików konfiguracyjnych. Kiedy system jest już gotowy do działania, administrator jest odpowiedzialny za pobieranie i instalację dodatkowego oprogramowania (z aktualizacją systemu operacyjnego włącznie), tworzenie kopii zapasowych, odtwarzanie danych z kopii zapasowych oraz zarządzanie innymi elementami środowiska, takimi jak drukarki, terminale, serwery czy lokalna sieć komputerowa. Administrator systemu jest również odpowiedzialny za tworzenie i konfigurację kont dla nowych użytkowników systemu wielodostępnego, włączanie i wyłączanie systemu w miarę potrzeb, monitorowanie systemu i rozwiązywanie bieżących problemów z jego funkcjonowaniem.

DODATKOWE MECHANIZMY SYSTEMU LINUX Projektanci systemu Linux włączyli do niego liczne mechanizmy znane do tej pory z systemów BSD, System V czy Solaris (firmy Sun Microsystems), jak również wiele nowych. Choć większość narzędzi działających w systemach klasy UNIX ma swoje odpowiedniki w systemie Linux, to jednak w niektórych przypadkach oryginalne narzędzia zostały zastąpione ich nowszymi, lepszymi odpowiednikami. W tej sekcji omówimy niektóre popularne narzędzia i mechanizmy dostępne w systemie Linux.

GRAFICZNE INTERFEJSY UŻYTKOWNIKA X Window System (nazywany również krótko X lub X11) został opracowany częściowo przez naukowców z MIT (Massachusetts Institute of Technology) i stał się fundamentem dla wszystkich środowisk graficznych dostępnych w systemie Linux. Mając terminal lub stację roboczą, która obsługuje serwer X, użytkownik może pracować z komputerem poprzez szereg okienek wyświetlanych na ekranie, wyświetlać informacje graficzne, używać aplikacji do rysowania i retuszowania, monitorować procesy działające w systemie czy wyświetlać podgląd graficzny kompletnej, sformatowanej strony dokumentu. X jest protokołem sieciowym, który pozwala użytkownikowi na otwieranie okien na zdalnych stacjach roboczych i w innych systemach komputerowych. Praktycznie wszyscy użytkownicy komputerów Macintosh znają standardowy graficzny interfejs użytkownika OS X o nazwie Aqua. Opiera się on na technologii Quartz odpowiedzialnej za generowanie standardowego wyglądu interfejsu aplikacji. Domyślnie w systemie OS X nie jest instalowane środowisko X11, ale zamiast niego możesz wykorzystać XQuartz (http://xquartz.macosforge.org/trac/wiki).

Aqua

Zazwyczaj na bazie serwera X działają dwie dodatkowe warstwy: menedżer pulpitu i menedżer okien. Menedżer pulpitu to zorientowany graficznie (obrazkowo) interfejs użytkownika, który pozwala na interakcję z programami systemowymi poprzez odpowiednie użycie ikon (zamiast wpisywania nazw poleceń bezpośrednio w wierszu poleceń konsoli). Domyślnym menedżerem pulpitu

Menedżer pulpitu

Dodatkowe mechanizmy systemu Linux  59

w większości dystrybucji systemu Linux jest GNOME (http://www.gnome.org/), ale możesz również używać KDE (http://www.kde.org/) i wielu innych. Z kolei OS X obsługuje pulpit11 w Aqua, a nie X11, więc nie korzysta z oddzielnego menedżera pulpitu. Menedżer okien to program, który działa pod kontrolą menedżera pulpitu i pozwala na otwieranie i zamykanie okien, uruchamianie programów i sterowanie funkcjami i akcjami myszy, tak aby w zależności od miejsca i sposobu kliknięcia wykonywane były odpowiednie operacje. Menedżer okien jest również odpowiedzialny za nadawanie odpowiedniego charakteru wyglądowi ekranu. Podczas gdy Microsoft Windows pozwala na zmianę kolorów kluczowych elementów okien dialogowych, menedżer okien działający pod kontrolą serwera X umożliwia dostosowanie do własnych, indywidualnych potrzeb całego ekranu — możesz zmienić wygląd i sposób zachowania okien dialogowych (poprzez zmianę wyglądu obramowań, przycisków czy pasków przewijania), tworzyć wirtualne pulpity, własne menu i wiele innych. Podczas pracy w powłoce, uruchamiając program Midnight Commander (mc), możesz otrzymać efekt zbliżony do używania menedżera okien.

Menedżer okien

W systemie Linux działającym z serwerem X możesz spotkać kilka bardzo popularnych menedżerów okien. W wielu dystrybucjach systemu Linux dostępne są Metacity (domyślny menedżer okien środowiska GNOME 2) oraz kwin (domyślny menedżer okien środowiska KDE). W systemie Fedora oprócz menedżera z KDE dostępny jest również menedżer o nazwie Mutter (domyślny menedżer okien środowiska GNOME 3). Nazwa Mutter powstała jako złożenie nazwy Metacity Clutter (Clutter to nazwa biblioteki procedur graficznych). Dostępne są również inne menedżery okien, takie jak Sawfish czy WindowMaker. W systemie OS X większością okien zarządza warstwa Quartz, która odpowiada za zapewnienie spójnego wyglądu i działania menedżera Aqua. W przypadku aplikacji działających jedynie w środowisku X11 obsługą zajmuje się quartz-wm, który dba o to, aby aplikacje X11 uruchomione w systemie Mac wyglądały tak samo jak rodzime aplikacje OS X.

NARZĘDZIA (MIĘDZY)SIECIOWE Mechanizm obsługi połączeń sieciowych w systemie Linux wyposażony jest w wiele narzędzi pozwalających na łączenie się ze zdalnymi systemami znajdującymi się w wielu różnych typach sieci komputerowych. Dzięki połączeniom sieciowym LAN i WAN (a nawet sieci Internet) możesz nie tylko wysyłać wiadomości poczty elektronicznej do użytkowników znajdujących się w innych systemach, ale też mieć dostęp do plików znajdujących się na dyskach zamontowanych na innych komputerach, tak jakby te pliki znajdowały się na dysku lokalnym, w analogiczny sposób udostępniać swoje zasoby plikowe, kopiować i przenosić pliki z jednego systemu do drugiego, uruchamiać programy w systemach zdalnych i na lokalnym komputerze obserwować wyniki ich działania oraz wykonywać cały szereg innych operacji. Na bazie połączeń sieciowych funkcjonuje szeroki wachlarz aplikacji, które rozszerzają możliwości Twoje i Twojego komputera. Możesz z łatwością rozmawiać z osobą znajdującą się na drugim końcu świata, zbierać informacje na interesujące Cię tematy oraz szybko i wygodnie pobierać z sieci Internet nowe pakiety oprogramowania.

TWORZENIE OPROGRAMOWANIA Jednym z elementów systemu Linux, które z pewnością robią największe wrażenie, jest bogate środowisko do tworzenia i testowania oprogramowania. Linux potrafi obsługiwać kompilatory i interpretery bardzo wielu języków programowania. Oprócz C i C++ system Linux obsługuje między innymi takie języki jak Ada, Fortran, Java, Lisp, Pascal, Perl i Python. Narzędzie o nazwie bison pozwala na generowanie kodu parserów, które znakomicie ułatwiają pisanie programów tworzących kompilatory (czyli narzędzi przetwarzających pliki zawierające zorganizowane informacje). Polecenie flex z kolei pozwala na łatwe generowanie analizatorów leksykalnych składni, niezbędnych dla każdego kompilatora. Polecenie make oraz GNU CBS (ang. GNU Configure and Build System), czyli zestaw 11

W systemie OS X pulpit przyjęło się nazywać biurkiem, stąd np. obecność katalogu o nazwie Biurko zamiast znanego z systemów Windows i Linux katalogu Pulpit — przyp. tłum.

60  ROZDZIAŁ 1. WITAMY W SYSTEMACH LINUX I OS X narządzi programistycznych, które pomagają w kompilowaniu kodu źródłowego i budowaniu oprogramowania, bardzo ułatwiają zarządzanie złożonymi projektami programistycznymi. Z kolei systemy zarządzania kodem źródłowym, takie jak CVS, pozwalają na efektywną kontrolę nad poszczególnymi wersjami oprogramowania. Kilka debugerów, takich jak ups czy gdb, może pomóc Ci podczas wyszukiwania i poprawiania błędów w aplikacji. Kompilator GNU C (gcc) razem z poleceniem profilującym aplikacje gprof ułatwia programistom identyfikację wąskich gardeł w kodzie, mających negatywny wpływ na wydajność programu. Kompilator języka C posiada opcje pozwalające na bardzo skrupulatną kontrolę składni kodu źródłowego, dzięki czemu kod wynikowy jest bardziej przenośny, a czas potrzebny na testowanie ulega znacznemu skróceniu. Z kolei w systemie OS X opracowane przez Apple narzędzie Xcode oferuje zunifikowane, graficzne środowisko programistyczne zawierające wiele z wymienionych powyżej narzędzi oraz inne.

PODSUMOWANIE ROZDZIAŁU System operacyjny Linux wyrósł na bazie doświadczeń z systemem UNIX i szybko stał się popularną alternatywą dla systemu Windows, który do tej pory „tradycyjnie” był najczęściej instalowany na komputerach osobistych klasy PC. Użytkownicy systemu UNIX odnajdą w środowisku systemu Linux wiele znajomych elementów. W dystrybucjach systemu Linux znajdziesz wiele poleceń, programów i narzędzi znanych z systemu UNIX, rozwijanych i ulepszanych przez szerokie rzesze programistów z całego świata. Znajdziesz tam również cały zestaw narzędzi opracowanych w ramach projektu GNU. Społeczność związana ze środowiskiem systemu Linux jest mocno zaangażowana w proces ciągłego rozwoju i ulepszania tego systemu. Odpowiednie sterowniki zapewniające obsługę nowych urządzeń są dostępne dla systemu Linux niemal natychmiast po pojawieniu się takich urządzeń na rynku, a narzędzia systemowe są bardzo często aktualizowane. Jeżeli dodamy do tego cały szereg komercyjnych pakietów oprogramowania działającego na platformie Linux oraz wielu producentów sprzętu sprzedających swoje komputery z preinstalowanym systemem Linux, to staje się jasne, dlaczego ten system zamienił się z niepozornego, studenckiego projektu w poważny, stabilny system operacyjny, używany zarówno przez najważniejsze ośrodki naukowe i akademickie, firmy i korporacje, jak również niezliczone rzesze użytkowników prywatnych.

ĆWICZENIA 1. Czym jest wolne oprogramowanie? Wymień trzy najważniejsze cechy takiego oprogramowania. 2. Dlaczego system Linux jest tak popularny? Z czym jest związana jego popularność w ośrodkach akademickich? 3. Co to jest system wielodostępny? Dlaczego takie systemy odniosły duży sukces na rynku? 4. Czym jest FSF/GNU (Free Software Foundation/GNU)? Czym jest system Linux? Które części systemu Linux są dziełem każdej z nich? Kto jeszcze przyczynił się do powstania i rozwoju systemu Linux? 5. W jakim języku został napisany system Linux? Dlaczego ten język przyczynił się do sukcesu, jaki odniósł system Linux? 6. Co to jest program narzędziowy? 7. Co to jest powłoka systemu? Jak powłoka współpracuje z jądrem systemu? Jak powłoka współpracuje z użytkownikiem? 8. Jak można użyć programów narzędziowych i powłoki systemu do utworzenia własnych aplikacji? 9. Dlaczego system plików wykorzystywany przez system Linux jest określany jako hierarchiczny? 10. Jaka jest różnica między systemem wieloprocesorowym a wieloprocesowym? 11. Podaj przykład sytuacji, w której chciałbyś użyć systemu wieloprocesowego. 12. Ilu programistów (w przybliżeniu) pracowało nad powstaniem systemu Linux? Dlaczego ten projekt jest taki unikatowy? 13. Jakie są główne założenia Powszechnej Licencji Publicznej GNU (GNU GPL)?

Część I Rozpoczynamy pracę z systemami Linux i OS X

ROZDZIAŁ 2. Wprowadzenie do systemów Linux i OS X

ROZDZIAŁ 3. Narzędzia systemu Linux

ROZDZIAŁ 4. System plików

ROZDZIAŁ 5. Powłoka systemu Linux

62  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X

Konwencje używane w tej książce  63

2 Wprowadzenie do systemów Linux i OS X

W tym rozdziale: Konwencje używane w tej książce Logowanie z poziomu terminala (emulator) Praca z poziomu wiersza poleceń powłoki Polecenia su i sudo: Ograniczanie Twojej władzy — uprawnienia superużytkownika root man — wyświetlanie podręcznika systemowego info — wyświetlanie informacji o narzędziach Opcja --help HOWTO Co zrobić, kiedy nie możesz się zalogować? Zmiana hasła

Cele rozdziału Po przeczytaniu tego rozdziału będziesz wiedział:  Jak zalogować się do systemu Linux za pomocą powłoki.  Jakie są zalety interfejsu tekstowego.  Jak poprawiać błędy powstałe podczas wpisywania poleceń w powłoce.  Jak używać polecenia kill do przerywania wykonywania programu.  Jak powtarzać i edytować poprzednio wydane polecenia.  Jaką rolę spełnia i jakie przywileje posiada użytkownik root.  Jak używać poleceń man i info w celu wyświetlania informacji o narzędziach.  Jak używać opcji --help w celu wyświetlania informacji o narzędziach.  Jak zmienić hasło z poziomu powłoki.

64  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X Niezależnie od tego, jak to się stało, siedzisz teraz przed komputerem pracującym pod kontrolą systemu Linux. Do swojej dyspozycji masz tekstowe lub graficzne środowisko pracy. W tej książce koncentrujemy się na środowisku tekstowym, nazywanym wierszem poleceń powłoki (ang. Command Line Interface, CLI). Jeżeli pracujesz w środowisku graficznym, wówczas do wykonania poleceń przedstawionych w książce będziesz musiał wykorzystać emulator terminala, na przykład xterm, Konsole, GNOME Terminal, Terminal (w systemie OS X) bądź też konsolę wirtualną. W tym rozdziale najpierw opiszemy konwencje typograficzne użyte w tej książce, a później przejdziemy do tematu logowania się do systemu. W kolejnych punktach zostanie przedstawiona powłoka, dowiesz się, jak poprawiać pomyłki popełnione w wydanych poleceniach powłoki oraz jak ponownie wykonywać już wcześniej wydane polecenia. Następnie pokrótce przedstawimy potężne możliwości, jakie daje praca z uprawnieniami superużytkownika root, i jednocześnie udzielimy Ci wskazówek, jak uniknąć pomyłek, które mogą prowadzić do uszkodzenia systemu. W dalszej części rozdziału znajdziesz sekcję, w której dowiesz się, gdzie możesz znaleźć dokumentację systemu Linux. W kolejnej sekcji dowiesz się więcej na temat logowania się oraz jak zmienić hasło dostępu do systemu. Powinieneś dokładnie zapoznać się z ostrzeżeniami zamieszczonymi w następnej sekcji, traktującymi o zagrożeniach, jakie niesie ze sobą nadużywanie lub niewłaściwe używanie przywilejów użytkownika root. Jeżeli będziesz o tym pamiętał, możesz do woli eksperymentować z systemem — spróbuj samodzielnie uruchamiać różne polecenia, tworzyć pliki, używać przykładów opisywanych w książce i po prostu dobrze się bawić.

KONWENCJE UŻYWANE W TEJ KSIĄŻCE W naszej książce używamy pewnych konwencji zapisu i formatowania, które mają na celu zwiększenie przejrzystości tekstu i ułatwienie zrozumienia omawianych zagadnień. W tej sekcji omówimy przyjęte konwencje. Odniesienia do systemu OS X w wersji 10.8 (Mountain Lion). Ponieważ w książce koncentrujemy się na rzadko zmieniających się w kolejnych wydaniach OS X komponentach tworzących system operacyjny, przedstawione w książce informacje pozostaną aktualne w kilku kolejnych wydaniach systemu OS X. Jeżeli będzie konieczne uaktualnienie informacji przedstawionych w książce, znajdziesz je na witrynie internetowej autora (http://www.sobell.com/).

OS X

Większość tekstu książki jest zapisana tzw. czcionką normalną, czyli taką, jaka została użyta do zapisania tego zdania. Przykłady kodu i poleceń omawiane w poszczególnych rozdziałach są zapisywane przy użyciu czcionki o stałym odstępie międzyznakowym (nazywanej inaczej czcionką o stałej szerokości znaku):

Tekst i przykłady

$ cat praktyka To jest przykład zawartości małego pliku utworzonego w edytorze tekstu.

Wszystko, co użytkownik powinien wpisać bezpośrednio z klawiatury, jest zapisywane czcionką pogrubioną o stałej szerokości znaków. W tekście akapitów używana jest taka czcionka pogrubiona, natomiast w kodach przykładów czcionka pogrubiona wygląda tak. W poprzednim przykładzie znak $ widoczny na początku wiersza symbolizuje znak zachęty, wyświetlany przez powłokę systemu Linux, zatem nie jest pogrubiony, natomiast reszta wiersza, obejmująca polecenie cat i jego argument, jest już wpisywana przez użytkownika, stąd została zapisana pogrubioną czcionką.

Elementy wpisywane przez użytkownika

Wszystkie nazwy poleceń są zapisywane przy użyciu czcionki o stałej szerokości Przykładowo: w książce możemy mówić o edytorze emacs, poleceniu cat czy ls, ale jeżeli mówimy o wpisaniu polecenia w oknie terminala, to będzie to wyglądało na przykład tak: ls –a. Dzięki takiemu rozwiązaniu możemy łatwo odróżnić, kiedy mówimy o narzędziach, które są programami, a kiedy o poleceniach wpisywanych z wiersza poleceń konsoli, których używamy do uruchamiania takich narzędzi.

Nazwy poleceń znaków.

Konwencje używane w tej książce  65

Nazwy plików są zapisywane przy użyciu czcionki pochylonej, na przykład memo5, list.1283 czy raporty. Nazwy plików mogą składać się z małych i wielkich liter; należy przy tym jednak pamiętać, że system Linux rozróżnia wielkość liter w nazwach plików, stąd memo5, MEMO5 i Memo5 to dla systemu Linux trzy różne pliki.

Nazwy plików

HFS+, czyli domyślny system plików OS X, nie rozróżnia wielkości liter, stąd memo5, MEMO5 i Memo5 to dla systemu OS X ten sam plik. Więcej informacji na ten temat znajdziesz w dodatku D. W treści książki pojedyncze znaki i ciągi znaków są wyróżniane czcionką pochyloną. Dzięki takiemu rozwiązaniu unikamy konieczności ujmowania ich w znaki cudzysłowu lub inne znaczniki umieszczone przed i po ciągu znaków. Na przykład polecenie passwd może wyświetlić następujący komunikat: Błędne hasło.

Ciągi znaków

Klawisze i znaki

Czcionka pochylona jest używana w następujących przypadkach:

 Nazwy klawiszy, na przykład Spacja, Enter1, Esc czy Tab.  Nazwy znaków generowanych przez naciśnięcie wybranych klawiszy, jak na przykład znaki

spacji generowane przez naciśnięcia klawisza Spacja.  Nazwy kombinacji klawiszy, wymagających naciśnięcia dwóch lub więcej klawiszy jednocześnie,

na przykład Ctrl+D (pomimo iż klawisz D jest tutaj zapisany wielką literą, nie oznacza to, że powinieneś w takiej kombinacji klawiszy naciskać dodatkowo klawisz Shift; zapis Ctrl+D oznacza po prostu, że powinieneś wcisnąć i przytrzymać klawisz Ctrl, a następnie nacisnąć klawisz oznaczony literą D). W większości przykładów widnieje znak zachęty wyświetlany przez powłokę (ang. shell prompt) — czyli sygnał, że system Linux oczekuje na wprowadzenie nowego polecenia — mający postać znaku dolara ($), kraty (#) lub czasami znaku procentu (%). W przykładach znak zachęty nie jest pogrubiony, ponieważ jest wyświetlany przez powłokę, a nie wpisywany przez użytkownika, stąd kiedy będziesz pracował z przykładami omawianymi w naszej książce, nie powinieneś wpisywać znaku zachęty — jeżeli tak zrobisz, to wpisywane polecenie zazwyczaj nie zadziała poprawnie.

Znaki zachęty i znak powrotu karetki (Enter)

We wszystkich przykładach pomijamy naciśnięcie klawisza Enter na końcu wiersza. Przykładowy zapis komendy wpisywanej w wierszu poleceń konsoli wygląda następująco: $ vim memo.1204

Aby użyć tego przykładu, powinieneś w wierszu poleceń konsoli wpisać komendę vim memo.1204 (w niektórych systemach zamiast vim trzeba napisać vim.tiny) i następnie nacisnąć klawisz Enter (aby zakończyć pracę z edytorem vim, naciśnij sekwencję poleceń Esc, Z, Z; więcej szczegółowych informacji na temat pracy z tym edytorem znajdziesz w sekcji „Poradnik: jak użyć edytora vim do utworzenia i edytowania pliku” w rozdziale 6.). Jeżeli będziesz się trzymał takiej metody postępowania, to przykłady w książce będą odpowiadały temu, co będzie się pojawiało na ekranie Twojego monitora. Wszystkie hasła w słowniczku na końcu książki, które zostały wyróżnione znacznikiem FOLDOC, są oparte na definicjach ze słownika Free On-Line Dictionary of Computing (foldoc.org) pod redakcją Denisa Howe i zamieszczone w tej książce za jego zgodą. Strona internetowa tego słownika jest ciągle rozwijającym się projektem, gdzie oprócz definicji haseł znajdziesz różne anegdoty i ciekawostki.

Definicje

1

Klawisz Enter, którego naciśnięcie przenosi kursor na początek kolejnego wiersza, na różnych klawiaturach może być oznaczany w różny sposób. W naszej książce będziemy konsekwentnie używać klawisza Enter, ale na innych klawiaturach może on być oznaczony jako Enter, NEWLINE, Ret czy jeszcze inaczej. Po prostu za każdym razem, kiedy napotkasz w książce prośbę o naciśnięcie klawisza Enter, naciśnij odpowiedni klawisz na swojej klawiaturze — przyp. autora.

66  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X INFORMACJE DODATKOWE ELEMENTY OPCJONALNE Dodatkowe informacje, rozszerzające zagadnienia omawiane w głównym nurcie książki, są umieszczone w szarych ramkach. Czasami materiał z ramki nie dotyczy bezpośrednio omawianych zagadnień, ale porusza tematy luźno z nimi powiązane. Dobrym sposobem postępowania podczas czytania książki może być początkowe pomijanie szarych ramek — możesz do nich powrócić nieco później, kiedy już nabierzesz pewnego doświadczenia z zagadnieniami omawianymi w danym rozdziale. Czytanie akapitów zamieszczonych w szarych ramkach jest najzupełniej opcjonalne.

Adresy stron internetowych, zwane w skrócie adresami URL, zaczynają się zwykle od prefiksu http:// (czasami też spotkasz inne prefiksy, takie jak ftp:// czy https://). Jeżeli dany adres rozpoczyna się od http://, to nie musisz tego prefiksu wpisywać w polu adresu przeglądarki sieciowej. Pamiętaj jednak, że w pozostałych przypadkach (na przykład dla ftp:// czy https://) wpisanie prefiksu będzie niezbędne. W przeglądarce internetowej wprowadzaj więc adresy dokładnie w takiej postaci, w jakiej zostały przedstawione w książce.

Adresy URL (adresy stron internetowych)

W tej książce wszystkie wyniki działania polecenia ls wyglądają tak, jak po dodaniu do niego opcji --time-style=ISO. Dzięki takiemu rozwiązaniu wyniki działania tego polecenia są bardziej zwięzłe i przejrzyste.

Wyniki działania polecenia ls

W elementach przedstawionych poniżej zamieszczane są dodatkowe informacje, które mogą być przydatne podczas pracy i zarządzania systemem Linux.

Wskazówki, ostrzeżenia i noty bezpieczeństwa

WSKAZÓWKA To jest ramka wskazówki. Wskazówki mogą pomóc Ci uniknąć powszechnie popełnianych błędów lub naprowadzić Cię na inne rozwiązania problemu.

OSTRZEŻENIE To jest ramka ostrzeżenia. Ostrzeżenia, jak sama nazwa wskazuje, ostrzegają Cię przed potencjalnym niebezpieczeństwem.

BEZPIECZEŃSTWO To jest ramka noty bezpieczeństwa. W notach bezpieczeństwa zamieszczane są ważne informacje o potencjalnych problemach z zabezpieczeniami Twojego systemu. Noty bezpieczeństwa są zazwyczaj przeznaczone dla administratorów systemów, ale niektóre z nich mogą być przydatne również dla szeregowych użytkowników.

LOGOWANIE SIĘ PRZY UŻYCIU TERMINALA (EMULATORA) Zanim będziesz mógł zalogować się, używając terminala, emulatora terminala lub innego urządzenia tekstowego, wiele systemów wyświetla na ekranie komunikat powitalny (ang. issue), przechowywany w pliku /etc/issue, który identyfikuje wersję systemu Linux działającą na danym komputerze, nazwę systemu oraz urządzenia używanego do zalogowania się. Przykładowy komunikat powitalny może wyglądać następująco:

Logowanie się przy użyciu terminala (emulatora)  67

Fedora release 16 (Verne) Kernel 3.3.2-6.fc16.i686 on an i686 (tty4)

Po wyświetleniu tej wiadomości na ekranie pojawia się znak zachęty do logowania. Aby się zalogować, wpisz nazwę użytkownika i hasło dostępu. Upewnij się o podaniu nazwy użytkownika i hasła dokładnie w takiej postaci, w jakiej zostały podane podczas tworzenia konta użytkownika. Procedury sprawdzające nazwę użytkownika i hasło rozróżniają wielkość liter. Podobnie jak większość systemów Linux nie wyświetla wpisywanego hasła. Domyślnie system OS X nie pozwala na zdalne logowanie się. Przedstawiony poniżej przykład pokazuje, jak Robert loguje się do systemu o nazwie tiny: tiny login: robert Password: Last login: Wed Mar 13 19:50:38 from plum [robert @tiny robert]$

Jeżeli używasz terminala, a na ekranie nie pojawia się komunikat login:, sprawdź, czy terminal jest poprawnie podłączony i włączony, a następnie naciśnij kilka razy klawisz Enter. Jeżeli komunikat login: nadal nie pojawia się na ekranie, spróbuj nacisnąć kombinację klawiszy Ctrl+Q (Xon).

BEZPIECZEŃSTWO Czy to Ty logowałeś się ostatnim razem? Kiedy logujesz się do systemu pracującego w trybie tekstowym, to po wpisaniu poprawnej nazwy użytkownika i hasła system może wyświetlić na ekranie informacje o ostatnim udanym zalogowaniu się użytkownika na tym koncie. Oprócz daty i czasu system wyświetla informacje o tym, skąd nastąpiło logowanie. Dzięki takim informacjom możesz zorientować się, czy ktoś korzystał z Twojego konta od czasu Twojego ostatniego logowania. Jeżeli podejrzewasz, że tak, to być może jakiś nieautoryzowany użytkownik zdołał podpatrzeć hasło do Twojego konta i zalogował się na nie, udając Ciebie. W takiej sytuacji powinieneś niezwłocznie powiadomić administratora systemu o swoich podejrzeniach i oczywiście natychmiast zmienić hasło do swojego konta. Jeżeli używasz komputera Mac, PC lub innej stacji roboczej, uruchom program ssh, telnet lub inny pakiet komunikacyjny, za pomocą którego możesz się logować do komputera zdalnego. Podaj nazwę lub adres IP systemu, do którego chcesz się zalogować.

BEZPIECZEŃSTWO telnet nie jest bezpieczny telnet nie jest bezpieczny, ponieważ podczas logowania nazwa użytkownika i hasło są przesyłane poprzez sieć w postaci nieza-

szyfrowanej. Istnieje więc niebezpieczeństwo, że ktoś może przechwycić te informacje i zalogować się do Twojego konta. Narzędzie szyfruje wszystkie informacje przekazywane poprzez sieć i dlatego jest lepszym rozwiązaniem niż telnet. Program ssh umożliwiający połączenie ze zdalnym systemem za pośrednictwem protokołu o tej samej nazwie został zaimplementowany w wielu różnych systemach operacyjnych, a nie tylko w systemie Linux. Wiele interfejsów użytkownika potrafi używać emulatora terminala i połączenia ssh. ssh

Poniżej przedstawiono przykład zalogowania się do systemu Linux za pomocą ssh: $ ssh robert@tiny robert@tiny's password: Permission denied, please try again. robert @tiny's password: Last login: Wed Mar 13 21:21:49 2005 from plum [robert @tiny robert]$

W powyższym przykładzie Robert pomylił się podczas podawania hasła, co spowodowało wyświetlenie komunikatu błędu oraz ponownie znaku zachęty, po którym Robert podał już prawidłowe hasło. Jeżeli nazwa użytkownika jest taka sama jak w systemie, z którego się logujesz, to możesz ją pominąć wraz ze znakiem at (@). W omawianym przykładzie Robert mógłby wydać polecenie ssh tiny.

68  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X Kiedy na ekranie pojawi się znak zachęty powłoki systemu (ang. shell prompt), będzie to oznaczało, że zalogowałeś się pomyślnie — w ten sposób powłoka systemu daje znać, że jest gotowa przyjąć Twoje polecenia. Przed pierwszym znakiem zachęty powłoki systemu na ekranie może się jeszcze pojawić krótka wiadomość, nazywana wiadomością dnia (motd — ang. message of the day), która jest przechowywana w pliku /etc/motd. Domyślnie w systemie Linux znak zachęty powłoki to po prostu znak dolara ($). Nie martw się, jeśli w używanym przez Ciebie systemie znak zachęty ma inną postać. Przykłady przedstawione w tej książce działają niezależnie od sposobu wyświetlania znaku zachęty powłoki. W zaprezentowanym wcześniej przykładzie znak zachęty $ (ostatni wiersz) jest poprzedzony nazwą użytkownika (robert), znakiem @, nazwą systemu (tiny) i nazwą aktualnego katalogu (robert). Więcej szczegółowych informacji na temat sposobów zmiany znaku zachęty znajdziesz w rozdziale 8.

WSKAZÓWKA Upewnij się o prawidłowej konfiguracji zmiennej TERM Zmienna powłoki TERM pozwala na zdefiniowanie pseudograficznych cech terminala tekstowego lub emulatora terminala. Wymieniona zmienna najczęściej jest już zdefiniowana w systemie, więc nie musisz jej konfigurować samodzielnie. Jeżeli dane wyświetlane na ekranie wyglądają dziwnie, zajrzyj do punktu „Definiowanie typu terminala”, który znajdziesz w dodatku B.

PRACA Z POZIOMU WIERSZA POLECEŃ POWŁOKI Zanim w systemie Linux pojawił się graficzny interfejs użytkownika (GUI — ang. graphical user interface), UNIX i następnie Linux posiadały wyłącznie interfejsy tekstowe, czyli inaczej mówiąc, interakcja z systemem odbywała się za pomocą wiersza poleceń powłoki systemu. Obecnie konsola tekstowa w systemie Linux jest dostępna, kiedy logujesz się z poziomu terminala, emulatora terminala, tekstowej konsoli wirtualnej lub zdalnie, za pośrednictwem protokołu ssh (połączenie szyfrowane, bezpieczne) lub telnet (połączenie nieszyfrowane, brak zabezpieczeń). Choć sama idea pracy w konsoli tekstowej może wydawać się nieco anachroniczna, to jednak wiersz poleceń powłoki systemu nadal zajmuje silne miejsce we współczesnych systemach komputerowych. W niektórych przypadkach administratorzy systemów wolą korzystać z narzędzi konsolowych, ponieważ ich odpowiedniki graficzne albo nie istnieją, albo nie są tak elastyczne i wygodne w użytkowaniu jak narzędzia konsolowe. Na przykład polecenie chmod ma znacznie większe możliwości i jest dużo bardziej elastyczne niż jego graficzny odpowiednik. Bardzo często zdarza się również, zwłaszcza w systemach serwerowych, że środowisko graficzne po prostu nawet nie jest zainstalowane. Pierwszym powodem takiego stanu rzeczy jest to, że graficzne interfejsy użytkownika zużywają duże ilości zasobów systemowych, które w przypadku serwerów można przeznaczyć na zupełnie inne zadania. Oprócz tego ze względów bezpieczeństwa w każdym systemie powinny działać tylko takie usługi i procesy, które są rzeczywiście niezbędne — każdy dodatkowy proces i każda dodatkowa usługa zwiększają potencjalną podatność takiego systemu na atak czy awarię.

Zalety pracy z poziomu wiersza poleceń powłoki

Ogromną zaletą pracy z tekstową powłoką systemu jest możliwość pisania skryptów. Dzięki odpowiednio przygotowanym skryptom możesz łatwo wykonywać złożone zadania w powtarzalny sposób w wielu systemach, co umożliwia łatwe skalowanie zadań w dużych środowiskach. Jeżeli jednak jesteś administratorem tylko jednego systemu, to użycie graficznego interfejsu użytkownika może być rzeczywiście najłatwiejszym sposobem zarządzania takim systemem. Jeżeli jednak pracujesz jako administrator wielu systemów, z których każdy musi być skonfigurowany i aktualizowany w taki sam sposób, użycie odpowiednio spreparowanych skryptów może znacząco ułatwić i przyspieszyć realizację takich zadań. Pisanie skryptów powłoki wykonujących nawet złożone operacje jest zadaniem relatywnie prostym, podczas gdy w przypadku narzędzi wykorzystujących interfejsy graficzne realizacja takich zadań może być mocno utrudniona lub wręcz niemożliwa.

Praca z poziomu wiersza poleceń powłoki  69

Przed pojawieniem się graficznych interfejsów użytkownika wielu zdolnych programistów tworzyło programy wyposażone w interfejsy tekstowe, które posiadały elementy „graficzne” takie jak ramki, obramowania, podświetlanie zaznaczonych elementów, a nawet wykorzystywały kolory — oczywiście wszystkie elementy były tworzone za pomocą specjalnych znaków tekstowych. Takie pseudograficzne interfejsy użytkownika, nazywane bardziej poprawnie interfejsami semitekstowymi, w swoim czasie wypełniły lukę pomiędzy interfejsami tekstowymi a pełnym, graficznym interfejsem użytkownika. Dobrym przykładem narzędzia, które w doskonały sposób wykorzystuje wspomniany semitekstowy interfejs, jest menedżer plików Midnight Commander (mc).

Interfejs semitekstowy

Z KTÓREJ POWŁOKI KORZYSTASZ? W tej książce zostały omówione powłoki Bourne Again Shell (bash) i TC Shell (tcsh). Prawdopodobnie korzystasz z powłoki bash, choć równie dobrze może być to tcsh bądź inna, na przykład Z Shell (zsh). Po wydaniu polecenia echo $0 i naciśnięciu klawisza Enter na ekranie zostanie wyświetlona informacja o aktualnie używanej powłoce. Wymienione polecenie działa, ponieważ powłoka rozwija argument $0 na postać nazwy uruchomionego programu. Poniżej przedstawiono przykładowe dane wyjściowe omawianego polecenia: $ echo $0 -bash

W systemie lokalnym mogą być wyświetlone następujące dane wyjściowe: $ echo $0 /bin/bash

Wyświetlone dane jednoznacznie wskazują, że używana jest powłoka powłoki, dane wyjściowe będą zawierały jej nazwę.

bash.

Jeśli korzystasz z innej

POPRAWIANIE BŁĘDÓW W tej sekcji wyjaśnimy, jak poprawiać literówki i inne błędy, które możesz popełnić podczas pracy z interfejsem tekstowym. Ponieważ powłoka i większość narzędzi konsolowych nie interpretuje komend i tekstów wpisywanych w wierszu poleceń aż do momentu naciśnięcia klawisza Enter, to zanim naciśniesz ten klawisz, możesz spokojnie poprawić wszystkie popełnione błędy. Poprawki możesz wprowadzać na kilka sposobów: możesz usuwać po jednym znaku, kasować po jednym słowie lub usuwać od razu cały wprowadzony wiersz. Po naciśnięciu klawisza Enter jest już zbyt późno na korekty — w takiej sytuacji musisz albo czekać, aż wywołany program zakończy pracę, albo przerwać jego działanie.

USUWANIE ZNAKÓW Podczas wpisywania znaków z klawiatury możesz w każdej chwili cofnąć się i usunąć błędnie wprowadzone znaki, naciskając raz za razem klawisz wymazywania znaków (ang. erase key). Za pomocą kolejnych naciśnięć takiego klawisza możesz usunąć dowolną liczbę znaków, z tym że nie możesz się cofnąć poza początek wiersza poleceń. Domyślnym klawiszem wymazywania znaków jest oczywiście klawisz Backspace. Jeżeli ten klawisz z jakiegoś powodu nie działa, możesz wypróbować klawisz Del lub kombinację klawiszy Ctrl+H. Jeżeli żaden z tych klawiszy nie działa, możesz wykonać następujące polecenie stty2, które powinno przywrócić ustawienia klawiszy usuwania znaków i wierszy (patrz sekcja „Usuwanie całego wiersza”) na wartości domyślne: $ stty ek

2

Polecenie stty to skrót od ang. set teletypewriter, czyli ustaw dalekopis, który był pierwszym typem terminala, na którym pracował system UNIX. Obecnie polecenie stty jest tłumaczone jako set terminal, czyli ustaw terminal.

70  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X Inna możliwość to wydanie poniższego polecenia, które wyzeruje większość parametrów terminala i przypisze im akceptowane wartości. Jeżeli naciśnięcie klawisza Enter nie przeniesie kursora do kolejnego wiersza, naciśnij kombinację Ctrl+J. $ stty sane

Więcej przykładów użycia polecenia stty znajdziesz w części VI książki.

USUWANIE CAŁYCH SŁÓW Aby usunąć całe wprowadzone słowo, powinieneś nacisnąć kombinację klawiszy Ctrl+W. W tym przypadku określenie słowo odnosi się do dowolnej sekwencji znaków niezawierającej znaków spacji ani tabulatora. Kiedy naciśniesz kombinację klawiszy Ctrl+W, kursor przesunie się na początek bieżącego słowa (jeżeli ciągle je wprowadzasz) lub na początek poprzedniego słowa (kiedy już zakończyłeś jego wprowadzanie, naciskając klawisz Spacja lub Tab), usuwając je w całości.

WSKAZÓWKA Kombinacja klawiszy Ctrl+Z wstrzymuje działanie programu Choć nie jest to sposób poprawiania błędów, możesz przez przypadek nacisnąć kombinację klawiszy, która wstrzymuje działanie programu (domyślnie jest to Ctrl+Z), i następnie zastanawiać się, co się tak naprawdę wydarzyło. Jeżeli na ekranie widzisz komunikat zawierający słowo Stopped, to znaczy, że właśnie wstrzymałeś działanie bieżącego programu. Jeżeli teraz wykonasz polecenie fg, które ponownie uruchomi wstrzymany program jako proces pierwszoplanowy, powinieneś powrócić do takiego miejsca działania programu, w którym byłeś tuż przed naciśnięciem klawisza wstrzymania. Więcej szczegółowych informacji na temat sterowania zadaniami znajdziesz w sekcji „Polecenie bg — wysyłanie zadania do pracy w tle” w rozdziale 8.

USUWANIE CAŁEGO WIERSZA W dowolnym momencie przed naciśnięciem klawisza Enter możesz usunąć cały wprowadzony wiersz polecenia, naciskając klawisz usuwania wiersza (ang. line kill key). Kiedy naciśniesz taki klawisz, kursor przesuwa się w lewo aż na początek wiersza, usuwając wszystkie znaki, jakie napotka po drodze. Domyślnym klawiszem usuwania wiersza jest kombinacja Ctrl+U. Jeżeli taka kombinacja klawiszy nie zadziała, wypróbuj kombinację klawiszy Ctrl+X. Jeżeli również taka kombinacja nie zadziała, wykonaj polecenie stty opisane w sekcji „Usuwanie znaków”. PRZERYWANIE DZIAŁANIA PROGRAMU Czasami może się zdarzyć, że z takiego czy innego powodu będziesz chciał przerwać wykonywanie jakiegoś programu. Na przykład możesz chcieć przerwać działanie programu wyświetlającego na ekranie zawartość dokumentu składającego się z kilkuset stron czy kopiowanie ogromnego pliku, którego wcale nie chciałeś skopiować. Aby zatrzymać program działający na poziomie konsoli tekstowej, powinieneś nacisnąć klawisz przerwania pracy programu (ang. interrupt key), którym zazwyczaj jest kombinacja Ctrl+C lub czasami klawisz Del (Delete). Kiedy naciśniesz ten klawisz, Linux wyśle sygnał zakończenia pracy zarówno do programu, jak i do powłoki, z której został uruchomiony. Efekt działania takiego sygnału zależy od samego programu. Niektóre programy natychmiast przerywają działanie, niektóre ignorują taki sygnał, a niektóre robią jeszcze coś innego. Kiedy powłoka odbierze taki sygnał, wyświetla na ekranie znak zachęty i oczekuje na wprowadzenie kolejnego polecenia. Jeżeli opisana wyżej metoda nie spowoduje przerwania działania programu, możesz spróbować wysłać do niego sygnał zakończenia pracy (kombinacja klawiszy Ctrl+\). Jeżeli wszystko inne zawiedzie, spróbuj nacisnąć klawisz wstrzymania działania programu (zazwyczaj Ctrl+Z), następnie wykonaj polecenie jobs, aby sprawdzić numer zadania, i następnie zakończ zadanie poleceniem kill. Numer zadania jest wyświetlany w nawiasach kwadratowych po lewej stronie wyników działania polecenia

Praca z poziomu wiersza poleceń powłoki  71

jobs

(na przykład [1]). W kolejnym przykładzie polecenie kill wykorzystuje opcję -TERM do wysłania sygnału zakończenia działania do procesu określonego przez numer zadania poprzedzony znakiem procentu (%1). W zasadzie możesz pominąć opcję -TERM, ponieważ polecenie kill domyślnie wysyła sygnał zakończenia działania. $ duze_zadanie ^Z [1]+ Stopped duze_zadanie $ jobs [1]+ Stopped duze_zadanie $ kill -TERM %1 [1]+ Killed duze_zadanie

OSTRZEŻENIE Sygnał KILL stosuj jedynie w ostateczności Kiedy sygnał przerwania pracy programu nie działa, wówczas użyj sygnału KILL (w poleceniu podaj -KILL zamiast -TERM). Uruchomiony program nie może zignorować sygnału KILL, a tym samym masz pewność, że działanie programu zostanie przerwane. Ponieważ program otrzymujący sygnał KILL nie ma szans zamknięcia otwartych plików przed zakończeniem swojego działania, użycie sygnału KILL może doprowadzić do uszkodzenia danych. Sygnał KILL stosuj jedynie w ostateczności. Zanim zdecydujesz się na użycie sygnału KILL, najpierw spróbuj wysłać programowi sygnał TERM lub QUIT i odczekaj co najmniej dziesięć sekund, aby przekonać się, czy użycie wymienionych sygnałów przyniosło oczekiwany efekt. Po wykonaniu polecenia kill powinien ponownie pojawić się znak zachęty powłoki, aczkolwiek czasami wymaga to naciśnięcia klawisza Enter. Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Uruchamianie procesów drugoplanowych” w rozdziale 5.

POWTARZANIE I EDYTOWANIE POLECEŃ POWŁOKI Aby powtórzyć poprzednie polecenie, powinieneś nacisnąć klawisz strzałka w górę (). Za każdym naciśnięciem tego klawisza powłoka będzie wyświetlała wcześniej wykonane polecenie. Aby ponownie wykonać polecenie wyświetlone aktualnie w wierszu poleceń, naciśnij klawisz Enter. Aby przeglądać listę poleceń w przeciwnym kierunku, naciskaj kolejno klawisz strzałka w dół (). Klawisze strzałka w lewo () oraz strzałka w prawo () przesuwają kursor tam i z powrotem wzdłuż wiersza polecenia. Nowe znaki możesz dodać w dowolnym miejscu wiersza poleceń. Aby to zrobić, po prostu ustaw kursor w odpowiednim miejscu i rozpocznij wpisywanie. Aby usunąć znaki z wiersza poleceń, użyj klawisza kasowania. Naciśnięcia klawisza Enter spowoduje wykonanie zmodyfikowanego polecenia. Poprzednio wykonane polecenie możesz powtórzyć, wpisując dwa znaki wykrzyknika (!!). Taka technika jest bardzo użyteczna, jeżeli przed wykonaniem polecenia zapomniałeś użyć komendy su. Jeżeli w takim przypadku wpiszesz polecenie su -c "!!", to powłoka ponownie wykona ostatnio wykonane polecenie, z tym że tym razem na prawach użytkownika root. Jeżeli system lokalny został skonfigurowany do używania sudo, możesz wydać polecenie sudo !!, a powłoka wykona poprzednie polecenie wraz z uprawnieniami użytkownika root. Polecenie ^stare^nowe^ również powoduje wykonanie poprzednio wykonanego polecenia, zamieniając przed tym ciąg znaków stare na ciąg znaków nowe. Dodatkowo w wierszu poleceń powłoka zamienia ciąg znaków !$ z ostatnim argumentem poprzedniego polecenia. Przykład przedstawiony poniżej pokazuje użytkownika, który poprawia nazwę pliku z meno na memo przy użyciu polecenia ^n^m^ i następnie drukuje zawartość pliku memo przy użyciu polecenia lpr !$. Powłoka automatycznie zastąpi ciąg znaków !$ nazwą pliku memo, czyli ostatnim argumentem poprzedniego polecenia (cat).

72  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X $ cat meno cat: meno: Nie ma takiego pliku ani katalogu $ ^n^m^ cat memo To jest zawartość pliku memo. $ lpr !$ lpr memo

Więcej informacji na temat zaawansowanych sposobów edytowania poleceń wpisywanych w wierszu poleceń znajdziesz w rozdziale 8.

POLECENIA SU I SUDO: OGRANICZANIE TWOJEJ WŁADZY — UPRAWNIENIA SUPERUŻYTKOWNIKA ROOT W systemach UNIX i Linux zawsze jest uprzywilejowany użytkownik o nazwie root. Kiedy jesteś zalogowany jako użytkownik o nazwie root, możemy powiedzieć, że jesteś superużytkownikiem lub inaczej administratorem systemu, pracujesz na prawach użytkownika root i posiadasz uprawnienia do wykonywanie nadzwyczajnych operacji. Kiedy pracujesz na prawach użytkownika root, możesz odczytywać i zapisywać niemal dowolne pliki znajdujące się w systemie, wykonywać programy, których nie mogą uruchomić szeregowi użytkownicy, i wiele więcej. W systemie wieloużytkownikowym możesz nie mieć prawa posiadania hasła użytkownika root, a co za tym idzie, także możliwości uruchamiania niektórych programów. Ale to inna para kaloszy — tak czy inaczej ktoś, czyli administrator systemu, zna hasło użytkownika root i właśnie ta osoba zajmuje się zarządzaniem danym systemem.

OSTRZEŻENIE Nie eksperymentuj podczas pracy z uprawnieniami użytkownika root Możesz do woli eksperymentować, kiedy nie pracujesz z uprawnieniami użytkownika root. Jednak kiedy pracujesz na prawach tego użytkownika, powinieneś wykonywać tylko takie zadania, które naprawdę musisz wykonać, i to pod warunkiem, że dokładnie wiesz, co robisz i jakie będą tego rezultaty. Po wykonaniu danego zadania powinieneś jak najszybciej przelogować się i powrócić na swoje konto „normalnego” użytkownika. Pamiętaj, że niewłaściwie posługując się uprawnieniami, jakie daje konto użytkownika root, możesz uszkodzić system w taki sposób, że będzie konieczne całkowite przeinstalowanie systemu Linux. W tradycyjnie skonfigurowanym systemie uprawnienia użytkownika root możesz uzyskać na dwa sposoby. Pierwszy polega na zalogowaniu się do systemu jako root — w tym przypadku uprawnienia root masz aż do chwili wylogowania się. Drugi sposób możesz wykorzystać, kiedy pracujesz w ramach zwykłego konta użytkownika — uprawnienia root możesz uzyskać do wykonania pojedynczego polecenia, poprzedzając je poleceniem su (ang. substitute user, zamiana użytkownika), lub tymczasowo w celu wykonania kilku poleceń. Zalogowanie się jako root wymaga podania hasła dostępu dla użytkownika root. Przedstawiony poniżej przykład pokazuje, jak wykorzystać su do wykonania pojedynczego polecenia: $ ls -l /lost+found ls: nie można otworzyć katalogu /lost+found: Brak dostępu $ su -c 'ls -l /lost+found' Hasło: Tutaj podaj hasło użytkownika root total 0 $

Pierwsze polecenie w powyższym bloku pokazuje, że użytkownik, który nie posiada uprawnień root, nie może wyświetlić listy plików w katalogu /lost+found. Próba wykonania polecenia ls kończy się otrzymaniem komunikatu błędu. W drugim poleceniu użyto su wraz z opcją -c, co pozwala na wykonanie

Gdzie szukać dokumentacji systemu?  73

polecenia ls z uprawnieniami root. Ujęcie polecenia w apostrofy gwarantuje jego prawidłową interpretację przez powłokę. Po zakończeniu wykonywania polecenia (ls informuje o braku plików we wskazanym katalogu) użytkownik nie ma już uprawnień root. Jeżeli nie zostaną podane żadne argumenty, su rozpoczyna nową sesję powłoki wraz z uprawnieniami root. Gdy masz uprawnienia root, wiersz zachęty powłoki najczęściej wyświetla znak #. Wydanie polecenia exit powoduje powrót do sesji powłoki użytkownika bez uprawnień root. $ su Hasło: Tutaj podaj hasło użytkownika root # ls -l /lost+found total 0 # exit exit $

W niektórych dystrybucjach (na przykład Ubuntu) konto użytkownika root jest domyślnie zablokowane — nie ma zdefiniowanego hasła root. Do nadawania użytkownikom uprawnień root stosowane jest wówczas polecenie sudo (http://www.sudo.ws/). Aby otrzymać uprawnienia root, w poleceniu sudo musisz podać własne hasło, a nie hasło użytkownika root. Przedstawiony poniżej przykład pokazuje, jak użytkownik uzyskuje uprawnienia root w celu wyświetlenia zawartości katalogu /lost+found. $ sudo ls -l /lost+found [sudo] password for robert: total 0 $

Tutaj podaj swoje hasło

W przypadku użycia opcji -s polecenie sudo powoduje rozpoczęcie nowej sesji powłoki z uprawnieniami root. Gdy masz uprawnienia root, wiersz zachęty powłoki najczęściej wyświetla znak #. Wydanie polecenia exit powoduje powrót do sesji powłoki użytkownika bez uprawnień root. $ sudo -s [sudo] password for robert: # ls -l /lost+found total 0 # exit logout $

Tutaj podaj swoje hasło

GDZIE SZUKAĆ DOKUMENTACJI SYSTEMU? Niemal żadna dystrybucja systemu Linux nie jest wyposażona w drukowany komplet podręczników użytkownika. Z drugiej jednak strony, dokumentacja dostępna online w sieci Internet była zawsze mocną stroną systemów Linux. Dokładna dokumentacja w postaci stron man oraz info była dostępna poprzez narzędzia o tych samych nazwach, począwszy od pierwszych wersji tego systemu operacyjnego. Nie będzie dla nikogo zaskoczeniem, jeżeli powiemy, że wraz z rozwojem systemu Linux oraz upowszechnieniem dostępu do sieci Internet zasoby dokumentacji tego systemu również znacząco się powiększyły. W tej sekcji poznasz niektóre miejsca, do których warto zajrzeć w poszukiwaniu informacji na temat systemu Linux (zajrzyj również do dodatku B).

POLECENIE MAN — WYŚWIETLANIE TEMATÓW POMOCY Polecenie man pracuje w trybie tekstowym i wyświetla strony podręcznika systemowego, zawierającego szczegółową dokumentację wszystkich poleceń systemu. Taka dokumentacja jest bardzo przydatna zwłaszcza w sytuacji, kiedy pamiętasz, jakiego polecenia chciałeś użyć, ale zupełnie zapomniałeś, jaką ono ma składnię. Z podręcznika man możesz również korzystać w sytuacji, kiedy chcesz uzyskać więcej informacji na wybrany temat lub sprawdzić określone możliwości systemu Linux. Ponieważ opisy zamieszczone w podręczniku systemowym są często bardzo zwięzłe i techniczne, najczęściej przydają się w sytuacji, kiedy już znasz podstawowe funkcje i sposób działania danego narzędzia.

74  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X Jeżeli chcesz dowiedzieć się czegoś więcej o samym narzędziu, wpisz w oknie terminala polecenie man, po którym wpisz nazwę tego polecenia, czyli powtórnie man. Na rysunku 2.1 przedstawiono wygląd narzędzia man wyświetlającego strony podręcznika systemowego dotyczące samego narzędzia man po wykonaniu polecenia man man.

Rysunek 2.1. Narzędzie man wyświetlające informacje o samym sobie

Polecenie man wysyła dane na ekran za pośrednictwem narzędzia stronicującego (ang. pager) — zazwyczaj jest to polecenie less, które wyświetla dane przesyłane na jego wejście po jednej stronie (ekranie) na raz. Kiedy wyświetlasz strony podręcznika man, polecenie less wyświetla w ostatnim wierszu okna terminala informację o kolejnej wyświetlonej stronie (na przykład Manual page man(1) line 1) i oczekuje, aż zażądasz wykonania jednego z wymienionych poniżej kroków:

Polecenie less (strona po stronie)

 Naciśnięcie klawisza Spacja spowoduje wyświetlenie kolejnej strony tekstu.  Naciśnięcie tradycyjnych klawiszy nawigacyjnych, takich jak PageUp, PageDown, strzałka

w górę () czy strzałka w dół (), pozwala na poruszanie się po tekście.  Naciśnięcie klawisza h (ang. help) wyświetla listę komend polecenia less.  Naciśnięcie klawisza q (ang. quit) zatrzymuje działanie polecenia less i przekazuje sterowanie

do powłoki. Tematy pomocy oferowanej przez polecenie man możesz również przeszukiwać za pomocą narzędzia o nazwie apropos (patrz kolejna sekcja). W oparciu o strukturę FHS (ang. Filesystem Hierarchy Standard) dokumentacja systemu Linux oraz strony podręcznika man podzielone zostały na dziesięć sekcji, a każda z nich opisuje zestaw powiązanych z nią narzędzi: 1. Polecenia użytkownika. 2. Wywołania systemowe. 3. Podprogramy. 4. Urządzenia. 5. Formaty plików. 6. Gry. 7. Inne. 8. Administracja systemu. 9. Jądro. 10. Nowe.

Sekcje podręcznika

Gdzie szukać dokumentacji systemu?  75

Taki podział blisko naśladuje tradycyjny sposób, w jaki podzielone zawsze były podręczniki systemu UNIX. Jeżeli nie określisz sekcji podręcznika, polecenie man zawsze wyświetli tę sekcję podręcznika, w której znajduje się pierwsze wystąpienie poszukiwanego słowa. Większość użytkowników znajduje poszukiwane informacje w sekcjach 1., 6. i 7., a z kolei programiści i administratorzy systemu bardzo często poszukują informacji również w innych sekcjach. W niektórych przypadkach w podręczniku znajdują się opisy różnych narzędzi posiadających jednak tę samą nazwę. Na przykład polecenie przedstawione poniżej wyświetla strony podręcznika man dla polecenia passwd z sekcji 1. podręcznika systemowego: $ man passwd

Aby zobaczyć strony podręcznika man dla pliku passwd z sekcji 5. podręcznika systemowego, powinieneś wpisać następujące polecenie: $ man 5 passwd

Powyższe polecenie powoduje, że man sięga tylko sekcji 5. podręcznika systemowego. W dokumentacji systemowej odwołania do takiej strony są oznaczane jako passwd(5). Aby wyświetlić wszystkie strony podręcznika man dla danego tematu, powinieneś użyć opcji –a (zapoznaj się ze wskazówką przedstawioną poniżej), strony z kolejnych sekcji możesz wyświetlić, naciskając sekwencje klawiszy q, Enter. Na przykład: aby wyświetlić wszystkie strony podręcznika dla hasła passwd, powinieneś wykonać polecenie man –a passwd.

WSKAZÓWKA Opcje Opcje modyfikują sposób działania danego polecenia. Opcje większości poleceń mają postać jednej lub kilku liter poprzedzonych jednym lub dwoma myślnikami. Zazwyczaj opcje umieszczane są po nazwie polecenia i są od niej oddzielone znakiem spacji. Inne argumenty polecenia umieszczane są zazwyczaj za opcjami i również są od nich oddzielone znakiem spacji. Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Wiersz poleceń” w rozdziale 5.

POLECENIE APROPOS — WYSZUKIWANIE SŁÓW KLUCZOWYCH Jeżeli nie znasz nazwy polecenia potrzebnego do wykonania danego zadania, możesz użyć polecenia apropos do wyszukiwania słów kluczowych w tematach pomocy. Polecenie apropos przeszukuje wiersze opisów poleceń na stronach podręcznika systemowego man i wyświetla na ekranie wszystkie opisy poleceń pasujących do wzorca. Polecenie man posiada również opcję –k (od ang. keyword), której działanie jest identyczne jak działanie polecenia apropos. Baza danych, z której korzysta polecenie apropos nosi nazwę mandb lub makewhatis. Żadna z tych baz nie jest domyślnie dostępna po zainstalowaniu systemu — zamiast tego są one automatycznie budowane przez zadania demona crond. (Aby dowiedzieć się więcej na temat crond, zapoznaj się z przedstawionym w części VI książki opisem crontab). Przykład zamieszczony poniżej przedstawia wyniki działania polecenia apropos wywołanego z argumentem w postaci słowa kluczowego who. W wynikach działania wyświetlana jest nazwa odszukanego polecenia, sekcja podręcznika, w której zostało znalezione, oraz krótki opis polecenia pobrany z podręcznika man. Jak widać, w wynikach działania programu znalazło się polecenie, którego poszukiwaliśmy (who), oraz szereg innych, najczęściej powiązanych ze sobą poleceń, które również mogą okazać się użyteczne. $ apropos who at.allow (5) jwhois (1) w (1) who (1)

-

determine who can submit jobs via at or batch client for the whois service Show who is logged on and what they are doing. pokaż, kto jest zalogowany

76  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X who (1p) whoami (1) whois (1) whois.jwhois (1)

-

display who is on the system wydrukuj efektywny id użytkownika client for the whois service client for the whois service

Polecenie whatis jest nieco podobne w działaniu do polecenia jedynie całe słowa pasujące do podanego wzorca:

whatis

$ whatis who who (1p) who (1)

apropos,

z tym że wyszukuje

- display who is on the system - pokaż, kto jest zalogowany

POLECENIE INFO — WYŚWIETLANIE INFORMACJI O NARZĘDZIACH Polecenie info (patrz strona http://www.gnu.org/software/texinfo/manual/info/) to pracujący w trybie tekstowym, oparty na menu system hipertekstowy, opracowany w ramach projektu GNU i rozpowszechniany z systemem Linux. W pakiecie znajduje się krótki podręcznik opisujący korzystanie z tego polecenia (aby go wyświetlić, wykonaj polecenie info info) oraz dokumentację wielu powłok używanych w systemach Linux oraz wielu narzędzi, poleceń i programów opracowanych w ramach projektu GNU. Na rysunku 2.2 przedstawiono wygląd ekranu po wykonaniu polecenia info coreutils (pakiet coreutils zawiera szereg podstawowych narzędzi systemu Linux).

Rysunek 2.2. Pierwsza strona wyników działania polecenia info coreutils

WSKAZÓWKA Polecenia man i info wyświetlają różne informacje Polecenie info wyświetla dokładniejsze i bardziej aktualne informacje o narzędziach GNU niż polecenie man. Jeżeli strony podręcznika wyświetlane przez polecenie man zawierają tylko skrócony opis polecenia, którego pełny opis jest dostępny w bazie polecenia info, strona podręcznika man zawiera odwołanie do polecenia info. Strony podręcznika man bardzo często zawierają tylko opisy poleceń, które nie powstały w ramach projektu GNU. Z kolei kiedy polecenie info wyświetla informacje o poleceniu spoza projektu GNU, jest to bardzo często kopia strony podręcznika man. Ponieważ informacje na ekranie są pobierane z pliku edytowalnego, to wyniki działania tych poleceń widoczne na ekranie Twojego komputera mogą się różnić od tych zamieszczonych w naszej książce. Kiedy na ekranie wyświetlona jest pierwsza strona podręcznika info, możesz nacisnąć dowolny z klawiszy omawianych poniżej:  H lub ?, aby wyświetlić listę komend polecenia info.  Spacja, aby przewijać wyświetlany tekst.

Gdzie szukać dokumentacji systemu?  77

 M, po którym następuje nazwa menu, które chcesz wyświetlić, lub Spacja, aby wyświetlić listę

dostępnych menu.  Q lub Ctrl+C, aby zakończyć działanie polecenia info. Konwencja zapisu nazw klawiszy i kombinacji wykorzystywana przez polecenie info jest taka sama jak stosowana w edytorze emacs i może wydawać się nieco nietypowa. Na przykład zapis C-h oznacza to samo co Ctrl+H, a zapis M-x oznacza, że powinieneś wcisnąć i przytrzymać klawisz Meta (lub inaczej klawisz Alt), a następnie nacisnąć klawisz X (aby to osiągnąć w niektórych systemach, musisz nacisnąć klawisz Esc, a następnie klawisz X). Więcej informacji na ten temat znajdziesz w rozdziale 7. Po wykonaniu polecenia info coreutils przewiń tekst na ekranie, naciskając kilka razy klawisz Spacja. Jeżeli chcesz wyszukać na przykład frazę sleep, wpisz /sleep i naciśnij klawisz Enter. Kiedy naciśniesz klawisz /, kursor zostanie przeniesiony do dolnego wiersza okna, gdzie pojawi się komunikat: Szukanie wyr. Reg. []:, gdzie to ostatnio wyszukiwany ciąg znaków. Naciśnij klawisz Enter, aby wyszukać poprzedni ciąg znaków, lub wpisz nowe wyrażenie. Ponowne wpisanie tego samego wyrażenia i naciśnięcie klawisza Enter spowoduje wyszukanie jego następnego wystąpienia w tekście.

WSKAZÓWKA Polecenie pinfo może być łatwiejsze w użyciu niż info Polecenie pinfo jest bardzo podobne do info, ale jest bardziej intuicyjne, zwłaszcza jeżeli nie masz doświadczenia w pracy z edytorem emacs. Polecenie pinfo działa w środowisku tekstowym, podobnie jak info. Jeżeli wyświetlanie kolorów jest dostępne, polecenie pinfo używa ich do zwiększenia przejrzystości interfejsu użytkownika. Jeżeli polecenie pinfo nie jest zainstalowane w Twoim systemie, możesz zainstalować pakiet pinfo — sposób instalacji pakietów oprogramowania przedstawiono w dodatku C. Teraz naciśnij klawisz / i następnie klawisz Enter (lub od razu wpisz ciąg znaków /sleep i naciśnij klawisz Enter), aby wyszukać kolejne wystąpienie frazy sleep, tak jak to zostało zilustrowane na rysunku 2.3. Znak gwiazdki wyświetlany z lewej strony wiersza oznacza, że jest to nazwa elementu menu. Po znaku gwiazdki wyświetlana jest nazwa menu i jego opis.

Rysunek 2.3. Wygląd okna terminala po wykonaniu polecenia info coreutils i dwukrotnym wyszukaniu frazy sleep

Każdy element menu to łącze do strony polecenia info zawierającej opis tego elementu. Aby przejść do takiej strony, wyszukaj odpowiedni element lub użyj strzałek kursora, aby ustawić kursor przy żądanym elemencie menu i następnie naciśnij klawisz Enter. Jeżeli umieściłeś kursor tak, jak to jest widoczne na rysunku 2.3, to po naciśnięciu klawisza Enter polecenie info wyświetli stronę podręcznika polecenia sleep. Zamiast tego możesz również skorzystać z wiersza poleceń menu i wpisać w nim

78  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X nazwę menu, które chcesz wyświetlić. Na przykład: aby wyświetlić informacje na temat polecenia sleep, możesz wpisać polecenie m sleep i nacisnąć klawisz Enter. Kiedy naciśniesz klawisz m (ang. menu), kursor zostanie przeniesiony do ostatniego wiersza w oknie (podobnie jak wtedy, kiedy naciskałeś klawisz /), gdzie pojawi się komunikat Element menu:. Teraz wpisz poszukiwaną nazwę menu (na przykład sleep) i naciśnij klawisz Enter — na ekranie pojawią się żądane informacje. Na rysunku 2.4 przedstawiono główny węzeł (ang. top node) informacji dotyczących polecenia sleep. Poszczególne węzły grupują zestawy informacji, które możesz przewijać, naciskając klawisz Spacja. Aby wyświetlić kolejny węzeł, naciśnij klawisz n. Aby powrócić do poprzedniego węzła, naciśnij klawisz p.

Rysunek 2.4. Strona info dla polecenia sleep

W miarę czytania kolejnych rozdziałów naszej książki i poznawania nowych poleceń i narzędzi możesz używać polecenia man lub info do wyszukiwania informacji o tych narzędziach. Jeżeli możesz drukować dokumenty zapisane w formacie PostScript, możesz wydrukować wybrane strony podręcznika man, wykonując polecenie man z opcją –t. Na przykład wykonanie polecenia man –t cat | lpr spowoduje wydrukowanie informacji na temat polecenia cat. Możesz również skorzystać z przeglądarki sieciowej i przejść jedną ze stron wymienionych w dodatku B i wydrukować żądane informacje bezpośrednio z okna przeglądarki.

OPCJA --HELP Kolejnym narzędziem, którego możesz używać w środowisku tekstowym, jest opcja --help. Większość narzędzi GNU posiada opcję --help, której użycie powoduje wyświetlenie na ekranie opisu danego narzędzia. Narzędzia, które powstawały poza projektem GNU, do wyświetlania informacji o samym sobie mogą używać opcji –h lub –help. $ cat --help Składnia: cat [OPCJA]... [PLIK]... Połączenie PLIKU(ÓW) albo standardowego wejścia i przekazanie na wyjście. -A, --show-all równoważne -vET -b, --number-nonblank numerowanie niepustych linii na wyjściu -e równoważne -vE -E, --show-ends wypisanie $ na końcu każdej linii ...

Jeżeli informacje wyświetlane przez opcję –help przekraczają aktualne rozmiary okna terminala, możesz wyświetlić je za pośrednictwem wybranego narzędzia stronicującego, takiego jak less. Aby to zrobić, musisz użyć znaku przekierowania strumienia danych (|): $ ls --help | less

Gdzie szukać dokumentacji systemu?  79

POLECENIE HELP POWŁOKI BASH Polecenie help powłoki bash powoduje wyświetlenie informacji o poleceniach powłoki, strukturach kontrolnych oraz innych funkcjach. Po znaku zachęty wydaj polecenie help, a następnie podaj interesujące Cię słowo kluczowe. Poniżej przedstawiono kilka przykładów. $ help help help: help [-dms] [pattern ...] Display information about builtin commands. Displays brief summaries of builtin commands. If PATTERN is specified, gives detailed help on all commands matching PATTERN, otherwise the list of help topics is printed. ... $ help echo echo: echo [-neE] [arg ...] Write arguments to the standard output. Display the ARGs on the standard output followed by a newline. Options: -n do not append a newline ... $ help while while: while COMMANDS; do COMMANDS; done Execute commands as long as a test succeeds. ...

UZYSKIWANIE POMOCY W tym punkcie zostanie przedstawionych kilka sposobów, na jakie możesz otrzymać pomoc związaną z używaniem systemu Linux. Poznasz także kilka użytecznych witryn WWW. Zapoznaj się również z dodatkiem B.

WYSZUKIWANIE POMOCY NA DYSKU LOKALNYM W katalogach /usr/src/linux/Documentation (aby ten katalog był dostępny, musisz zainstalować pakiety kodu źródłowego jądra systemu) oraz /usr/share/doc często możesz znaleźć wiele znacznie bardziej szczegółowych opisów różnych poleceń i narzędzi niż te oferowane przez polecenia man oraz info. Bardzo często takie informacje są przeznaczone dla osób, które będą samodzielnie kompilowały i modyfikowały poszczególne narzędzia, a nie dla szeregowych użytkowników. We wspomnianych katalogach znajdziesz tysiące plików, z których każdy zawiera informacje na inny temat. Jak pokazano na poniższych przykładach, nazwy większości podkatalogów /usr/share/doc zawierają numery wersji:

/usr/share/doc

$ ls /usr/share/doc abrt-2.0.7 accountsservice-0.6.15 acl-2.2.51 aic94xx-firmware-30 aisleriot-3.2.1 alsa-firmware-1.0.25 alsa-lib-1.0.25

iwl100-firmware-39.31.5.1 iwl3945-firmware-15.32.2.9 iwl4965-firmware-228.61.2.24 iwl5000-firmware-8.83.5.1_1 iwl5150-firmware-8.24.2.2 iwl6000-firmware-9.221.4.1 iwl6000g2a-firmware-17.168.5.3

openldap-2.4.26 openobex-1.5 openssh-5.8p2 openssl-1.0.0g openvpn-2.2.1 orc-0.4.16 orca-3.2.1

Większość wspomnianych podkatalogów zawiera plik README, w którym znajdują się informacje o danym narzędziu lub katalogu. Wpisywanie nazwy pliku będzie łatwiejsze, jeśli zamiast numeru wersji użyjesz gwiazdki (*, patrz rozdział 5.). Przedstawiony poniżej plik README dla narzędzia bzip2 wyjaśnia sposób kompilacji kodu źródłowego narzędzia.

80  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X $ cat /usr/share/doc/bzip2*/README This is the README for bzip2/libzip2. This version is fully compatible with the previous public releases. ... Complete documentation is available in Postscript form (manual.ps), PDF (manual.pdf) or html (manual.html). A plain-text version of the manual page is available as bzip2.txt. HOW TO BUILD -- UNIX Type 'make'. This builds the library libbz2.a and then the programs bzip2 and bzip2recover. Six self-tests are run. If the self-tests complete ok, carry on to installation: To install in /usr/local/bin, /usr/local/lib, /usr/local/man and /usr/local/include, type make install ...

WYSZUKIWANIE POMOCY W SIECI INTERNET W sieci Internet możesz znaleźć wiele pomocnych stron i witryn zajmujących się zagadnieniami związanymi z systemami Linux i OS X. Na takich stronach możesz często znaleźć bardzo szczegółową dokumentację poszczególnych narzędzi i całego systemu. Możesz też skorzystać z wyszukiwarek sieciowych, takich jak „wszystkowiedząca” wyszukiwarka Google (http://www.google.pl). Na przykład: jeżeli jakiś program, którego używasz, wyświetla komunikat o wystąpieniu błędu, możesz wkleić komunikat w polu wyszukiwania przeglądarki. Pamiętaj, że w celu poprawienia rezultatów wyszukiwania warto ująć taki komunikat w znaki cudzysłowu. W zdecydowanej większości przypadków znajdziesz informacje na temat problemu oraz sugestie, jak go rozwiązać (patrz rysunek 2.5).

Rysunek 2.5. Google — wyniki wyszukiwania komunikatu o błędzie

Podręczniki projektu GNU są dostępne na stronie http://www.gnu.org/manual/. Inną dokumentację oraz zestawienie dodatkowych zasobów GNU możesz znaleźć na stronie głównej projektu, http://www.gnu.org/. Wiele stron i zasobów projektu GNU zostało już przetłumaczonych na inne języki3.

GNU

3

Polską wersję strony projektu GNU znajdziesz pod adresem http://www.gnu.org/home.pl.html — przyp. tłum.

Gdzie szukać dokumentacji systemu?  81

Zasoby projektu LDP (ang. Linux Documentation Project) znajdziesz na stronie internetowej http://www.tldp.org/ (patrz rysunek 2.6). Projekt LDP, który powstał niemal równolegle z pojawieniem się pierwszych wersji systemu Linux, udostępnia niemal kompletny zestaw podręczników, dokumentów HOWTO, FAQ, podręczników man itd. Znajdziesz tam nawet szereg czasopism dotyczących systemu Linux. Strona domowa projektu jest dostępna w języku angielskim, portugalskim, hiszpańskim, włoskim, koreańskim i francuskim. Strona jest łatwa w użyciu i posiada wygodną wyszukiwarkę. Znajdziesz tam również rozbudowany zestaw łączy do innych źródeł informacji o systemie Linux, gdzie znajdziesz praktycznie wszystko, co Ci będzie potrzebne (w polu wyszukiwania kliknij łącze Links lub po prostu w pasku adresu przeglądarki sieciowej wpisz http://www.tldp.org/links/). Strona z łączami podzielona jest na kilka kategorii, grupujących zasoby dotyczące ogólnych informacji o systemie Linux, wydarzeniach z nim związanych, grupach użytkowników systemu Linux, listach i grupach dyskusyjnych i wielu innych.

Projekt LDP (Linux Documentation Project)

Rysunek 2.6. Strona domowa projektu LDP (Linux Documentation Project)

Dokumenty HOWTO szczegółowo opisują sposób wykonania różnych zadań związanych z systemem Linux — począwszy od podłączenia i konfiguracji jakiegoś nietypowego, specjalizowanego urządzenia peryferyjnego, poprzez rutynowe zadania administratora, aż do instalacji i konfiguracji złożonych pakietów oprogramowania sieciowego. W dokumentach Mini-HOWTO znajdziesz nieco skrócone wersje objaśnień.

Dokumenty HOWTO

Na stronie internetowej projektu LDP (ang. Linux Documentation Project) znajdziesz mnóstwo dokumentów HOWTO oraz mini-HOWTO. Uruchom przeglądarkę sieciową, przejdź na stronę http://www.tldp.org/, kliknij łącze HOWTOs i wybierz indeks, którego chcesz użyć do wyszukiwania dokumentów HOWTO lub mini-HOWTO. Do wyszukiwania dokumentów możesz również użyć wyszukiwarki dostępnej na stronie głównej projektu LDP.

82  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X

WIĘCEJ INFORMACJI O LOGOWANIU SIĘ DO SYSTEMU ORAZ O HASŁACH Podstawowe informacje na ten temat znajdziesz w sekcji „Logowanie się przy użyciu terminala (emulatora)” we wcześniejszej części tego rozdziału, natomiast tutaj omówimy najczęściej spotykane problemy związane z logowaniem. Dowiesz się również, w jaki sposób możesz się zalogować się z systemu zdalnego, jak używać konsol wirtualnych oraz jak zmienić hasło.

BEZPIECZEŃSTWO Zawsze używaj haseł Jeżeli nie jesteś jedynym użytkownikiem systemu, jeżeli Twój system jest podłączony do innych systemów, sieci Internet lub nawet do modemu i jeżeli nie jesteś jedynym użytkownikiem mającym fizyczny dostęp do Twojego komputera, to tworzenie i utrzymywanie kont użytkowników, które nie są zabezpieczone silnym hasłem, jest raczej kiepskim pomysłem...

CO ZROBIĆ, KIEDY NIE MOŻESZ SIĘ ZALOGOWAĆ Jeżeli niepoprawnie wpiszesz nazwę użytkownika lub hasło dostępu, system wyświetli na ekranie komunikat o błędzie dopiero po tym, jak wpiszesz zarówno nazwę użytkownika, jak i hasło dostępu. Komunikat o błędzie informuje Cię, że nazwa użytkownika lub podane hasło jest niepoprawne. System nie informuje Cię, czy popełniłeś błąd, wpisując nazwę użytkownika, czy wpisując hasło — taka strategia ma na celu zniechęcanie nieautoryzowanych użytkowników do prób uzyskania dostępu do systemu. Poniżej podajemy zestawienie najpopularniejszych przyczyn powodujących, że próba zalogowania się do systemu kończy się niepowodzeniem:  Nazwa użytkownika i hasło dostępu nie są wpisane przy użyciu odpowiedniej wielkości liter.

Upewnij się, że klawisz CapsLock jest wyłączony oraz że wpisujesz nazwę użytkownika i hasło przy użyciu dokładnie takich samych kombinacji małych i wielkich liter jak podczas ich tworzenia.  Logujesz się do niewłaściwego komputera. Twoja kombinacja nazwy użytkownika i hasła dostępu może się okazać nieprawidłowa, jeżeli próbujesz się zalogować do niewłaściwego komputera. W przypadku dużych systemów sieciowych być może będziesz musiał przed zalogowaniem się podać nazwę komputera docelowego.  Twoje konto użytkownika jest nieważne. Twoja kombinacja nazwy użytkownika i hasła

dostępu może się okazać nieprawidłowa, jeżeli Twoje konto nie zostało poprawnie skonfigurowane i uaktywnione.  System plików jest całkowicie zapełniony. Jeżeli system plików niezbędny do poprawnego działania procesu logowania zostanie z jakiegoś powodu całkowicie zapełniony, może to wyglądać tak, jakby udało Ci się poprawnie zalogować, jednak po chwili na ekranie ponownie pojawi się ekran logowania. W takiej sytuacji musisz uruchomić system w trybie awaryjnym i zrobić odpowiednią ilość wolnego miejsca, usuwając niektóre pliki.  Twoje konto jest zablokowane. Możliwość logowania na konto użytkownika root z poziomu

graficznego ekranu logowania jest zablokowana domyślnie. Administrator systemu może również zablokować inne konta użytkowników. Bardzo często zdarza się również, że użytkownik root nie może się zalogować do systemu poprzez połączenie sieciowe. Jeżeli pracując zdalnie, musisz skorzystać z uprawnień użytkownika root, powinieneś użyć polecenia su. Jeżeli chcesz zmienić hasło do swojego konta użytkownika, zajrzyj do sekcji „Zmiana hasła użytkownika” w dalszej części tego rozdziału.

Więcej informacji o logowaniu się do systemu oraz o hasłach  83

LOGOWANIE ZDALNE — EMULATORY TERMINALA, SSH I POŁĄCZENIA TYPU DIAL-UP Jeżeli nie używasz konsoli, terminala lub innego urządzenia podłączonego bezpośrednio do systemu Linux, do którego się logujesz, to prawdopodobnie jesteś do niego podłączony za pośrednictwem emulatora terminala w systemie zdalnym. Oprogramowanie emulatora działa w systemie lokalnym, łączy się do systemu zdalnego za pośrednictwem połączenia sieciowego (Ethernet, asynchroniczne połączenie modemowe, PPP lub inne) i pozwala się w ten sposób zalogować w systemie zdalnym.

WSKAZÓWKA Upewnij się, że zmienna TERM jest ustawiona poprawnie Niezależnie od tego, w jaki sposób łączysz się z komputerem zdalnym, musisz się upewnić, że zmienna TERM jest ustawiona poprawnie i jej wartość reprezentuje typ terminala, który jest emulowany przez oprogramowanie Twojego systemu. Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Definiowanie typu terminala” w dodatku B. Kiedy logujesz się poprzez połączenie typu dial-up, sam proces połączenia jest prosty — przekazujesz emulatorowi polecenia połączenia się ze zdalnym systemem Linux, emulator wybiera odpowiedni numer na modemie, łączy się i zdalny system wyświetla na ekranie znak zachęty do logowania. Jeżeli logujesz się za pośrednictwem sieci komputerowej, możesz użyć albo protokołu ssh (połączenie szyfrowane, bezpieczne), albo protokołu telnet (połączenie nieszyfrowane, brak zabezpieczenia). Program ssh umożliwiający połączenie ze zdalnym systemem za pośrednictwem protokołu o tej samej nazwie został zaimplementowany w wielu różnych systemach operacyjnych, a nie tylko w systemie Linux. Wiele interfejsów użytkownika potrafi używać emulatora terminala i połączenia ssh. Jeżeli chcesz się połączyć z systemem Linux z komputera pracującego pod kontrolą systemu rodem z Apple, Windows czy UNIX, otwórz program wykorzystujący ssh i podaj w nim adres IP komputera, do którego chcesz się zalogować.

ZASTOSOWANIE KONSOLI WIRTUALNYCH Kiedy uruchamiasz system Linux na komputerze osobistym, będziesz zapewne bardzo często pracował z tym systemem za pośrednictwem monitora i klawiatury podłączonych bezpośrednio do tego komputera. Używając konsoli fizycznej, możesz podłączać się do jednej z 63 konsol wirtualnych (nazywanych również wirtualnymi terminalami). Niektóre z tych konsol pozwalają na zalogowanie się do systemu, inne umożliwiają pracę ze środowiskiem graficznym. Aby przełączać się pomiędzy poszczególnymi konsolami wirtualnymi, wciśnij i przytrzymaj klawisze Ctrl i Alt, a następnie naciśnij klawisz funkcyjny odpowiadający numerowi konsoli, do której chcesz się przełączyć. Na przykład naciśnięcie kombinacji klawiszy Ctrl+Alt+F5 wyświetla na ekranie piątą konsolę wirtualną. Domyślnie piąta lub szósta konsola wirtualna jest aktywna i działa w niej tekstowa sesja logowania. Jeżeli chcesz korzystać zarówno ze środowiska graficznego, jak i konsoli tekstowej, możesz uruchomić sesję graficzną w jednej konsoli, a sesję tekstową w innej.

WYLOGOWANIE Z SYSTEMU Jeżeli chcesz się wylogować ze środowiska tekstowego, naciśnij kombinację klawiszy Ctrl+D. To spowoduje wysłanie sygnału EOF (ang. Eng Of File). Alternatywnym rozwiązaniem jest wykonanie z poziomu powłoki polecenia exit. Zakończenie pracy z powłoką nie powoduje zakończenia sesji graficznej, a jedynie wyjście z aktualnie używanej powłoki. Na przykład wyjście z powłoki uruchomionej w terminalu GNOME powoduje zamknięcie okna wymienionego terminala.

84  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X

ZMIANA HASŁA UŻYTKOWNIKA Jeżeli to ktoś inny przydzielił Ci hasło do Twojego konta, to szybka zmiana takiego hasła jest z pewnością znakomitym pomysłem. Ze względów bezpieczeństwa hasła wpisywane przez Ciebie nie są wyświetlane na ekranie.

BEZPIECZEŃSTWO Chroń swoje hasło Nie dopuszczaj do sytuacji, w której ktoś inny mógłby poznać hasło do Twojego konta. Nie zapisuj hasła w zwykłym pliku tekstowym, który nie jest zaszyfrowany, nie pozwalaj, aby ktoś inny patrzył, jak wpisujesz hasło, nie przekazuj swojego hasła innym użytkownikom, a zwłaszcza takim, których nie znasz (pamiętaj, że administrator systemu nie musi znać Twojego hasła). W razie potrzeby możesz zawsze zapisać swoje hasło na kartce i przechowywać ją w bezpiecznym, tylko Tobie znanym miejscu.

BEZPIECZEŃSTWO Wybierz hasło trudne do odgadnięcia Jako hasła nie powinieneś używać numeru telefonu (ani swojego, ani bliskich), imion dzieci, zwierząt domowych, dat urodzin, imienin, rocznic, wyrazów ze słownika (nawet jeżeli to słownik innego języka) i tak dalej. Nie powinieneś również używać prostych kombinacji takich elementów ani prostych transliteracji typu l33t — nowoczesne programy do ataków słownikowych znakomicie sobie radzą również z takimi permutacjami.

BEZPIECZEŃSTWO Używaj w haśle znaków specjalnych Narzędzia do automatycznego łamania haseł w pierwszej kolejności sprawdzają możliwe kombinacje liter alfabetu i cyfr. Użycie w haśle chociaż jednego znaku specjalnego, takiego jak @ czy #, znacząco wydłuża czas złamania hasła i zwiększa jego bezpieczeństwo.

BEZPIECZEŃSTWO Rozróżniaj bardziej i mniej ważne hasła Rozróżnianie haseł bardziej i mniej ważnych jest całkiem niezłym pomysłem. Na przykład hasła do internetowych blogów czy serwisów pobierania plików nie są tak bardzo ważne i używanie takiego samego hasła do każdego z nich jest zupełnie do przyjęcia4. Z drugiej strony, hasła do Twojego konta użytkownika, poczty elektronicznej czy konta bankowego mają krytyczne znaczenie dla Twojego bezpieczeństwa — nigdy nie powinieneś używać takich haseł do logowania się na mniej ważnych serwisach sieciowych. Aby hasło było w miarę bezpieczne, powinno składać się z kombinacji cyfr, małych i wielkich liter oraz znaków przestankowych. Dobre hasło powinno również spełniać następujące kryteria:

Bezpieczne hasła

 Powinno mieć co najmniej 6 znaków długości (administrator może wymusić tworzenie haseł

o większej długości). Dobrym kompromisem pomiędzy bezpieczeństwem hasła a wygodą użytkowania są hasła o długości rzędu 7 czy 8 znaków.  Hasło nie powinno być słownikowe (nawet jeżeli to słownik innego języka i wybrany wyraz wydaje się trudny do odgadnięcia).  Hasło nie powinno być takie samo jak imiona bliskich, miejsc, zwierząt domowych czy innych

elementów, które łatwo można odgadnąć. 4

Rozsądek podpowiada, aby nigdy nie używać tego samego hasła więcej niż tylko jeden raz — przyp. tłum.

Więcej informacji o logowaniu się do systemu oraz o hasłach  85

 Hasło powinno zawierać przynajmniej dwie litery, jedną cyfrę i jeden znak przestankowy.  Hasło nie powinno być takie samo jak Twoje imię, nazwa Twojego konta czy inne tego typu

nazwy, nawet pisane wspak, czy z literami przesuniętymi o stałą liczbę znaków. W zasadzie tylko pierwszy wymóg powinien być bezwzględnie spełniony. Podczas tworzenia haseł unikaj znaków i sekwencji sterujących (takich jak na przykład Ctrl+H), ponieważ takie kombinacje klawiszy mogą mieć specjalne znaczenie dla systemu, co może uniemożliwić wpisanie poprawnego hasła. Jeżeli zmieniasz hasło do swojego konta, nowe hasło powinno różnić się od starego co najmniej trzema znakami. Zmiana wielkości liter w haśle nie powinna się liczyć jako zmieniony znak.

BEZPIECZEŃSTWO Polecenie pwgen pozwoli Ci wybrać bezpieczne hasło Polecenie pwgen (możesz je zainstalować, korzystając ze wskazówek przedstawionych w dodatku C) pozwala na generowanie silnych, pseudolosowych haseł. Przy odrobinie wysiłku i gimnastyki umysłowej szybko nauczysz się literowania i zapamiętywania przynajmniej niektórych z takich haseł. Aby zmienić hasło, wydaj polecenie passwd. Najpierw polecenie passwd poprosi Cię o podanie aktualnego hasła. Ma to na celu sprawdzenie, czy jesteś upoważniony do zmiany hasła. Następnie zostaniesz poproszony o podanie nowego hasła. $ passwd Zmienianie hasła użytkownika robert. Zmienianie hasła dla robert. (obecne) hasło UNIX: Nowe hasło : Proszę ponownie podać nowe hasło : passwd: zaktualizowanie wszystkich tokenów uwierzytelniania powiodło się.

Po wprowadzeniu nowego hasła system poprosi Cię o jego ponowne wpisanie w celu sprawdzenia, czy nie popełniłeś jakiegoś przypadkowego błędu. Jeżeli powtórnie wpisane hasło jest takie samo, system dokonuje zmiany. Jeżeli powtórnie wpisane hasło jest inne niż pierwsze, system wyświetli komunikat o wystąpieniu błędu i nie pozwoli Ci zatwierdzić nowego hasła: Podane hasła nie zgadzają się.

Jeżeli nowe hasło jest zbyt krótkie, system również Cię o tym powiadomi, wyświetlając na ekranie odpowiedni komunikat: BŁĘDNE HASŁO: ZDECYDOWANIE za krótkie

Jeżeli nowe hasło okaże się zbyt proste, system także wyświetli odpowiedni komunikat: BŁĘDNE HASŁO: za proste/systematyczne

Po kilku nieudanych próbach zmiany hasła system wyświetli komunikat błędu i nastąpi powrót do znaku zachęty. W takim przypadku konieczne będzie ponowne wydanie polecenia passwd.

WSKAZÓWKA OS X: polecenie passwd nie spowoduje zmiany hasła zapisanego w pęku kluczy W systemie OS X polecenie passwd zmieni hasło logowania się do systemu, ale nie spowoduje zmiany tego hasła zapisanego w narzędziu Dostęp do pęku kluczy. Hasło zapisane w pęku kluczy jest używane przez wiele programów działających w środowisku graficznym. Dlatego też będziesz musiał je zmienić samodzielnie, używając do tego narzędzia Dostęp do pęku kluczy.

86  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X Zmiana hasła zmienia również sposób, w jaki się logujesz. Jeżeli zapomnisz swojego nowego hasła, to użytkownik działający na prawach użytkownika root może je zmienić i przydzielić Ci nowe hasło. Mając uprawnienia root (uzyskane za pomocą omówionych wcześniej poleceń su lub sudo) można przypisać nowe hasło dowolnemu użytkownikowi systemu bez konieczności znania jego dotychczasowego hasła. Tę technikę można wykorzystać, gdy użytkownik zapomni hasła. # passwd robert Zmienianie hasła użytkownika robert. Nowe hasło : ...

PODSUMOWANIE ROZDZIAŁU Podobnie jak w przypadku innych systemów operacyjnych dostęp do systemu Linux wymaga odpowiedniej autoryzacji, czyli inaczej mówiąc zalogowania się. Aby to zrobić, kiedy pojawi się ekran logowania, musisz wpisać nazwę użytkownika i odpowiednie hasło. Po zalogowaniu się możesz w dowolnej chwili zmienić hasło dostępu do swojego konta, używając do tego polecenia passwd. Wybierz hasło, które jest trudne do odgadnięcia i spełnia kryteria stawiane przez narzędzie używane do zmiany haseł. Za zarządzanie systemem odpowiedzialny jest administrator systemu. W przypadku systemu z jednym użytkownikiem to Ty jesteś administratorem. W przypadku małych systemów z wieloma użytkownikami rolę administratora możesz spełniać Ty lub inna osoba, często taka rola może być dzielona przez kilku użytkowników. W dużych, sieciowych systemach wielodostępnych rolę administratora spełnia osoba wyznaczona na to stanowisko i jest to jej zajęcie na pełny etat. Kiedy do wykonania zadania wymagane są przywileje użytkownika root, administrator systemu loguje się do systemu jako root i realizuje zadanie. Użytkownik posiadający takie przywileje jest często nazywany superużytkownikiem. W przypadku dużych systemów wielodostępnych hasło użytkownika root może być udostępnione kilku zaufanym administratorom. Do codziennej pracy nie powinieneś wykorzystywać konta użytkownika root. Kiedy masz do wykonania zadanie, które rzeczywiście wymaga użycia uprawnień użytkownika root, powinieneś z nich korzystać tylko przez taki czas, jaki jest absolutnie niezbędny do wykonania zadania, i powrócić do pracy na normalnym koncie użytkownika tak szybko, jak to jest możliwe. Polecenie man daje użytkownikowi dostęp do dokumentacji systemowej. To narzędzie jest bardzo przydatne zarówno dla nowych użytkowników systemu Linux, jak i dla doświadczonych użytkowników, którzy poszukują szczegółowych informacji na temat wybranych aspektów działania różnych narzędzi i poleceń. Z kolei polecenie apropos ułatwia wyszukiwanie narzędzi. Polecenie info również może być przydatne zarówno dla początkujących, jak i zaawansowanych użytkowników systemu. Daje ono dostęp do dokumentacji wielu narzędzi systemu Linux. W niektórych przypadkach wywołanie narzędzia wraz z opcją --help powoduje wyświetlenie krótkiej dokumentacji dotyczącej danego narzędzia.

Ćwiczenia  87

ĆWICZENIA 1. Podczas próby logowania przy użyciu nieprawidłowej nazwy konta lub nieprawidłowego hasła system wyświetla następujący komunikat: Niepoprawne logowanie

2. 3. 4. 5. 6. 7. 8.

Taki komunikat nie pozwala na zorientowanie się, czy podana została błędna nazwa konta użytkownika, czy niepoprawne hasło. Dlaczego takie informacje nie powinny być ujawniane? Podaj trzy przykłady źle wybranych haseł. Wskaż słabe strony każdego z nich. Podaj przykład zbyt krótkiego hasła i wyświetlany wówczas przez systemem komunikat błędu. Czy słowo fido to dobrze dobrane hasło? Uzasadnij odpowiedź. Co zrobić w sytuacji, gdy nie można zalogować się do systemu? Spróbuj zmienić hasło na pies. Co się stanie? A teraz zmień je na bezpieczniejsze hasło. Co powoduje, że hasło można uznać za względnie bezpieczne? W jaki sposób można wyświetlić listę narzędzi pozwalających na kompresję plików? W jaki sposób ponownie wyświetlić w powłoce poprzednio wykonane polecenie, zmodyfikować je, a następnie wykonać? Jakie informacje wyświetli opcja --help dla narzędzia tar? W jaki sposób można te wszystkie informacje wyświetlić jednocześnie na ekranie?

ĆWICZENIA ZAAWANSOWANE 9. W jaki sposób można wyświetlić stronę podręcznika man dla piątej sekcji polecenia shadow? 10. Jak bez użycia uprawnień root zmienić powłokę logowania na tcsh? 11. Ile stron podręcznika man znajduje się w sekcji Urządzenia (ang. Devices) podręcznika systemowego? [Podpowiedź: Urządzenia to podsekcja sekcji Pliki specjalne (ang. Special Files)]. 12. Przykład omawiany w sekcji „Polecenie man — wyświetlanie tematów pomocy” pokazuje, że strony podręcznika man pojawiają się w sekcjach 1. i 5. podręcznika systemowego. Wyjaśnij, w jaki sposób można użyć polecenia man do sprawdzenia, w których sekcjach podręcznika systemowego występuje dane polecenie. 13. Jak możesz określić, które narzędzia systemu Linux pozwalają na tworzenie archiwów oraz pracę z nimi?

88  ROZDZIAŁ 2. WPROWADZENIE DO SYSTEMÓW LINUX I OS X

3 Narzędzia systemu Linux

W tym rozdziale:

Cele rozdziału

Znaki specjalne

Po przeczytaniu tego rozdziału będziesz wiedział:  Jak wpisywać znaki specjalne i jak zapobiegać interpretacji takich znaków.  Jak używać podstawowych narzędzi do wyświetlania listy plików oraz wyświetlania zawartości plików tekstowych.  Jak kopiować, przenosić i usuwać pliki.  Jak wyszukiwać, sortować, drukować i porównywać pliki tekstowe.  Jak łączyć kilka poleceń przy użyciu znaków przekierowania strumienia danych.  Jak pakować, rozpakowywać i archiwizować pliki.  Jak sprawdzić lokalizację poszczególnych narzędzi systemu Linux.  Jak wyświetlać informacje o kontach użytkowników.  Jak komunikować się z innymi użytkownikami.

Podstawowe narzędzia systemowe Polecenia less i more — wyświetlanie tekstu po jednym ekranie Praca z plikami Polecenie lpr — drukowanie pliku Symbol potoku | — komunikacja między procesami Kompresowanie i archiwizacja plików Wyświetlanie informacji o systemie i użytkownikach

90  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX Nie tylko w momencie, kiedy Linus Torvalds udostępnił wszystkim zainteresowanym swoją pierwszą wersję systemu Linux, ale jeszcze przez wiele lat później Linux nie posiadał graficznego interfejsu użytkownika — podstawowym i jedynym interfejsem był terminal tekstowy i wiersz poleceń tekstowej powłoki systemu. Wszystkie narzędzia były uruchamiane z poziomu wiersza poleceń. W obecnych czasach wyrafinowane graficzne interfejsy użytkownika z pewnością spełniają ogromnie ważną rolę, ale mimo to nadal wielu użytkowników — a zwłaszcza administratorów systemów — wykorzystuje starą, dobrą konsolę tekstową oraz narzędzia i komendy uruchamiane z wiersza poleceń. Narzędzia konsolowe są często o wiele szybsze, bardziej elastyczne, mają większe możliwości i często są bardziej kompletne niż ich graficzne odpowiedniki. Zdarza się nawet, że dane narzędzie konsolowe nie ma swojego „graficznego” odpowiednika. Wielu użytkowników preferuje pracę z konsolą tekstową, tłumacząc to tym, że daje im ona większe poczucie kontroli nad wykonywanymi zadaniami. Kiedy pracujesz z konsolą tekstową, pracujesz z tekstową powłoką systemu operacyjnego (patrz rozdziały 5., 8. i 10.). Zanim rozpoczniesz pracę z powłoką, powinieneś poznać znaki, które mają specjalne znaczenie dla powłoki, stąd w tym rozdziale nasze rozważania rozpoczniemy właśnie od omówienia znaków specjalnych. Następnie opiszemy pięć podstawowych narzędzi konsolowych: ls, cat, rm, less oraz hostname. W dalszej części rozdziału omówimy kilka narzędzi przeznaczonych do przetwarzania plików oraz narzędzia służące do pakowania i rozpakowywania plików, tworzenia i rozpakowywania archiwów, wyszukiwania narzędzi, wyświetlania informacji o systemie, komunikowania się z innymi użytkownikami oraz drukowania plików.

ZNAKI SPECJALNE Znaki specjalne, które mają specjalne znaczenie dla powłoki, zostały omówione w sekcji „Generowanie i rozwijanie nazw plików” w rozdziale 5. Dla ułatwienia wymieniamy je także poniżej, co pozwoli Ci uniknąć ich przypadkowego użycia, zanim nie dowiesz się, w jaki sposób są interpretowane przez powłokę. Dobrą praktyką jest unikanie stosowania poniżej wymienionych znaków w nazwach plików (nawet jeżeli edytory takie jak emacs i inne programy pozwalają na ich stosowanie), ponieważ odwoływanie się do takich plików z poziomu wiersza poleceń jest znacznie trudniejsze: & ; | * ? ' " ‘ [ ] ( ) $ < > { } # / \ ! ~

Choć znaki takie jak Enter, Spacja czy Tab mają specjalne znaczenie dla powłoki, to jednak nie zaliczamy ich do znaków specjalnych. Naciśnięcie klawisza Enter zazwyczaj kończy wprowadzanie danego wiersza i rozpoczyna wykonywanie polecenia. Znaki Spacja i Tab oddzielają od siebie poszczególne elementy wpisane w wierszu poleceń i są często nazywane białymi znakami (ang. whitespaces).

Białe znaki

Jeżeli musisz użyć znaku, który ma specjalne znaczenie dla powłoki, jako zwykłego znaku, możesz cytować (ang. quote) lub poprzedzić go tzw. znakiem ucieczki (ang. escape character), dzięki czemu powłoka nie będzie nadawała takiemu znakowi specjalnego znaczenia — powłoka traktuje wszystkie znaki cytowane (czyli inaczej mówiąc, poprzedzone znakiem ucieczki) jak normalne, zwykłe znaki. Pamiętaj jednak, że znak ukośnika (/) zawsze spełnia rolę separatora ścieżki, nawet jeżeli będzie cytowany (poprzedzony znakiem ucieczki).

Używanie znaków specjalnych

Aby cytować znak, powinieneś poprzedzić go znakiem lewego ukośnika (\) (ang. backslash). Jeżeli chcesz cytować dwa lub więcej znaków specjalnych występujących jeden po drugim, musisz każdy z nich poprzedzić znakiem lewego ukośnika (na przykład ciąg znaków ** powinieneś wpisać jako \*\*). W razie potrzeby możesz również cytować znak lewego ukośnika, traktując go tak, jak każdy inny znak specjalny, czyli poprzedzając kolejnym znakiem lewego ukośnika.

Lewy ukośnik

Innym sposobem cytowania znaków specjalnych jest ujęcie ich w znaki apostrofu, na przykład '**'. Pomiędzy znakami apostrofu możesz umieszczać dowolną liczbę znaków normalnych i specjalnych, na przykład 'To jest znak specjalny: >'. Normalne znaki umieszczone w takim ciągu znaków są traktowane tak jak zwykle, czyli jak normalne znaki, a znaki specjalne są również traktowane jak normalne znaki.

Znaki apostrofu

Podstawowe narzędzia systemowe  91

Jedynym sposobem cytowania znaków takich jak usuwanie znaku (Ctrl+H), usuwanie wiersza (Ctrl+U) i innych znaków sterujących (np. wypróbuj kombinację klawiszy Ctrl+M) jest poprzedzenie każdego z tych znaków znakiem Ctrl+V. W tym przypadku zarówno znaki apostrofu, jak i lewego ukośnika nie będą działać. Wypróbuj następujące polecenia (w tym przykładzie nazwy klawiszy sterujących zostały podane pochyloną czcionką): $ echo 'xxxxxxCtrl+U' $ echo xxxxxxCtrl+V Ctrl+U

INFORMACJE DODATKOWE Choć nie będziesz w stanie zauważyć znaku Ctrl+U wpisywanego w drugiej sekwencji poleceń, to jednak możesz być pewien, że tam jest. Komenda przedstawiona poniżej wysyła strumień danych z wyjścia polecenia echo na wejście polecenia od (które wyświetla zrzut danych w formacie ósemkowym, więcej szczegółowych informacji na temat tego polecenia znajdziesz na stronach podręcznika man) i wyświetla znak sterujący Ctrl+U jako wartość 25 (025) — w tym przykładzie nazwy klawiszy sterujących zostały podane pochyloną czcionką: $ echo xxxxxxCtrl+V Ctrl+U | od -c 0000000 x x x x x x 025 0000010

\n

Ostatni element, \n, to znak rozpoczęcia nowego wiersza, który polecenie echo wysyła jako ostatni znak strumienia danych.

PODSTAWOWE NARZĘDZIA SYSTEMOWE Jedną z największych zalet systemu Linux jest to, że daje użytkownikowi do dyspozycji tysiące narzędzi spełniających miriady przeróżnych funkcji. Z tych narzędzi korzystasz za każdym razem, kiedy logujesz się do systemu, wywołując ich nazwy bezpośrednio z wiersza poleceń, czy uruchamiając je pośrednio, za pomocą ikon czy menu środowiska graficznego. W kolejnych sekcjach omówimy szereg najważniejszych, podstawowych narzędzi dostępnych z poziomu wiersza poleceń powłoki systemu. Niektóre z narzędzi są również dostępne z poziomu graficznego interfejsu użytkownika, a istnieją również narzędzia, które pracują wyłącznie w środowisku graficznym.

WSKAZÓWKA Narzędzia omawiane w tym rozdziale powinieneś uruchamiać z wiersza poleceń powłoki systemu W tym rozdziale omawiamy narzędzia pracujące w trybie tekstowym, które uruchamiane są z poziomu wiersza poleceń powłoki systemu. Z tymi narzędziami możesz pracować, korzystając bezpośrednio z terminala, emulatora terminala pracującego w środowisku graficznym lub z poziomu konsoli wirtualnej. W kolejnych sekcjach będziemy często używać określenia katalog. Katalog jest to zasób dyskowy, w którym mogą być przechowywane pliki i inne katalogi. W innych systemach operacyjnych, włączając w to systemy Windows i OS X, katalogi są bardzo często określane mianem folderów. Co ciekawe, odnosi się to również do systemu Linux pracującego ze środowiskiem graficznym.

Folder czy katalog

WSKAZÓWKA W tym rozdziale będziesz pracował w swoim katalogu domowym Kiedy logujesz się do systemu, domyślnie zaczynasz pracę w swoim katalogu domowym (ang. home directory). W tym rozdziale będzie to jedyny katalog, z którego będziesz korzystał — wszystkie pliki, które będziemy tworzyć w omawianych przykładach, będą znajdowały się w Twoim katalogu domowym. Więcej szczegółowych informacji na temat katalogów znajdziesz w rozdziale 4.

92  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX

POLECENIE LS — WYŚWIETLANIE NAZW PLIKÓW Używając dowolnego edytora tekstu, utwórz mały plik o nazwie praktyka (poradnik użytkownika edytora vim znajdziesz w rozdziale 6., natomiast poradnik użytkownika edytora emacs znajduje się w rozdziale 7.). Po wyjściu z edytora możesz użyć polecenia ls (ang. list) do wyświetlenia listy plików znajdujących się w Twoim katalogu domowym. Pierwsze polecenie przedstawione na rysunku 3.1, ls, wyświetla nazwę pliku praktyka (oprócz tego pliku możesz również zobaczyć nazwy innych plików, które zostały wcześniej utworzone przez Ciebie, przez system lub inne programy). Kolejne polecenia widoczne na rysunku 3.1 wyświetlają zawartość pliku, a następnie usuwają go z systemu — te polecenia opiszemy w dalszej części tego rozdziału. $ ls praktyka $ cat praktyka To jest mały plik tekstowy, który został utworzony za pomocą edytora tekstu. $ rm praktyka $ ls $ cat praktyka cat: praktyka: Nie ma takiego pliku ani katalogu $

Rysunek 3.1. Zastosowanie poleceń ls, cat i rm do pracy z plikiem praktyka

POLECENIE CAT — WYŚWIETLANIE ZAWARTOŚCI PLIKU Polecenie cat wyświetla zawartość pliku tekstowego. Nazwa polecenia pochodzi od słowa cantenate, które oznacza łączenie elementów ze sobą jeden po drugim (na rysunku 5.8 w rozdziale 5. przedstawiono sposób użycia polecenia cat do połączenia zawartości trzech plików). Użycie polecenia cat jest wygodnym sposobem wyświetlania zawartości plików na ekranie. Aby to zrobić, wystarczy wpisać polecenie cat, po którym następuje spacja i nazwa pliku. Na rysunku 3.1 przedstawiono sposób użycia polecenia cat do wyświetlenia zawartości pliku praktyka. Rysunek wyraźnie pokazuje różnice pomiędzy poleceniami ls i cat — polecenie ls wyświetla nazwę pliku, podczas gdy polecenie cat wyświetla zawartość pliku.

POLECENIE RM — USUWANIE PLIKU Polecenie rm (ang. remove) usuwa wybrany plik (pliki). Na rysunku 3.1 przedstawiono sposób użycia polecenia rm do usunięcia pliku praktyka. Po usunięciu pliku wykonanie poleceń ls i cat pokazuje, że plik praktyka rzeczywiście został usunięty. Polecenie ls nie wyświetla już nazwy tego pliku, a próba wykonania polecenia cat kończy się wyświetleniem komunikatu, że plik lub katalog o takiej nazwie nie istnieje. Polecenia rm powinieneś używać z ostrożnością. Więcej informacji na temat tego polecenia znajdziesz w części VI książki oraz podręczniku systemowym po wydaniu polecenia info coreutils 'rm invocation'. Jeżeli używasz systemu OS X, zapoznaj się z informacjami przedstawionymi w dodatku D.

WSKAZÓWKA Bezpieczniejszy sposób usuwania plików Aby upewnić się, że kasujesz te pliki, które rzeczywiście chciałeś skasować, możesz używać interaktywnej wersji polecenia rm. Aby to zrobić, po nazwie polecenia rm wpisz opcję -i (wskazówki dotyczące opcji przedstawiono w poprzednim rozdziale), a następnie nazwę pliku, który chcesz usunąć. Polecenie rm poprosi o potwierdzenie zamiaru usunięcia pliku i dopiero kiedy odpowiesz pozytywnie, naciskając klawisz t (tak) lub y (yes), plik zostanie usunięty. Polecenie rm nie usunie pliku, jeżeli Twoja odpowiedź będzie się zaczynała od innego znaku niż t lub y. W niektórych dystrybucjach opcja -i jest ustawiana domyślnie podczas pracy na prawach użytkownika root. $ rm -i toollist rm: usunąć zwykły plik 'toollist'? y

Informacje dodatkowe: dla polecenia rm -i możesz utworzyć alias (patrz sekcja „Aliasy” w rozdziale 8.) i umieścić go w pliku startowym (ang. startup file), dzięki czemu polecenie rm będzie zawsze działać w trybie interakcyjnym.

Praca z plikami  93

POLECENIA LESS I MORE — WYŚWIETLANIE TEKSTU PO JEDNYM EKRANIE Kiedy chcesz wyświetlić zawartość pliku, która nie mieści się na jednym ekranie, możesz użyć polecenia less lub more. Każde z tych narzędzi po wyświetleniu jednego ekranu tekstu zatrzymuje się; aby wyświetlić kolejny ekran tekstu, musisz nacisnąć klawisz Spacja. Ponieważ te narzędzia wyświetlają po jednym ekranie (lub jak kto woli po jednej stronie za każdym razem), nazywane są poleceniami stronicującymi (ang. pagers). Choć oba polecenia są bardzo do siebie podobne, to jednak są między nimi pewne subtelne różnice. Na przykład polecenie less po wyświetleniu całej zawartości pliku wyświetla komunikat END i oczekuje, aż naciśniesz klawisz Q i dopiero po tym oddaje sterowanie do powłoki. Dla porównania polecenie more po zakończeniu wyświetlania od razu powraca do powłoki. W czasie działania obu poleceń naciśnięcie klawisza H powoduje wyświetlenie listy poleceń, których możesz używać, kiedy dane polecenie oczekuje na wciśnięcie klawisza po wyświetleniu kolejnego ekranu. Aby przekonać się, jak działają oba polecenia, możesz zamiast polecenia cat przedstawionego na rysunku 3.1 wykonać polecenie less praktyka albo more praktyka. Jeżeli chcesz poeksperymentować z wyświetlaniem dłuższego pliku, możesz wykonać polecenie less /etc/services. Więcej szczegółowych informacji na temat poleceń less i more znajdziesz na stronach podręcznika man.

Polecenia stronicujące

POLECENIE HOSTNAME — WYŚWIETLANIE NAZWY SYSTEMU Polecenie hostname wyświetla nazwę systemu, w którym obecnie pracujesz. Tego polecenia możesz użyć na przykład w sytuacji, kiedy nie jesteś pewny, czy zalogowałeś się do właściwego systemu. $ hostname helios

PRACA Z PLIKAMI W tej sekcji omówimy polecenia, za pomocą których możesz kopiować, przenosić, drukować, przeszukiwać, wyświetlać, sortować, porównywać oraz identyfikować pliki. Jeżeli używasz systemu OS X, zapoznaj się z informacjami przedstawionymi w dodatku D.

WSKAZÓWKA Dopełnianie nazw plików Po wpisaniu jednego lub więcej znaków nazwy pliku (która następuje po nazwie polecenia) naciśnij klawisz Tab. Powłoka Bourne Shell Again dopełni taką część nazwy pliku, jaką tylko będzie mogła. Jeżeli nazwa tylko jednego pliku rozpoczyna się od wpisanych przez Ciebie znaków, powłoka dopełni całą nazwę pliku i dodatkowo wstawi za nią jedną spację. Po dopełnieniu przez powłokę możesz kontynuować wpisywanie lub po prostu możesz nacisnąć klawisz Enter i wykonać wpisane polecenie. Jeżeli wpisane przez Ciebie znaki nie identyfikują pliku w jednoznaczny sposób, powłoka dopełnia taką część nazwy, jak to możliwe, i oczekuje na wpisanie dalszej części nazwy. Jeżeli naciśnięcie klawisza Tab nie spowoduje zmiany wyświetlanego tekstu, naciśnij ten klawisz ponownie (powłoka bash) lub klawisze Ctrl+D (powłoka tcsh), a na ekranie pojawi się lista możliwych dopełnień.

POLECENIE CP — KOPIOWANIE PLIKÓW Polecenie cp (ang. copy), patrz rysunek 3.2, pozwala na kopiowanie plików. Za pomocą tego polecenia możesz kopiować dowolne pliki, łącznie z plikami tekstowymi i binarnymi plikami wykonywalnymi. Polecenia cp możesz również używać do tworzenia kopii zapasowych plików czy kopii roboczych, których będziesz później używał do eksperymentowania. $ ls memo $ cp memo memo.kopia $ ls memo memo.kopia

Rysunek 3.2. Polecenie cp pozwala na kopiowanie plików

94  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX Polecenie cp wykorzystuje następującą składnię do określenia plików źródłowych i docelowych: cp plik_źródłowy plik_docelowy

Plik_źródłowy to nazwa pliku, który zostanie polecenie cp nada skopiowanemu plikowi.

skopiowany.

Plik_docelowy

to nazwa pliku, którą

Polecenie cp widoczne na rysunku 3.2 tworzy kopię pliku memo i nadaje jej nazwę memo.kopia. Kropka w nazwie tego pliku to część nazwy — po prostu kolejny znak. Początkowe polecenie ls pokazuje, że plik memo jest jedynym plikiem w tym katalogu. Po wykonaniu polecenia cp drugie wywołanie polecenia ls pokazuje już dwa pliki w katalogu, memo i memo.kopia. W pewnych sytuacjach bardzo przydatnym rozwiązaniem jest możliwość dodania daty do nazwy kopiowanego pliku. Polecenie przedstawione poniżej dołącza do nazwy kopiowanego pliku datę 30 stycznia 2011 (30012011): $ cp memo memo.30012011

Takie „rozszerzenie” nazwy pliku nie ma żadnego znaczenia dla systemu Linux, ale może Ci pomóc szybko odnaleźć wersję pliku, którą utworzyłeś właśnie tego dnia. Dołączanie daty do nazwy pliku pomoże Ci również uniknąć przypadkowego skasowania czy nadpisania istniejącego pliku (zakładając na przykład, że każdego dnia tworzysz nową kopię pliku, dodając do jego nazwy datę). Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Nazwy plików” w rozdziale 4. Jeżeli chcesz przekopiować pliki z jednego systemu do drugiego, znajdującego się w tej samej sieci, możesz skorzystać z poleceń scp lub ftp (patrz odpowiednio rozdział 17. i część VI książki).

OSTRZEŻENIE Polecenie cp może skasować plik Jeżeli plik docelowy istnieje przed wykonaniem polecenia cp, to jego wykonanie spowoduje nadpisanie pliku docelowego i tym samym usunięcie jego dotychczasowej zawartości. Ponieważ polecenie cp nadpisuje istniejący plik docelowy bez żadnego ostrzeżenia, musisz bardzo uważać, aby przypadkowo nie nadpisać pliku, który jest Ci potrzebny. Aby uniknąć takich niespodzianek, możesz skorzystać z interaktywnej wersji polecenia cp, która wywoływana jest poprzez dodanie opcji -i. Po dodaniu tej opcji polecenie cp przed nadpisaniem istniejącego pliku będzie prosiło o potwierdzenie chęci wykonania takiej operacji. Wskazówkę dotyczącą opcji znajdziesz w rozdziale 2. W przykładzie przedstawionym poniżej zakładamy, że plik o nazwie owoce.2 istniał przed wykonaniem polecenia cp. Po uruchomieniu polecenia użytkownik odpowiedział t na monit o potwierdzenie nadpisania pliku: $ cp -i owoce owoce.2 cp: zamazać 'owoce.2'? t

POLECENIE MV — ZMIANA NAZWY PLIKU Polecenie mv (ang. move) pozwala na zmianę nazwy pliku bez konieczności tworzenia jego kopii. Składnia tego polecenia jest niemal identyczna jak w przypadku polecenia cp: cp nazwa_istniejącego_pliku nowa_nazwa pliku

Polecenie przedstawione na rysunku 3.3 powoduje zmianę nazwy pliku memo na memo.30012011. Pierwsze wywołanie polecenia ls pokazuje, że plik o nazwie memo jest jedynym plikiem w tym katalogu. Po wykonaniu polecenia mv nazwa pliku zostaje zmieniona i jedyny plik w tym katalogu nosi teraz nazwę memo.30012011. Porównaj wyniki działania tych poleceń z przykładem z poleceniem cp na rysunku 3.2.

Praca z plikami  95

$ ls memo $ mv memo memo.30012011 $ ls memo.30012011

Rysunek 3.3. Polecenie mv pozwala na zmianę nazwy pliku

Polecenie mv może być używane nie tylko do zmiany nazwy pliku. Więcej informacji na ten temat znajdziesz w sekcji „Polecenia mv i cp — przenoszenie lub kopiowanie plików” w rozdziale 4. Dodatkowe informacje na temat polecenia mv znajdziesz również na stronach podręcznika info.

OSTRZEŻENIE Polecenie mv może skasować plik Niewłaściwie użyte polecenie mv może, podobnie jak polecenie cp, spowodować niezamierzone skasowanie pliku i — podobnie jak polecenie cp — posiada opcję -i (interaktywne). Więcej informacji na ten temat znajdziesz w ramce „Polecenie cp może skasować plik” w poprzedniej sekcji.

POLECENIE LPR — DRUKOWANIE PLIKU Polecenie lpr (ang. line printer) pozwala na umieszczenie jednego lub więcej plików w kolejce drukarki i w efekcie wydrukowanie ich zawartości. System Linux obsługuje kolejki wydruków, dzięki czemu w danej chwili na danej drukarce drukowany jest tylko jeden plik. Zastosowanie kolejek wydruku pozwala wielu użytkownikom i zadaniom na równoczesne wysyłanie plików na daną drukarkę i otrzymanie oczekiwanych rezultatów. W przypadku systemów, w których zainstalowana jest więcej niż jedna drukarka, możesz wyświetlić listę dostępnych urządzeń, wykonując polecenie lpstat -p. Użycie opcji -P powoduje, że polecenie lpr umieszcza drukowany plik w kolejce wybranej drukarki — nawet takiej, która jest fizycznie podłączona do innego systemu dostępnego w sieci. Wykonanie polecenia przedstawionego poniżej powoduje wydrukowanie pliku o nazwie raport: $ lpr raport

Ponieważ w składni tego polecenia nie została wymieniona konkretna drukarka, wydruk zostanie wykonany na drukarce domyślnej (czyli po prostu na drukarce, jeżeli do Twojego komputera jest podłączone tylko jedno takie urządzenie). Kolejne polecenie przedstawione poniżej powoduje wydrukowanie pliku raport na drukarce o nazwie kancelaria: $ lpr -P kancelaria raport

Jednym poleceniem możesz wysłać na drukarkę więcej niż jeden plik. Polecenie przedstawione poniżej wysyła na drukarkę o nazwie laser1 trzy pliki tekstowe: $ lpr -P laser1 05.txt 108.txt 12.txt

Jeżeli chcesz zobaczyć, jakie zadania znajdują się w chwili obecnej w kolejce drukarki, powinieneś wykonać polecenie lpstat -o lub lpq:

lpq

$ lpq lp jest gotowe i drukuje Status Właściciel Zadanie Pliki Całkowity rozmiar aktywne helion 86 (standardowe wejście) 954061 bajtów

W tym przykładzie użytkownik helion posiada jedno zadanie, które jest w trakcie wydruku; w kolejce nie ma żadnych innych zadań. W razie potrzeby możesz użyć numeru zadania (w tym przypadku 86) do usunięcia zadania z kolejki i zatrzymania drukowania. Aby to zrobić, powinieneś skorzystać z polecenia lprm:

lprm

$ lprm 86

96  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX

POLECENIE GREP — WYSZUKIWANIE ŁAŃCUCHÓW TEKSTU Polecenie grep1 przeszukuje jeden lub więcej plików pod kątem występowania w nich określonego łańcucha znaków. Wykonanie tego polecenia nie zmienia w żaden sposób zawartości pliku, ale po prostu wyświetla na ekranie wiersz tekstu zawierający poszukiwany ciąg znaków. Polecenie grep przedstawione na rysunku 3.4 przeszukuje zawartość pliku memo pod kątem wierszy zawierających słowo kredyt i wyświetla na ekranie wiersz spełniający kryterium wyszukiwania. Jeżeli w pliku memo będą znajdowały się takie słowa jak kredytowy, kredytobiorca czy akredytacja, to polecenie grep również wyświetli takie wiersze, ponieważ zawierają poszukiwany ciąg znaków. Dodanie opcji -w (ang. words) powoduje, że polecenie grep będzie wyszukiwało tylko całe słowa. Poszukiwanego ciągu znaków nie trzeba ujmować w znaki apostrofu, ale należy to zrobić w sytuacji, kiedy zawiera on spacje i inne znaki specjalne. $ cat memo Helena: Podczas naszego spotkania w dniu 6 czerwca omawialiśmy sprawy związane z wnioskiem o kredyt. Czy w związku z tym masz jeszcze jakieś inne uwagi? Marek $ grep 'kredyt' memo omawialiśmy sprawy związane z wnioskiem o kredyt.

Rysunek 3.4. Polecenie grep pozwala na wyszukiwanie ciągu znaków

Polecenie grep posiada znacznie większe możliwości niż tylko proste wyszukiwanie ciągu znaków w pojedynczym pliku. Więcej informacji na ten temat znajdziesz w części VI książki oraz w dodatku A „Wyrażenia regularne”.

POLECENIE HEAD — WYŚWIETLANIE POCZĄTKOWYCH WIERSZY PLIKU Domyślnie polecenie head wyświetla pierwszych dziesięć wierszy zawartości pliku. Tego polecenia możesz używać do szybkiego sprawdzenia zawartości wybranego pliku. Na przykład: jeżeli masz dany plik, w którym znajdują się nazwy kolejnych miesięcy roku ułożonych w kolejności kalendarzowej po jednej nazwie w wierszu, to wykonanie polecenia head spowoduje wyświetlenie nazw miesięcy od stycznia do października (patrz rysunek 3.5). $ head miesiące styczeń luty marzec kwiecień maj czerwiec lipiec sierpień wrzesień październik $ tail -5 miesiące sierpień wrzesień październik listopad grudzień

Rysunek 3.5. Polecenie head wyświetla domyślnie 10 pierwszych wierszy pliku 1

Nazwa grep pochodzi od sekwencji poleceń edytora ed — dostępnego początkowo w systemie UNIX a teraz również w większości dystrybucji: g/re/p. W tej sekwencji g oznacza polecenie globalne, re to wyrażenie regularne (ang. regular expression) oddzielone znakami prawego ukośnika, a p oznacza drukowanie (ang. print) — przyp. autora.

Praca z plikami  97

Za pomocą polecenia head możesz wyświetlać dowolną liczbę wierszy zawartości pliku, zatem możesz go użyć na przykład do wyświetlenia tylko pierwszego wiersza, pełnego ekranu tekstu lub więcej. Aby określić liczbę wyświetlanych wierszy, powinieneś w wierszu wywołania dodać myślnik, a po nim liczbę wierszy, które chcesz wyświetlić. Na przykład wykonanie polecenia przedstawionego poniżej powoduje wyświetlenie tylko pierwszego wiersza pliku miesiące: $ head -1 miesiące styczeń

Polecenie head potrafi również wyświetlać fragmenty pliku w oparciu o liczbę bloków lub znaków (zamiast zliczania wierszy). Więcej informacji na ten temat znajdziesz w części VI książki.

POLECENIE TAIL — WYŚWIETLANIE WIERSZY Z KOŃCA PLIKU Polecenie tail jest bardzo podobne do polecenia head, z tym że domyślnie wyświetla dziesięć ostatnich wierszy pliku. W zależności od tego, w jaki sposób zostanie wywołane, polecenie to może wyświetlać więcej lub mniej niż dziesięć wierszy, zliczać bloki tekstu lub znaki i na tej podstawie wyświetlać fragmenty zawartości pliku lub wyświetlać wiersze, które są dodawane do zmieniającego się pliku. Polecenie tail przedstawione na rysunku 3.5 wyświetla 5 ostatnich wierszy pliku miesiące (od sierpnia do grudnia). W razie potrzeby możesz używać polecenia tail do monitorowania wierszy dodawanych na końcu rosnącego pliku (na przykład pliku dziennika systemowego). Aby to zrobić, powinieneś skorzystać z następującego polecenia: $ tail -f nazwapliku

Aby zatrzymać działanie takiego polecenia tail i powrócić do znaku zachęty powłoki, naciśnij klawisz przerwania zadania (zazwyczaj jest to kombinacja klawiszy Ctrl+C). Więcej informacji na ten temat znajdziesz w części VI książki.

POLECENIE SORT — WYŚWIETLANIE ZAWARTOŚCI PLIKU W OKREŚLONEJ KOLEJNOŚCI Polecenie sort wyświetla zawartość pliku, sortując wiersze w określonej kolejności. Działanie polecenia nie zmienia w żaden sposób oryginalnej zawartości pliku. Na rysunku 3.6 użyto polecenia cat do wyświetlenia zawartości pliku DniTygodnia, zawierającego nazwy poszczególnych dni tygodnia zapisane w kolejności kalendarzowej. Następnie polecenie sort zostało użyte do wyświetlenia zawartości pliku w kolejności alfabetycznej. $ cat DniTygodnia poniedziałek wtorek środa czwartek piątek sobota niedziela $ sort DniTygodnia czwartek niedziela piątek poniedziałek sobota środa wtorek

Rysunek 3.6. Polecenie sort wyświetla zawartość pliku w określonej kolejności

98  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX Polecenie sort jest bardzo przydatne do wyświetlania posortowanej zawartości różnego rodzaju list i zestawień. Dodanie opcji -u powoduje wyświetlenie posortowanej listy z usunięciem powtarzających się wierszy (usuwanie duplikatów). Opcja -n pozwala na sortowanie listy liczb w kolejności numerycznej. Więcej informacji na ten temat znajdziesz w części VI książki.

POLECENIE UNIQ — USUWANIE POWTARZAJĄCYCH SIĘ WIERSZY Z PLIKU Polecenie uniq (ang. unique) wyświetla zawartość pliku, pomijając sąsiadujące ze sobą, powtarzające się wiersze. Działanie tego polecenia w żaden sposób nie zmienia oryginalnej zawartości pliku. Na przykład: jeżeli plik zawiera listę nazwisk i znajdują się w nim dwa kolejne wiersze zawierające to samo imię, to podczas wyświetlania zawartości pliku polecenie uniq pominie powtarzający się wiersz (patrz rysunek 3.7). $ cat duplikaty Kasia Franek Jacek Jerzy Maria Maria Paulina $ uniq duplikaty Kasia Franek Jacek Jerzy Maria Paulina

Rysunek 3.7. Polecenie uniq usuwa powtarzające się wiersze

Jeżeli zawartość pliku zostanie wcześniej posortowana, to użycie polecenia uniq gwarantuje, że wyświetlone wyniki nie będą zawierały powtarzających się wierszy (oczywiście taki sam efekt można osiągnąć, używając polecenia sort z opcją -u). Więcej informacji na ten temat znajdziesz w części VI książki.

POLECENIE DIFF — PORÓWNYWANIE ZAWARTOŚCI DWÓCH PLIKÓW Polecenie diff (ang. difference) pozwala na porównywanie zawartości dwóch plików i wyświetla listę różnic między nimi. Również i to polecenie nie zmienia w żaden sposób oryginalnej zawartości porównywanych plików i jest bardzo przydatne do porównywania na przykład dwóch wersji listów, raportów czy dwóch wersji kodu źródłowego jakiegoś programu. Dodanie opcji -u (zunifikowany format wyjściowy) najpierw wyświetla nazwy porównywanych plików i oznacza je znakami plus (+) i minus (-). Na rysunku 3.8 znakiem (-) został oznaczony plik kolory.1, a znakiem (+) plik kolory.2. $ diff -u kolory.1 kolory.2 --- kolory.1 2011-04-05 10:12:12.322528610 -0700 +++ kolory.2 2011-04-05 10:12:18.420531033 -0700 @@ -1,6 +1,5 @@ czerwony +niebieski zielony żółty -różowy -purpurowy pomarańczowy

Rysunek 3.8. Polecenie diff wyświetlające różnice między plikami w formacie zunifikowanym

Symbol potoku | — komunikacja między procesami  99

Polecenie diff -u powoduje podzielenie długiego, wielowierszowego tekstu na fragmenty (ang. hunks). Każdy fragment jest poprzedzony wierszem rozpoczynającym się i kończącym się dwoma znakami @@. Taki znacznik zawiera informacje o początkowym numerze wiersza oraz ilości wierszy każdego pliku, z jakich składa się dany fragment. Fragment widoczny na rysunku 3.8 ilustruje sekcję pliku kolor.1 (oznaczonego znakiem -) obejmującą wiersze od pierwszego do szóstego. Następujący po nim zapis +1,5 oznacza, że w ramach tego fragmentu z pliku kolory.2 porównywane są wiersze od pierwszego do piątego. Po wyświetleniu wierszy nagłówka z nazwami i oznaczeniami plików polecenie diff -u wyświetla kolejne wiersze tekstu poprzedzone znakami minus (-), plus (+) lub znakiem spacji. Znak minus na początku wiersza oznacza, że taki wiersz występuje tylko w pliku oznaczonym znakiem minus (-). Znak plus na początku wiersza oznacza, że taki wiersz występuje tylko w pliku oznaczonym znakiem plus (+). Wiersze oznaczone na początku znakiem spacji (bez plusa i minusa) występują w obu plikach na tych samych miejscach. Więcej informacji na ten temat znajdziesz w części VI książki.

POLECENIE FILE — ROZPOZNAWANIE ZAWARTOŚCI PLIKU Polecenia file możesz używać do rozpoznawania zawartości dowolnego pliku w systemie Linux bez konieczności otwierania takiego pliku i samodzielnego sprawdzania. W przykładzie przedstawionym poniżej polecenie file raportuje, że plik list_e.bz2 zawiera dane, które zostały skompresowane za pomocą polecenia bzip2: $ file list_e.bz2 list_e.bz2: bzip2 compressed data, block size = 900k

W kolejnym przykładzie polecenie file zostało użyte do rozpoznania zawartości dwóch plików: $ file memo zachód.jpg memo: ASCII text zach.jpg: JPEG image data, ... resolution (DPI), 72 x 72

Więcej informacji na ten temat znajdziesz w części VI książki.

SYMBOL POTOKU | — KOMUNIKACJA MIĘDZY PROCESAMI Ponieważ potoki komunikacyjne są elementem krytycznym dla poprawnego funkcjonowania systemu Linux, w tym podrozdziale omówimy ich zastosowanie praktyczne w przykładach. Więcej informacji na temat potoków znajdziesz w rozdziale 5. W systemie OS X potoki działają jedynie z danymi pliku, natomiast nie działają z tak zwanymi resource forks. Symbol potoku (zapisywany w wierszu poleceń jako pionowa kreska |, a na klawiaturze przedstawiany jako ciągła lub podzielona na dwie części pionowa kreska) zapewnia najprostszą formę takiej komunikacji. Użyty w ten sposób symbol potoku powoduje, że dane pobierane są z wyjścia jednego polecenia lub programu i przesyłane jako dane wejściowe dla innego polecenia. Inaczej mówiąc, potok pobiera dane ze standardowego wyjścia jednego procesu i przekierowuje do standardowego wejścia innego procesu. Więcej informacji na ten temat znajdziesz w sekcji „Standardowe wejście i standardowe wyjście danych” w rozdziale 5. Niektóre narzędzia, takie jak head, mogą przyjmować dane wejściowe z pliku wskazanego w wierszu poleceń lub za pośrednictwem potoku ze standardowego wejścia. W poleceniu przedstawionym poniżej polecenie sort przetwarza plik miesiące (patrz rysunek 3.5), a powłoka za pomocą symbolu potoku (inaczej mówiąc, za pomocą znaku przekierowania strumienia danych) pobiera dane z wyjścia polecenia sort i przesyła na wejście polecenia head, które finalnie wyświetla pierwsze cztery wiersze posortowanej listy: $ sort miesiące | head -4 czerwiec grudzień kwiecień lipiec

100  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX wc

Polecenie przedstawione w następnym przykładzie wyświetla liczbę plików w katalogu. Polecenie (ang. word count) z opcją -w (ang. words) wyświetla liczbę słów w wejściowym strumieniu danych lub w pliku podanym w wierszu poleceń jako argument tego polecenia: wc

$ ls | wc -w 14

Symbolu potoku możesz użyć również do przesłania danych ze standardowego wyjścia programu na drukarkę: $ tail miesiące | lpr

KOLEJNE CZTERY NARZĘDZIA Polecenia echo oraz date są jednymi z najczęściej używanych narzędzi systemu Linux. Polecenie script rejestruje sesję użytkownika z powłoką w pliku, a polecenie unix2dos przetwarza plik tekstowy tak, aby mógł być odczytywany na komputerach działających pod kontrolą systemu Windows lub OS X.

POLECENIE ECHO — WYŚWIETLANIE TEKSTU NA EKRANIE Polecenie echo wyświetla na ekranie ciąg znaków podany w wierszu poleceń jako argument tego polecenia. Na rysunku 3.9 przedstawiono wyniki działania kilku poleceń echo. Ostatnie polecenie pokazuje, w jaki sposób powłoka traktuje znak gwiazdki * (ang. asterisk), który został wpisany w wierszu poleceń bez ujmowania go w apostrofy — znak gwiazdki rozwijany jest do postaci listy nazw plików przechowywanych w danym katalogu. $ ls memo memo.1407 praktyka $ echo Cześć Cześć $ echo To jest zdanie przykładowe. To jest zdanie przykładowe. $ echo gwiazdka: * gwiazdka: memo memo.1407 praktyka

Rysunek 3.9. Polecenie echo kopiuje tekst z wiersza poleceń na ekran (z wyjątkiem słowa „echo”)

Polecenie echo jest dobrym narzędziem do poznawania sposobu działania powłoki i innych narzędzi systemu Linux. Wiele przykładów, które znajdziesz w rozdziale 5., ilustruje sposób działania znaków specjalnych, takich jak gwiazdka (*). Inne przykłady zastosowania polecenia echo, zamieszczone w rozdziałach 5., 8. i 10., pomagają wyjaśnić, w jaki sposób działają zmienne powłoki i w jaki sposób możesz przesyłać komunikaty ze skryptów powłoki na ekran. Więcej informacji na ten temat polecenia echo w części VI książki.

INFORMACJE DODATKOWE Polecenia echo możesz użyć do utworzenia na dysku prostego pliku tekstowego. Aby to zrobić, powinieneś przekierować wyjście polecenia echo do pliku: $ echo 'Mój nowy plik tekstowy.' > mójplik $ cat mójplik Mój nowy plik tekstowy.

Znak większości (>), użyty w tym przykładzie, informuje powłokę, że strumień danych z wyjścia polecenia echo powinien zostać przekierowany do pliku o nazwie mójplik zamiast na ekran. Więcej informacji na ten temat znajdziesz w sekcji „Przekierowywanie standardowego wyjścia danych” w rozdziale 5.

Kolejne cztery narzędzia  101

POLECENIE DATE — WYŚWIETLANIE BIEŻĄCEJ DATY I CZASU Polecenie date wyświetla bieżącą datę i czas: $ date śro, 28 gru 2011, 18:21:25 EST

Przykład przedstawiony poniżej ilustruje sposób, w jaki możesz zdefiniować format i zawartość wyświetlanej informacji o dacie: $ date +"%A %B %d" środa grudzień 28

Więcej informacji na ten temat znajdziesz w części VI książki.

POLECENIE SCRIPT — REJESTROWANIE SESJI POWŁOKI Polecenie script rejestruje całą sesję (lub jej fragment) użytkownika z powłoką systemu, łącznie z poleceniami wpisywanymi przez użytkownika i odpowiedziami systemu. To polecenie jest przydatne tylko do pracy z urządzeniami tekstowymi, takimi jak terminal czy emulator terminala. Sesja użytkownika jest przechwytywana za pomocą edytora tekstu vim, aczkolwiek ze względu na fakt, że vim używa znaków sterujących do pozycjonowania kursora i wyświetlania atrybutów tekstu (takich jak pogrubienie), wyniki działania mogą być trudne do przeczytania i stąd mało użyteczne. Kiedy użyjesz polecenia cat do wyświetlenia zawartości pliku przechwyconego w sesji vim, to cała zawartość zostanie szybko wyświetlona na ekranie. Domyślnie polecenie script zapisuje przechwyconą sesję w pliku o nazwie typescript. Aby zdefiniować inną nazwę pliku, powinieneś po nazwie polecenia script wstawić spację i po niej wpisać żądaną nazwę pliku. Aby dołączyć zapis przechwyconej sesji do istniejącego pliku, powinieneś poprzedzić nazwę pliku opcją -a, w przeciwnym wypadku polecenie script nadpisze istniejący plik. Poniżej przedstawiamy przykładowy zapis sesji przechwyconej poleceniem script: $ script Skrypt uruchomiony, plik to typescript $ ls -l /bin | head -5 razem 7804 -rwxr-xr-x. 1 root root 123 02-07 17:32 -rwxr-xr-x. 1 root root 25948 02-08 03:46 lrwxrwxrwx. 1 root root 4 02-25 16:52 -rwxr-xr-x. 1 root root 25088 02-08 03:46 $ exit exit Script wykonany, plik to typescript

alsaunmute arch awk -> gawk basename

Do zakończenia przechwytywania sesji poleceniem script powinieneś użyć komendy exit. Zawartość utworzonego pliku możesz wyświetlić za pomocą polecenia cat, less, more lub dowolnego edytora tekstu. Poniżej przedstawiamy zawartość pliku utworzonego poleceniem script w przykładzie powyżej: $ cat typescript Skrypt uruchomiony śro, 28 gru 2011, 18:38:04 $ ls -l /bin | head -5 razem 7804 -rwxr-xr-x. 1 root root 123 02-07 17:32 alsaunmute -rwxr-xr-x. 1 root root 25948 02-08 03:46 arch lrwxrwxrwx. 1 root root 4 02-25 16:52 awk -> gawk -rwxr-xr-x. 1 root root 25088 02-08 03:46 basename $ exit exit Skrypt wykonany śro, 28 gru 2011, 18:38:23

Jeżeli będziesz edytował zawartość pliku przy użyciu edytora vim, emacs czy dowolnego innego edytora tekstu, możesz wcześniej użyć polecenia dos2unix (patrz kolejna sekcja) do usunięcia z pliku typescript wszystkich znaków ^M znajdujących się na końcach poszczególnych wierszy. Więcej informacji na ten temat znajdziesz na stronach podręcznika man polecenia script.

102  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX

POLECENIE UNIX2DOS — KONWERSJA PLIKÓW LINUX I OS X DO FORMATU WINDOWS Jeżeli chcesz udostępnić plik tekstowy utworzony w systemie Linux innym użytkownikom, pracującym na komputerach z systemem Windows lub OS X, musisz najpierw dokonać konwersji pliku na format, który może być przez takich użytkowników łatwo odczytany. Polecenie unix2dos dokonuje konwersji plików tekstowych systemu Linux na format, który może być poprawnie odczytany w systemie Windows; z kolei polecenie unix2mac dokonuje takiej konwersji do formatu używanego w systemach OS X. Oba narzędzia są częścią pakietu oprogramowania o nazwie dos2unix. W niektórych dystrybucjach zamiast dos2unix używany jest pakiet todos. Wspomniany pakiet todos jest częścią oprogramowania tofrodos, które nie oferuje narzędzi pozwalających na konwersję plików na postać przeznaczoną dla systemu OS X. Jeżeli używasz unix2dos, aby dokonać konwersji pliku tekstowego o nazwie memo.txt (utworzonego za pomocą edytora tekstu) do formatu DOS, powinieneś wykonać polecenie przedstawione poniżej (aby dokonać konwersji do formatu Macintosh, użyj polecenia unix2mac):

unix2dos, unix2mac

$ unix2dos memo.txt

Teraz możesz przesłać taki plik za pomocą poczty elektronicznej do innego użytkownika, który korzysta z systemu Windows lub OS X. Pamiętaj, że wykonanie takiego polecenia nadpisuje oryginalną zawartość pliku. Polecenie dos2unix dokonuje konwersji plików zapisanych w formacie Windows, tak aby mogły być odczytywane w systemie Linux (aby dokonać konwersji do formatu OS X, użyj polecenia dos2mac):

dos2unix, dos2mac

$ dos2unix memo.txt

Więcej informacji na ten temat znajdziesz na stronach podręcznika man polecenia dos2unix. tr

Aby dokonać konwersji pliku tekstowego zapisanego w formacie Windows lub OS X do formatu Linux, możesz również użyć polecenia tr (ang. translate). W przykładzie przedstawionym poniżej opcja -d (ang. delete) powoduje, że polecenie tr usuwa z przetwarzanego pliku wszystkie znaki powrotu karetki (reprezentowane przez literał \r) i zapisuje zmodyfikowaną kopię pliku: $ cat memo | tr -d '\r' > memo.txt

Znak większości (>) użyty w poleceniu przekierowuje strumień danych ze standardowego wyjścia polecenia tr do pliku o nazwie memo.txt. Więcej informacji na ten temat znajdziesz w sekcji „Przekierowywanie standardowego wyjścia danych” w rozdziale 5. Dokonanie konwersji w inny sposób, bez użycia polecenia unix2dos, nie jest już tak proste.

KOMPRESOWANIE I ARCHIWIZACJA PLIKÓW Duże pliki mogą zajmować wiele miejsca na dysku, a ich przesyłanie z jednego systemu na drugi poprzez sieć zajmuje znacznie więcej czasu. Aby zredukować ilość miejsca zajmowanego przez takie pliki na dysku bez całkowitego usuwania plików, możesz dokonać kompresji pliku bez utraty jego zawartości. Pojedyncze archiwum zawierające wiele skompresowanych plików jest łatwiejsze w zarządzaniu, łatwiej też je przesyłać po sieci, pobierać z serwera czy przesyłać jako załącznik wiadomości poczty elektronicznej. Skompresowane archiwa będziesz bardzo często pobierał również z sieci Internet. Narzędzia opisywane w tej sekcji umożliwiają kompresowanie i dekompresowanie plików oraz pakowanie i rozpakowywanie plików archiwum.

Kompresowanie i archiwizacja plików  103

POLECENIE BZIP2 — KOMPRESOWANIE PLIKÓW Polecenie bzip2 umożliwia kompresowanie zawartości pliku poprzez dokonanie jego analizy i przekodowanie w odpowiedni sposób. Zawartość nowej wersji pliku wygląda zupełnie inaczej niż oryginał. W praktyce ze względu na fakt, że nowy, skompresowany plik zawiera wiele znaków niedrukowalnych, bezpośrednie przeglądanie jego zawartości staje się niemożliwe. Polecenie bzip2 jest szczególnie efektywne w przypadku plików zawierających wiele powtarzających się informacji, takich jak tekst i obrazy (aczkolwiek należy pamiętać, że wiele formatów obrazów z definicji przechowuje dane w postaci skompresowanej). Zawartość pliku użytego w poniższym przykładzie jest dosyć nudna. Każdy z 8000 wierszy pliku lista_e składa się z 72 liter e i jest zakończony znakiem nowego wiersza. Taki plik zajmuje na dysku ponad pół megabajta miejsca. $ ls -l -rw-rw-r--. 1 helion pubs 584000 2011-02-07 22:31 lista_e

Opcja -l (ang. long) powoduje, że polecenie ls wyświetla więcej informacji o poszczególnych plikach. Na naszym przykładzie widać, że plik lista_e ma rozmiar 584 000 bajtów. Użycie opcji -v (ang. verbose) powoduje, że polecenie bzip2 wyświetla informacje o tym, jak bardzo udało się podczas kompresji zmniejszyć rozmiar pliku. W naszym przypadku rozmiar pliku został zredukowany aż o 99,99%: $ bzip2 -v lista_e lista_e: 11680.00:1, 0.001 bits/byte, 99.99% saved, 584000 in, 50 out. $ ls -l -rw-rw-r--. 1 helion pubs 50 2011-02-07 22:32 lista_e.bz2

Po skompresowaniu nasz plik zajmuje tylko 50 bajtów. Użycie polecenia spowodowało również zmianę nazwy pliku, dodając do jego nazwy rozszerzenie .bz2. Utrzymanie takiej konwencji nadawania nazw skompresowanym plikom pozwala Ci łatwo zorientować się, że dany plik został skompresowany, dzięki czemu nie będziesz próbował wyświetlać jego zawartości czy drukować bez uprzedniej dekompresji. Skompresowanie pliku przy użyciu polecenia bzip2 nie powoduje zmiany znacznika czasu modyfikacji pliku, pomimo że cała zawartość pliku po kompresji ulega zmianie.

.bz2 — rozszerzenie nazwy pliku bzip2

WSKAZÓWKA Zachowaj oryginalny plik, dodając opcję -k Polecenie bzip2 (i jego polecenie dopełniające, bunzip2) domyślnie po dokonaniu kompresji (bądź odpowiednio dekompresji) usuwa oryginalny plik, zastępując go skompresowaną (bądź zdekompresowaną) wersją. Jeżeli chcesz, aby oryginalny plik został zachowany w nienaruszonym stanie, powinieneś podczas wywołania polecenia dodać opcję -k. Poniżej przedstawiamy kolejny, bardziej realistyczny przykład, gdzie w pliku zachód.jpg przechowywane jest zdjęcie: $ ls -l -rw-r--r--. 1 helion pubs 33287 2011-02-07 22:40 zachód.jpg

Polecenie bzip2 jest w stanie zredukować rozmiar tego pliku tylko o 28%, ponieważ oryginalne zdjęcie jest zapisane w formacie, który z definicji przechowuje już dane w postaci skompresowanej: $ bzip2 -v zachód.jpg zach.jpg: 1.391:1, 5.749 bits/byte, 28.13% saved, 33287 in, 23922 out. $ ls -l -rw-r--r--. 1 helion pubs 23922 2011-02-07 22:41 zachód.jpg.bz2

Więcej szczegółowych informacji na ten temat znajdziesz w części VI książki, na stronie http://www.bzip.org/ lub w dokumencie Bzip2 mini-HOWTO (w rozdziale 1. wyjaśniono, jak uzyskać dostęp do dokumentów HOWTO).

104  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX

POLECENIA BZCAT ORAZ BUNZIP2 — DEKOMPRESOWANIE PLIKÓW Polecenie bzcat wyświetla zawartość pliku, który został skompresowany za pomocą polecenia Łatwo zauważyć, że polecenie to jest odpowiednikiem polecenia cat dla plików .bz2. Po uruchomieniu polecenie bzcat automatycznie dokonuje dekompresji pliku i wyświetla jego zawartość na ekranie. Polecenie bzcat — podobnie jak polecenie cat — w żaden sposób nie zmienia oryginalnej zawartości pliku. W przykładzie przedstawionym poniżej strumień danych ze standardowego wyjścia polecenia bzcat został za pomocą potoku przekierowany na wejście polecenia head, które wyświetla pierwsze dwa wiersze pliku:

bzcat

bzip.

$ bzcat lista_e.bz2 | head -2 eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee eeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeeee

Po wykonaniu polecenia bzcat zawartość pliku lista_e.bz2 nie zmienia się; plik jest nadal przechowywany na dysku w postaci skompresowanej. bunzip

Polecenie bunzip2 przywraca pierwotną postać pliku skompresowanego poleceniem bzip2:

$ bunzip2 lista_e.bz2 $ ls -l -rw-rw-r--. 1 helion pubs 584000 03-01 22:31 lista_e $ bunzip2 zachód.jpg.bz2 $ ls -l -rw-r--r--. 1 helion pubs 33287 03-01 22:40 zachód.jpg

Polecenie bzip2recover pozwala na częściowe odzyskiwanie danych ze skompresowanego pliku uszkodzonego na skutek błędów nośnika. Jeżeli chcesz spróbować odzyskać dane z takiego pliku, powinieneś w wierszu poleceń wpisać bzip2recover , gdzie to nazwa uszkodzonego pliku.

bzip2recover

POLECENIE GZIP — KOMPRESOWANIE PLIKÓW Polecenie gzip (ang. GNU zip) jest starsze i mniej wydajne niż bzip2. Jego składnia, opcje i sposób działania są bardzo podobne do tych z polecenia bzip2. Nazwa pliku skompresowanego przy użyciu polecenia gzip jest oznaczana rozszerzeniem .gz. Dla zaoszczędzenia miejsca na dysku strony podręcznika systemu Linux są przechowywane w skompresowanych plikach .gz, często również pliki pobierane z sieci Internet są skompresowane i przesyłane w tym formacie. Poleceń gzip, gunzip oraz zcat możesz używać w taki sam sposób, jak używałeś poleceń odpowiednio bzip2, bunzip2 oraz bzcat. Więcej szczegółowych informacji na ten temat znajdziesz w części VI książki.

Polecenia gunzip i zcat

Polecenie compress również pozwala na kompresowanie zawartości plików, aczkolwiek nie robi tego tak dobrze jak polecenie gzip. Nazwa pliku skompresowanego za pomocą polecenia compress jest oznaczana poprzez dodanie do nazwy rozszerzenia .Z.

Polecenie compress

WSKAZÓWKA Polecenie gzip kontra zip Nie powinieneś mylić poleceń gzip oraz gunzip z poleceniami odpowiednio zip i unzip. Ostatnie dwa polecenia są wykorzystywane do pakowania i rozpakowywania archiwów zawierających wiele plików, które zostały zaimportowane z systemu Windows lub są przeznaczone do wysłania na taki system. Polecenie zip tworzy archiwum zip, podczas gdy polecenie unzip pozwala na rozpakowanie archiwum zip. Polecenia zip oraz unzip są kompatybilne z poleceniem PKZIP, czyli programem dla systemu Windows, który pozwala na kompresowanie i archiwizację plików.

Kompresowanie i archiwizacja plików  105

POLECENIE TAR — PAKOWANIE I ROZPAKOWYWANIE ARCHIWÓW Polecenie tar realizuje wiele funkcji. Jego nazwa to akronim angielskiego określenia tape archive (archiwum taśmowe), ponieważ jego początkowym zadaniem było tworzenie i odczytywanie archiwów i kopii zapasowych przechowywanych na nośnikach taśmowych. Obecnie polecenie tar jest wykorzystywane do tworzenia pojedynczego pliku archiwum (nazywanego plikiem tar, archiwum lub tarball) zawierających wiele innych plików, a nawet całe struktury katalogów, oraz odczytywania plików z takich archiwów. Przedstawione w części VI książki polecenia cpio i pax spełniają podobną rolę. W przykładzie przedstawionym poniżej pierwsze polecenie ls wyświetla rozmiary plików o nazwach g, b oraz d. Następnie użyte zostaje polecenie tar z opcjami -c (ang. create), -v (ang. verbose) i -f (ang. file; zapis do pliku lub odczytywanie danych z pliku), które tworzy plik archiwum o nazwie pliki.tar, zawierający wszystkie wymienione pliki. Poszczególne wiersze wyników działania tego polecenia pokazują nazwy plików, które są dołączane do tworzonego archiwum. Polecenie tar oprócz samych plików zapisuje w archiwum dodatkowe informacje, stąd plik archiwum zajmuje 9700 bajtów, podczas gdy suma rozmiarów plików składowych wynosi około 6000 bajtów (co ilustrują wyniki działania kolejnego polecenia ls). Zjawisko to jest najbardziej widoczne w przypadku tworzenia archiwów o niewielkich rozmiarach, tak jak to zostało przedstawione w naszym przykładzie: $ ls -l g b d -rw-r--r--. 1 helion other 1178 2011-02-08 14:16 -rw-r--r--. 1 helion helion 3783 2011-02-08 14:17 -rw-r--r--. 1 helion helion 1302 2011-02-08 14:16 $ tar -cvf pliki.tar g b d g b d $ ls -l pliki.tar -rw-r--r--. 1 helion helion 9728 2011-02-08 14:17 $ tar -tvf pliki.tar -rw-r--r-- helion /helion 1302 2011-02-08 14:16 g -rw-r--r-- helion /other 1178 2011-02-08 14:16 b -rw-r--r-- helion /helion 3783 2011-02-08 14:17 d

b d g

pliki.tar

Ostatnie polecenie w powyższym przykładzie używa opcji -t do wyświetlenia tabeli zawartości archiwum. Jeżeli chciałbyś wypakować pliki z archiwum, powinieneś zamiast opcji -t użyć opcji -x (ang. extract). Jeżeli chcesz, aby polecenie tar podczas pracy było mniej „gadatliwe”, możesz pominąć opcję -v2. Do kompresowania plików .tar możesz używać omawianych wcześniej poleceń bzip2, compress lub — po skompresowaniu takie pliki będą zajmować mniej miejsca, co ułatwi ich składowanie, przetwarzanie i przesyłanie. Wiele plików, które będziesz pobierał z sieci Internet, jest zapisanych w jednym z tych formatów. Pliki archiwum, które zostały przygotowane poleceniem tar i następnie skompresowane poleceniem bzip2, często mają rozszerzenie .tar.bz2 lub .tbz. Pliki przygotowane poleceniem tar i skompresowane poleceniem gzip mają rozszerzenia .tar.gz lub .tz, natomiast pliki .tar skompresowane poleceniem compress mają zwykle rozszerzenie .tar.Z. gzip

Pliki archiwum przygotowane poleceniem tar i następnie skompresowane poleceniem gzip możesz rozpakować w dwóch etapach (procedury opisanej poniżej możesz również używać w przypadku plików skompresowanych poleceniem bzip2, z tym że zamiast polecenia gunzip powinieneś użyć polecenia bunzip2). Przykład przedstawiony poniżej ilustruje sposób rozpakowania narzędzia GNU make, które zostało pobrane z sieci Internet (ftp.gnu.org/pub/gnu/make/make-3.82.tar.gz):

2

Oryginalne polecenie tar w systemie UNIX nie używa znaków myślnika do oznaczenia opcji, jednak wersja GNU/Linux polecenia tar działa równie dobrze z myślnikami jak i bez. Dla zapewnienia spójności ze składnią innych poleceń omawianych w tej książce, będziemy konsekwentnie poprzedzać wszystkie opcje polecenia tar znakami myślnika — przyp. autora.

106  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX $ ls -l mak* -rw-r--r--. 1 helion pubs 1712747 04-05 10:43 make-3.82.tar.gz $ gunzip mak* $ ls -l mak* -rw-r--r--. 1 helion pubs 6338560 04-05 10:43 make-3.82.tar $ tar -xvf mak* make-3.82/ make-3.82/vmsfunctions.c make-3.82/getopt.h make-3.82/make.1 ... make-3.82/README.OS2 make-3.82/remote-cstms.c

Pierwsze polecenie wyświetla informacje o pobranym z sieci pliku make-3.82.tar.gz (archiwum .tar skompresowane poleceniem gzip), o rozmiarze ok. 1,7 megabajta. Znak gwiazdki (*) w nazwie pliku zastępuje dowolny ciąg znaków, zatem polecenie ls wyświetla wszystkie pliki, których nazwy rozpoczynają się od ciągu znaków mak; w naszym przypadku takie kryterium spełnia tylko jeden plik. Użycie symbolu wieloznacznego (gwiazdka) oszczędza konieczności wpisywania znaków z klawiatury i może poprawić dokładność zwracanych wyników w przypadku dużej ilości plików o długich nazwach. Polecenie gunzip dekompresuje plik i tworzy nowy plik make-3.82.tar (już bez rozszerzenia .gz), o rozmiarze ok. 6,3 megabajta. Polecenie tar tworzy katalog o nazwie make-3.82 w bieżącym katalogu roboczym i wypakowuje do niego wszystkie pliki z archiwum .tar. $ ls -ld mak* drwxr-xr-x. 8 helion -rw-r--r--. 1 helion $ ls -l make-3.82 razem 2020 -rw-r--r--. 1 helion -rw-r--r--. 1 helion -rw-r--r--. 1 helion -rw-r--r--. 1 helion ... -rw-r--r--. 1 helion -rw-r--r--. 1 helion drwxr-xr-x. 6 helion

pubs 4096 2010-07-27 make-3.82 pubs 6338560 04-05 10:43 make-3.82.tar pubs 53838 2010-07-27 ABOUT-NLS pubs 4783 2010-07-12 acinclude.m4 pubs 36990 2010-07-27 aclocal.m4 pubs 14231 2002-10-14 alloca.c pubs 18391 2010-07-12 vmsjobs.c pubs 17905 2010-07-19 vpath.c pubs 4096 2010-07-27 w32

Kiedy polecenie tar zakończy wypakowywanie plików z archiwum, w bieżącym katalogu roboczym znajdują się dwa pliki, których nazwy rozpoczynają się od ciągu znaków mak: make-3.82.tar oraz make-3.82. Opcja -d (ang. directory) powoduje, że polecenie ls wyświetla tylko nazwy plików i katalogów, a nie zawartość katalogów, tak jak w normalnym przypadku. Ostatnie polecenie ls wyświetla pliki i katalogi znajdujące się w katalogu make-3.82. Więcej informacji na temat polecenia tar znajdziesz w części VI książki.

OSTRZEŻENIE Polecenie tar: opcja -x może wypakować z archiwum duże ilości plików Niektóre archiwa .tar mogą zawierać duże ilości plików. Aby wyświetlić listę plików znajdujących się w archiwum bez ich wypakowywania, powinieneś uruchomić polecenie tar z opcją -tf, po której następuje nazwa pliku archiwum. W niektórych przypadkach dobrym rozwiązaniem może się okazać utworzenie nowego katalogu (patrz sekcja „Polecenie mkdir — tworzenie katalogów” w rozdziale 4.), przeniesienie do niego pliku archiwum i dopiero tam wypakowanie plików z archiwum. Dzięki takiemu rozwiązaniu wypakowane pliki nie będą się mieszały z plikami istniejącymi wcześniej, a dodatkowo w takiej sytuacji ewentualne usunięcie wypakowanych plików będzie dużo łatwiejsze. W zależności od sposobu utworzenia niektóre archiwa przy wypakowywaniu automatycznie tworzą nowy katalog, gdzie jest umieszczana ich zawartość. Opcja -t pozwala na zdefiniowanie miejsca, w którym polecenie tar umieści wypakowywane pliki.

Lokalizowanie poleceń  107

OSTRZEŻENIE Polecenie tar: opcja -x może nadpisywać pliki Użycie w poleceniu tar opcji -x spowoduje nadpisanie wszystkich istniejących plików, które mają takie same nazwy jak pliki wypakowywane z archiwum. Aby uniknąć takiej sytuacji, powinieneś postępować zgodnie z sugestiami zawartymi w poprzednim ostrzeżeniu.

INFORMACJE DODATKOWE Wywołania poleceń gunzip oraz tar możesz połączyć w jednym wierszu poprzez zastosowanie symbolu potoku (|), który spowoduje przekierowanie strumienia danych z wyjścia polecenia gunzip na standardowe wejście polecenia tar: $ gunzip -c make-3.82.tar.gz | tar -xvf -

Opcja -c powoduje, że polecenie gunzip zamiast tworzyć plik na dysku, wysyła strumień danych do potoku wyjściowego. Znak minus (-) znajdujący się na końcu wiersza poleceń powoduje, że polecenie tar pobiera dane ze standardowego wejścia. Więcej informacji na ten temat znajdziesz w sekcji „Potoki danych” w rozdziale 5., w sekcji „Polecenie gzip — kompresowanie plików” we wcześniejszej części bieżącego rozdziału oraz w części VI książki. Jeszcze łatwiejszym rozwiązaniem jest użycie opcji -z polecenia tar. Użycie tej opcji powoduje, że polecenie tar automatycznie wywołuje polecenie gunzip (lub polecenie gzip, jeżeli tworzysz archiwum), co pozwala na zredukowanie wiersza wywołania polecenia do następującej postaci: $ tar -xvzf make-3.82.tar.gz

W podobny sposób użycie opcji -j pozwala na wywołanie polecenia bzip2 lub bunzip2.

LOKALIZOWANIE POLECEŃ Polecenia whereis oraz locate pozwalają na odszukiwanie poleceń, których nazwy zapomniałeś, lub jeśli nie pamiętasz, w którym katalogu dane polecenie się znajduje. Jeżeli w systemie znajduje się kilka kopii tego samego polecenia czy narzędzia, to polecenie which pomoże Ci się zorientować, która kopia zostanie wywołana. Polecenie locate umożliwia z kolei wyszukiwanie plików w lokalnym systemie.

POLECENIA WHICH I WHEREIS — WYSZUKIWANIE NARZĘDZI Kiedy wydajesz jakieś polecenie systemu Linux, powłoka przegląda listę katalogów w poszukiwaniu programu o danej nazwie. Taka lista katalogów jest nazywana ścieżką wyszukiwania (ang. search path). Więcej informacji na temat wprowadzania zmian do ścieżki wyszukiwania znajdziesz w sekcji „Zmienna PATH, czyli gdzie powłoka szuka programów” w rozdziale 8. Jeżeli nie zmienisz standardowej ścieżki wyszukiwania, to powłoka będzie przeszukiwała tylko domyślny zestaw katalogów. Oczywiście nie zmienia to w niczym faktu, że użyteczne narzędzia mogą się znajdować również w innych katalogach. Polecenie which szuka narzędzia w ścieżce wyszukiwania i po odnalezieniu go wyświetla jego pełną ścieżkę (w rozdziale 4. znajdziesz więcej informacji na temat ścieżek i struktury linuksowego systemu plików). Na dysku może znajdować się kilka narzędzi o tej samej nazwie. Kiedy wpisujesz nazwę danego narzędzia czy polecenia, powłoka przegląda ścieżkę wyszukiwania i uruchamia pierwszą odnalezioną kopię narzędzia (lub polecenia). Aby przekonać się, która kopia zostanie uruchomiona, możesz skorzystać z polecenia which. W przykładzie przedstawionym poniżej which zostało użyte do zlokalizowania polecenia tar:

Polecenie which

$ which tar /bin/tar

108  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX Polecenie which może być bardzo przydatne zwłaszcza wtedy, kiedy dane polecenie zaczyna się zachowywać w dziwny, nieoczekiwany sposób. Korzystając w takiej sytuacji z polecenia which, możesz zorientować się, czy używasz niestandardowej wersji tego polecenia lub wersji znajdującej się w zupełnie innym miejscu, niż oczekiwałeś (w sekcji „Ważne pliki i katalogi domyślne” w rozdziale 4. znajdziesz listę standardowych katalogów, w których domyślnie przechowywane są pliki wykonywalne). Na przykład: jeżeli z jakiegoś powodu polecenie tar nie działa poprawnie i okaże się, że zamiast wersji z katalogu /bin/tar używasz kopii z katalogu /usr/local/bin/tar, to możesz podejrzewać, że wersja lokalna została w jakiś sposób uszkodzona. Polecenie whereis poszukuje plików związanych z danym narzędziem, przeglądając zamiast ścieżki wyszukiwania listę katalogów domyślnych. Na przykład polecenie przedstawione poniżej wyszukuje pliki związane z poleceniem tar:

Polecenie whereis

$ whereis tar tar: /bin/tar /usr/share/man/man1/tar.1.gz

W tym przykładzie polecenie whereis odnalazło dwa pliki powiązane z poleceniem tar: pierwszy z nich to sam plik wykonywalny polecenia tar, a drugi to strona podręcznika man polecenia tar.

WSKAZÓWKA Polecenie which kontra whereis Polecenie which, którego argumentem wywołania jest nazwa poszukiwanego narzędzia, przeszukuje listę katalogów zawartych w ścieżce wyszukiwania w kolejności ich występowania i wyświetla nazwę katalogu, w którym takie narzędzie zostanie odnalezione. Jeżeli kopia danego narzędzia znajduje się w więcej niż jednym katalogu, to polecenie which wyświetla nazwę pierwszego katalogu, w którym poszukiwane narzędzie zostanie odnalezione. Polecenie whereis sprawdza listę standardowych katalogów, w których zazwyczaj przechowywane są pliki wykonywalne, i działa zupełnie niezależnie od ścieżki wyszukiwania. Polecenia whereis możesz używać do lokalizowania plików wykonywalnych, powiązanych z nimi plików podręcznika oraz plików kodu źródłowego — polecenie whereis wyświetla ścieżki i nazwy wszystkich plików pasujących do podanego wzorca wyszukiwania.

OSTRZEŻENIE Polecenia which i whereis a wbudowane polecenia powłoki Zarówno polecenie which, jak i whereis wyświetlają tylko nazwy takich poleceń, których pliki wykonywalne mogą być odnalezione na dysku i nie raportują żadnych wbudowanych poleceń powłoki (więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Wbudowane polecenia powłoki” w rozdziale 5.). Kiedy spróbujesz użyć polecenia whereis do odszukania lokalizacji polecenia echo (które jest zarówno wbudowanym poleceniem powłoki, jak i programem narzędziowym przechowywanym na dysku), to wyniki działania będą następujące: $ whereis echo echo: /bin/echo /usr/share/man/man1/echo.1.gz

Polecenie whereis nie wyświetla żadnych informacji o wbudowanym poleceniu echo. Polecenie which również zwraca nieprawidłowe informacje na jego temat: $ which echo /bin/echo

Jeżeli pracujesz z powłoką bash, możesz użyć polecenia type do sprawdzenia, czy dane polecenie jest poleceniem wbudowanym (wewnętrznym), czy zewnętrznym: $ type echo echo jest wewnętrznym poleceniem powłoki

Wyświetlanie informacji o systemie i użytkownikach  109

POLECENIE LOCATE — WYSZUKIWANIE PLIKÓW Polecenie locate umożliwia wyszukiwanie plików w systemie lokalnym: $ locate init /boot/initramfs-2.6.38-0.rc5.git1.1.fc15.i686.img /boot/initrd-plymouth.img /etc/gdbinit /etc/gdbinit.d /etc/init /etc/init.d ...

Zanim będziesz mógł użyć polecenia locate lub mlocate, baza danych polecenia musi zostać zbudowana lub zaktualizowana poleceniem updatedb. W typowym przypadku baza danych jest aktualizowana raz dziennie przez odpowiedni skrypt cron (więcej szczegółowych informacji na ten temat znajdziesz w części VI książki).

WYŚWIETLANIE INFORMACJI O SYSTEMIE I UŻYTKOWNIKACH W tej sekcji omawiamy narzędzia, które dostarczają informacji o tym, kto korzysta z naszego systemu, co tacy użytkownicy robią i jak działa sam system. Aby dowiedzieć się, kto korzysta z systemu lokalnego, możesz użyć jednego z kilku dostępnych poleceń, które różnią się od siebie ilością wyświetlanych informacji oraz listą obsługiwanych opcji. Najstarsze spośród tych poleceń, who, wyświetla listę użytkowników zalogowanych w systemie lokalnym, nazwę urządzeń, z których korzystają poszczególni użytkownicy, oraz datę i czas zalogowania użytkownika do systemu. Polecenia w oraz finger wyświetlają więcej szczegółowych informacji, takich jak pełna nazwa użytkownika i nazwa polecenia, które każdy z użytkowników ostatnio uruchomił z wiersza poleceń konsoli. Polecenie finger potrafi również pobierać informacje o użytkownikach z innych systemów. W tabeli 3.1 w dalszej części tego rozdziału przedstawiono zestawienie informacji wyświetlanych przez te trzy narzędzia.

POLECENIE WHO — WYŚWIETLANIE LISTY ZALOGOWANYCH UŻYTKOWNIKÓW Polecenie who wyświetla listę użytkowników, którzy są zalogowani w systemie lokalnym. Na rysunku 3.10 pierwsza kolumna wyników działania tego polecenia informuje, że w tej chwili w systemie zalogowani są użytkownicy kuba, dawid i mati (kuba jest zalogowany z dwóch lokalizacji). W drugiej kolumnie wyświetlana jest nazwa urządzenia, do którego podłączony jest terminal, stacja robocza czy emulator terminala każdego z tych użytkowników. W trzeciej kolumnie wyświetlana jest data i czas zalogowania się danego użytkownika do systemu. Opcjonalna kolumna czwarta wyświetla (w nawiasach) nazwę systemu, z którego loguje się użytkownik zdalny. $ who dawid kuba mati kuba

tty4 tty2 tty1 pts/4

2011-07-25 2011-07-25 2011-07-25 2011-07-25

17:18 16:42 16:39 17:27 (kiwi)

Rysunek 3.10. Polecenie who wyświetla listę zalogowanych użytkowników

Informacje wyświetlane przez polecenie who są bardzo przydatne na przykład w sytuacji, kiedy chcesz się skontaktować z danym użytkownikiem systemu lokalnego. Jeżeli dany użytkownik jest zalogowany, możesz użyć polecenia write (patrz nieco dalej w rozdziale) do natychmiastowego zainicjowania komunikacji. Jeżeli polecenie who nie wyświetla nazwy takiego użytkownika lub nie musisz się z nim kontaktować natychmiast, możesz po prostu wysłać do niego wiadomość za pośrednictwem poczty elektronicznej (patrz nieco dalej w rozdziale).

110  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX Jeżeli wyniki działania polecenia who przekraczają rozmiary jednego ekranu, możesz za pośrednictwem symbolu potoku (|) przekierować strumień danych z wyjścia tego polecenia na wejście polecenia less, które wyświetla informacje po jednym ekranie. Wyjście polecenia who możesz również przekierować na wejście polecenia grep, dzięki czemu będziesz mógł wyszukiwać konkretnych użytkowników po nazwie. Jeżeli chcesz się dowiedzieć, którego terminala używa Twoja sesja, czy o której godzinie się zalogowałeś, możesz użyć polecenia who am i: $ who am i kuba pts/4

2011-07-25 17:27 (kiwi)

POLECENIE FINGER — WYŚWIETLANIE LISTY UŻYTKOWNIKÓW DANEGO SYSTEMU Polecenie finger wyświetla listę użytkowników zalogowanych w danym systemie lokalnym, a w niektórych przypadkach może również pobierać i wyświetlać informacje o systemach i użytkownikach zdalnych. Oprócz nazwy konta użytkownika polecenie finger wyświetla pełną nazwę użytkownika, nazwę urządzenia, do którego podłączony jest terminal użytkownika, czas, jaki upłynął od chwili naciśnięcia przez użytkownika ostatniego klawisza na klawiaturze, datę i czas zalogowania do systemu oraz informacje kontaktowe (o ile są dostępne). Jeżeli dany użytkownik jest zalogowany poprzez połączenie sieciowe, nazwa zdalnego systemu pojawia się w kolumnie Office. Na przykład na rysunku 3.11 możemy zobaczyć, że użytkownik kuba zalogował się poprzez sieć, korzystając ze zdalnego systemu o nazwie kiwi. Znak gwiazdki (*) przed nazwą urządzenia w kolumnie Tty oznacza, że użytkownik zablokował możliwość odbierania wiadomości przesyłanych bezpośrednio na jego terminal (patrz sekcja „Polecenie mesg — blokowanie lub przyjmowanie wiadomości” w dalszej części rozdziału). $ finger Login kuba kuba dawid mati

Name Kuba-Redakcja Kuba-Redakcja Dawid-Skład Mateusz-Druk

Tty *tty2 pts/4 *tty4 *tty1

Idle 3 29 1:07

Login Time Jul 25 16:42 Jul 25 17:27 Jul 25 17:18 Jul 25 16:39

Office ... (kiwi)

Rysunek 3.11. Polecenie finger, wersja I — wyświetlanie listy zalogowanych użytkowników

BEZPIECZEŃSTWO Polecenie finger może narażać system na ryzyko zagrożenia bezpieczeństwa W przypadku systemów, w których bezpieczeństwo systemu jest traktowane poważnie, administrator systemu może zablokować możliwość korzystania z polecenia finger, ponieważ może ono ujawniać informacje, które potencjalny „czarny charakter” może wykorzystać podczas próby włamania do systemu. W systemie OS X zdalne wykonywanie polecenia finger jest domyślnie zablokowane. Polecenia finger możesz używać do wyświetlania bardziej szczegółowych informacji o wybranym użytkowniku. Aby to zrobić, po nazwie polecenia powinieneś wpisać nazwę interesującego Cię użytkownika. Na rysunku 3.12 przedstawiono przykład zastosowania polecenia finger do wyświetlenia informacji na temat użytkownika kuba. Jak widać na wynikach działania polecenia, użytkownik ten jest zalogowany do systemu, aktywnie korzysta z jednego ze swoich terminali (tty2) i nie używał terminala pts/4 od 3 minut i 7 sekund. Z wyników działania polecenia dowiesz się również, że jeżeli chcesz spotkać się z użytkownikiem kuba, powinieneś najpierw skontaktować się z użytkownikiem o nazwie anna, pod wewnętrznym numerem telefonu 1693.

Wyświetlanie informacji o systemie i użytkownikach  111

$ finger kuba Login: kuba Name: Kuba-Redakcja Directory: /home/kuba Shell: /bin/bash On since pią cze 25 16:42 (CET) on tty2 (messages off) On since pią cze 25 17:27 (CET) on pts/4 from kiwi 3 minutes 7 seconds idle New mail received pią cze 25 17:16 2010 (CET) Unread since pią cze 25 16:44 2010 (CET) Plan: W przyszłym tygodniu wyjeżdżam na konferencję na Hawaje. Jeżeli chcesz się ze mną skontaktować, zadzwoń do Anny, tel. wewn. 1693.

Rysunek 3.12. Polecenie finger, wersja II — wyświetlanie szczegółowych informacji o danym użytkowniku

Większość danych przedstawionych na rysunku 3.12 została zebrana przez polecenie z plików systemowych, jednak informacje wyświetlane po nagłówku Plan: zostały przygotowane przez użytkownika kuba. Polecenie finger odszukało w katalogu domowym użytkownika kuba plik o nazwie .plan i po prostu wyświetliło jego zawartość (pamiętaj, że pliki, których nazwy rozpoczynają się od kropki, takie jak na przykład .plan, domyślnie nie są wyświetlane przez polecenie ls, stąd mówimy, że są to pliki ukryte — patrz sekcja „Ukryte nazwy plików” w rozdziale 4.).

Pliki .plan i .project finger

Plik o nazwie .plan możesz utworzyć samodzielnie i umieścić w nim dowolne informacje, takie jak na przykład Twój rozkład zajęć na następny tydzień, zainteresowania, numer telefonu czy adres. W podobny sposób polecenie finger wyświetla zawartość plików .project i .pgpkey, które również znajdują się w Twoim katalogu domowym. Jeżeli użytkownik kuba nie byłby zalogowany, to polecenie finger wyświetliłoby tylko informacje o użytkowniku, datę i czas ostatniego logowania, datę i czas ostatniego odczytania wiadomości poczty elektronicznej oraz plan. Polecenia finger możesz używać do wyświetlania nazwy konta użytkownika. Na przykład: jeżeli z danego systemu korzysta Twoja znajoma, Helena Nowakowska, to pewnie wiesz, że nazwisko Heleny to Nowakowska, ale niekoniecznie musisz wiedzieć, że nazwa jej konta użytkownika to hln. Za pomocą polecenia finger (które nie zwraca uwagi na pisownię małych i wielkich liter) możesz poszukać informacji o Helenie, używając jej imienia bądź nazwiska. Polecenia przedstawione poniżej wyświetlają informacje zarówno o poszukiwanej przez Ciebie osobie, jak i innych osobach, które mają na imię Helena lub noszą nazwisko Nowakowska: $ finger HELENA Login: hln Name: Helena Nowakowska. ... $ finger nowakowska Login: hln Name: Helena Nowakowska. ...

POLECENIE UPTIME — WYŚWIETLANIE INFORMACJI O SYSTEMIE I JEGO OBCIĄŻENIU Polecenie uptime wyświetla dane wyjściowe w postaci pojedynczego wiersza zawierającego następujące informacje: bieżący czas, ilość czasu, jaka upłynęła od ostatniego uruchomienia systemu (wyrażoną w dniach, godzinach i minutach), liczbę zalogowanych użytkowników oraz średnie obciążenie systemu (czyli informację o tym, jak bardzo system jest zajęty realizacją zadań) — poszczególne wartości reprezentują średnią liczbę zadań oczekujących na uruchomienie, liczoną w ostatniej minucie, ostatnich 5 minutach i wreszcie w ostatnich 15 minutach.. $ uptime 09:49:14 up 2 days, 23:13,

3 users,

load average: 0.00, 0.01, 0.05

112  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX

POLECENIE W — WYŚWIETLANIE LISTY ZALOGOWANYCH UŻYTKOWNIKÓW Polecenie w wyświetla listę użytkowników, którzy w danej chwili są zalogowani w systemie, a ponadto wyświetla takie same dane wyjściowe jak przedstawione powyżej polecenie uptime. Jak już wspominaliśmy przy okazji omawiania polecenia who, informacje dostarczane przez polecenie w mogą być użyteczne na przykład w sytuacji, kiedy chcesz się skontaktować z jednym z użytkowników Twojego systemu. Pierwsza kolumna wyników działania polecenia w, przedstawionych na rysunku 3.13, pokazuje, że w systemie zalogowani są użytkownicy kuba, dawid i mati. W drugiej kolumnie wyświetlane są nazwy urządzeń, do których podłączone są terminale poszczególnych użytkowników. W trzeciej kolumnie wyświetlana jest nazwa systemu zdalnego, z którego loguje się dany użytkownik. W kolumnie czwartej wyświetlana jest data i czas zalogowania użytkownika do systemu. W piątej kolumnie wyświetlany jest czas bezczynności użytkownika (czyli inaczej mówiąc, czas, jaki upłynął od ostatniego naciśnięcia przez użytkownika klawisza na klawiaturze). Kolejne dwie kolumny pokazują ilość czasu procesora zużytego przez użytkownika podczas tej sesji logowania oraz podczas wykonywania ostatniego zadania. W ostatniej kolumnie wyświetlane jest polecenie wykonywane w tej chwili przez użytkownika. W tabeli 3.1 przedstawiono porównanie informacji wyświetlanych przez polecenia w, who oraz finger. $ w 17:47:35 up 1 day, 8:10, 6 users, load average: 0.34, USER TTY FROM LOGIN@ IDLE JCPU PCPU dawid tty4 17:18 29:14m 0.20s 0.00s kuba tty2 16:42 0.00s 0.20s 0.07s mati tty1 16:39 1:07 0.05s 0.00s kuba pts/4 kiwi 17:27 3:10m 0.24s 0.24s

0.23, 0.26 WHAT vi memo w run_bdgt -bash

Rysunek 3.13. Wyniki działania polecenia w Tabela 3.1. Porównanie informacji wyświetlanych przez polecenia w, who oraz finger Wyświetlana informacja

w

who

finger

Nazwa konta użytkownika

X

X

X

Identyfikacja terminala (tty)

X

X

X

Czas ostatniego logowania (i dzień w przypadku długich sesji)

X X

X

Data i czas ostatniego logowania Czas bezczynności

X

Nazwa programu uruchamianego przez użytkownika

X

Lokalizacja miejsca, z którego loguje się użytkownik Zużyty czas procesora (CPU)

X X

X

Pełna nazwa użytkownika (lub inne informacje z pliku /etc/passwd)

X

Dodatkowe informacje dostarczane przez użytkownika

X

Czas pracy i średnie obciążenie systemu

X

POLECENIE FREE — WYŚWIETLANIE INFORMACJI O WYKORZYSTANIU PAMIĘCI Polecenie free pozwala na wyświetlenie informacji o ilości wolnej w systemie lokalnym pamięci fizycznej (RAM) i przestrzeni wymiany. Dane wyjściowe zawierają kolumny informujące o całkowitej, użytej i wolnej pamięci, a także informacje o buforach jądra. Kolumna zatytułowana shared jest zbędna. W systemie OS X to narzędzie jest niedostępne, ale podobną rolę pełni tutaj vm_stat.

Komunikacja z innymi użytkownikami  113

W przedstawionym poniżej przykładzie opcja -m powoduje, że polecenie free wyświetla wielkości wyrażone w megabajtach. Natomiast użycie opcji -t spowodowało dodanie kolumny total do danych wyjściowych. Inne przydatne opcje to: -g (wyświetlenie wielkości w gigabajtach), -k (wyświetlanie wielkości w kilobajtach, to jest opcja domyślna) i -b (wyświetlanie wartości w bajtach). Więcej informacji na temat polecenia free możesz znaleźć w podręczniku man. $ free -mt

total Mem: 2013 -/+ buffers/cache: Swap: 2044 Total: 4058

used 748 254 0 748

free 1264 1759 2044 3309

shared 0

buffers 110

cached 383

System Linux ma użyteczną cechę dotyczącą zarządzania pamięcią — nieużywana pamięć jest wykorzystywana jako bufor (patrz słowniczek) lub bufor podręczny (patrz słowniczek). Dlatego też wartość Mem w kolumnie total będzie mała i nie wskazuje całej wolnej pamięci dostępnej dla prawidłowo działającego jądra. Kiedy jądro będzie potrzebowało większej ilości pamięci, wykorzysta tę, która wcześniej została zaalokowana jako bufor. Wiersz -/+ buffers/cache informuje o ilości o pamięci przy założeniu, że pamięć zaalokowana dla buforów jest uznawana za wolną. Wartość w kolumnie used dla wymienionego wiersza wskazuje ilość pamięci, która może zostać zwolniona. W omawianym przykładzie 110 + 383 daje 493, a więc wartość w kolumnie used wynosi 254 (748 - 493). Z kolei wartość w kolumnie free wynosi 1759 (1264 + 493). Jeżeli w przeciwieństwie do wartości kolumny free w wierszu Mem wartość w kolumnie free dla wiersza -/+ buffers/cache będzie wynosiła 0, oznacza to rzeczywisty brak pamięci w systemie. Wiersz Swap wyświetla informacje o całkowitej, użytej i wolnej ilości przestrzeni wymiany.

KOMUNIKACJA Z INNYMI UŻYTKOWNIKAMI Narzędzia omawiane w tej sekcji pozwalają na wymianę wiadomości i plików z innymi użytkownikami zarówno interaktywnie, jak i za pośrednictwem poczty elektronicznej.

POLECENIE WRITE — WYSYŁANIE WIADOMOŚCI Polecenie write pozwala na wysyłanie wiadomości do innych, zalogowanych użytkowników. Kiedy Ty i inny użytkownik używacie polecenia write do wysyłania sobie nawzajem wiadomości, tworzona jest swego rodzaju komunikacja dwukierunkowa. Początkowo polecenie write (patrz rysunek 3.14) wyświetlało na terminalu adresata baner tekstowy, informujący, że zaraz otrzyma od Ciebie wiadomość. $ write kuba Cześć Kuba! Jesteś tam? o

Rysunek 3.14. Polecenie write — wersja I

Składnia polecenia write jest prosta: write nazwa_użytkownika [terminal]

Parametr nazwa_użytkownika to nazwa konta użytkownika, z którym chcesz porozmawiać, a terminal to opcjonalna nazwa urządzenia, która może być bardzo użyteczna w sytuacji, kiedy użytkownik jest zalogowany w więcej niż jednej sesji. Nazwy kont zalogowanych użytkowników oraz nazwy urządzeń, z których korzystają, możesz wyświetlić na ekranie przy użyciu polecenia w, who lub finger. Aby nawiązań dwukierunkowe połączenie z innym użytkownikiem, obaj użytkownicy muszą użyć polecenia write i jako parametr nazwa_użytkownika wpisać nazwę konta swojego rozmówcy. Po nawiązaniu połączenia polecenie write kopiuje kolejne wiersze tekstu wpisywane przez danego użytkownika i wyświetla je na ekranie jego rozmówcy (patrz rysunek 3.15). Czasami w takiej komunikacji

114  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX pomaga wcześniejsze ustalenie pewnych konwencji zapisu, takich jak na przykład kończenie każdej wiadomości wpisaniem litery o (ang. over; odbiór) czy kończenie całej rozmowy wpisaniem oo (ang. over and out; bez odbioru, koniec rozmowy). Kiedy chcesz zakończyć sesję rozmowy z innym użytkownikiem, powinieneś na początku nowego wiersza nacisnąć kombinację klawiszy Ctrl+D. Naciśnięcie tej kombinacji klawiszy kończy pracę polecenia write, wyświetla znacznik EOF (koniec pliku) na terminalu rozmówcy i przekazuje sterowanie do powłoki. Twój rozmówca musi zrobić to samo, aby zamknąć swoją sesję polecenia write. $ write kuba Cześć Kuba! Jesteś tam? o Komunikat od kuba@kiwi na pts/4 o 16:23 ... Cześć Dawid! Tak, jestem. o

Rysunek 3.15. Polecenie write — wersja II

Jeżeli na Twoim ekranie pojawi się baner Komunikat od i zakryje część ekranu, gdzie aktualnie pracujesz, naciśnij kombinację klawiszy Ctrl+L lub Ctrl+R, aby odświeżyć ekran i usunąć baner. Następnie możesz spokojnie zakończyć to, co robiłeś, i odpowiedzieć osobie, która do Ciebie napisała. W takiej sytuacji musisz jednak pamiętać, kto to Ciebie „zagadał”, ponieważ po usunięciu baner nie pojawi się ponownie na ekranie.

POLECENIE MESG — BLOKOWANIE LUB PRZYJMOWANIE WIADOMOŚCI Domyślnie wszystkie wiadomości wysyłane na Twój ekran są blokowane. Jeżeli chcesz, aby inni użytkownicy mogli wysyłać do Ciebie wiadomości, powinieneś wykonać polecenie przedstawione poniżej: $ mesg y

Jeżeli kuba nie wykonał takiego polecenia, zanim dawid próbował wysłać do niego wiadomość, to na ekranie użytkownika dawid może się pojawić następujący komunikat: $ write kuba write: kuba ma zablokowane wiadomości

W razie potrzeby możesz zablokować odbieranie wiadomości, wykonując polecenie mesg n. Wywołanie tego polecenia bez żadnych argumentów wyświetla status odbierania wiadomości. Jeżeli odbieranie wiadomości jest odblokowane, polecenie mesg wyświetli komunikat is y (to bardzo lakoniczna wersja komunikatu tak, odbieranie wiadomości jest dozwolone — ang. yes, messages are allowed), w przeciwnym wypadku na ekranie pojawi się komunikat is n (to równie rozbudowana wersja komunikatu nie, odbieranie wiadomości nie jest dozwolone — ang. no, messages are not allowed). Jeżeli wyłączysz odbieranie wiadomości i później będziesz chciał wysłać wiadomość do innego użytkownika, polecenie write wyświetli na ekranie komunikat przedstawiony poniżej, ponieważ nawet jeżeli będziesz mógł wysłać taką wiadomość do użytkownika, to on nie będzie w stanie odpisać do Ciebie: $ write kuba write: prawo zapisu jest wyłączone.

POCZTA ELEKTRONICZNA Poczta elektroniczna pozwala na komunikowanie się z innymi użytkownikami systemu lokalnego, jak i użytkownikami pracującymi w innych systemach w sieci. Jeżeli Twój komputer jest podłączony do sieci Internet, to za pomocą poczty elektronicznej możesz się komunikować z użytkownikami na całym świecie. Narzędzia do obsługi poczty elektronicznej różnią się od polecenia write na przykład tym, że pozwalają na wysyłanie wiadomości do użytkowników, którzy nie są w danej chwili zalogowani do systemu. W takiej sytuacji wysłana wiadomość jest po prostu przechowywana na serwerze poczty elektronicznej aż do momentu, kiedy jej adresat się nie pojawi w systemie i nie odbierze oczekującej wiadomości. Narzędzia pocztowe pozwalają również na przesyłanie tej samej wiadomości do wielu użytkowników jednocześnie.

Podsumowanie rozdziału  115

Dla systemu Linux istnieje wiele programów do obsługi poczty elektronicznej, takich jak na przykład pracujący w trybie tekstowym program mail, klient Mozilla/Thunderbird, pine, wysyłanie wiadomości pocztowych poprzez edytor emacs, Kmail czy evolution. Innym popularnym, graficznym klientem poczty elektronicznej jest program sylpheed (patrz http://sylpheed.sraoss.jp/en/). Istnieją również dwa programy, które ułatwiają korzystanie z dowolnego klienta poczty elektronicznej oraz znacząco przyczyniają się do zwiększenia bezpieczeństwa przesyłanych informacji. Pierwszy z nich, o nazwie procmail (patrz http://www.procmail.org/), pozwala na tworzenie i zarządzanie serwerami poczty elektronicznej i listami dyskusyjnymi, dokonuje wstępnego przetwarzania wiadomości poczty elektronicznej i sortuje je do odpowiednich plików i katalogów, w zależności od rodzaju nadchodzącej wiadomości może uruchamiać różne programy, automatycznie przesyłać pocztę na inne konta lub do innych użytkowników i tak dalej. Drugi program, gpg (ang. GNU Privacy Guard; w skrócie GPG lub GNUpg), pozwala na silne szyfrowanie i odszyfrowywanie przesyłanych wiadomości, dzięki czemu odczytanie przesyłanej wiadomości przez osoby trzecie bez znajomości hasła jest praktycznie niemożliwe. Jeżeli Twój system lokalny jest częścią sieci LAN, zazwyczaj będziesz mógł wysyłać i odbierać wiadomości poczty elektronicznej od użytkowników innych systemów w tej sieci, posługując się odpowiednimi nazwami kont użytkowników. Użytkownik, który chciałby wysłać wiadomość poczty elektronicznej do użytkownika kuba, zazwyczaj będzie musiał w adresie dodać nazwę domeny danego użytkownika. Na przykład: jeżeli chciałbyś wysłać wiadomość do autora niniejszej książki, powinieneś napisać na adres: [email protected].

Adresy sieciowe

PODSUMOWANIE ROZDZIAŁU Polecenia i narzędzia omawiane w tym rozdziale są małym, ale posiadającym potężne możliwości podzbiorem pakietu narzędzi, w jaki wyposażone są systemy Linux. Ze względu na fakt, że będziesz z tych narzędzi często korzystał podczas pracy z kolejnymi rozdziałami, powinieneś dobrze je poznać i zrozumieć sposób ich działania. W tabeli 3.2 zamieszczamy zestawienie poleceń, które pozwalają na manipulowanie plikami, wyświetlanie ich, porównywanie i drukowanie. Tabela 3.2. Narzędzia do pracy z plikami Nazwa narzędzia

Przeznaczenie

cp

Kopiuje jeden lub więcej plików.

diff

Wyświetla różnice między dwoma plikami.

file

Wyświetla informacje na temat zawartości pliku.

grep

Wyszukuje ciąg znaków w pliku.

head

Wyświetla pierwsze wiersze zawartości pliku.

lpq

Wyświetla listę zadań oczekujących w kolejce drukarki.

lpr

Umieszcza plik(i) w kolejce drukarki.

lprm

Usuwa zadanie z kolejki drukarki.

mv

Zmienia nazwę pliku lub przenosi plik do innego katalogu.

sort

Wyświetla zawartość pliku posortowaną w określonej kolejności (wiersz po wierszu).

tail

Wyświetla ostatnie wiersze zawartości pliku.

uniq

Wyświetla zawartość pliku, pomijając sąsiadujące, powtarzające się wiersze (duplikaty).

116  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX Aby zredukować ilość miejsca zajmowanego przez pliki, możesz skompresować je przy użyciu polecenia bzip2. Kompresja jest bardzo efektywna zwłaszcza w przypadku plików, które zawierają powtarzające się elementy (na przykład pliki tekstowe), ale z reguły zmniejsza rozmiar niemal wszystkich rodzajów plików. Odwrotność polecenia bzip2 — polecenie bunzip2 — pozwala na przywrócenie oryginalnej, nieskompresowanej formy pliku. W tabeli 3.3 zamieszczamy zestawienie narzędzi, które pozwalają na kompresowanie i dekompresowanie plików. Polecenie bzip2 jest najbardziej efektywnym narzędziem spośród wszystkich wymienionych poniżej. Tabela 3.3. Narzędzia do (de)kompresji plików Nazwa narzędzia

Przeznaczenie

bunzip2

Przywraca plik skompresowany poleceniem bzip2 do oryginalnego rozmiaru i formatu.

bzcat

Wyświetla zawartość pliku skompresowanego poleceniem bzip2.

bzip2

Kompresuje zawartość pliku.

compress

Kompresuje zawartość pliku (ale nie tak dobrze jak polecenia bzip2 czy gzip).

gunzip

Przywraca plik skompresowany poleceniem gzip lub compress do oryginalnego rozmiaru i formatu.

gzip

Kompresuje zawartość pliku (ale nie tak dobrze jak polecenie bzip2).

unzip

Wypakowuje archiwa .zip, które są kompatybilne z archiwami systemu Windows utworzonymi przy użyciu polecenia PKZIP.

zcat

Wyświetla zawartość pliku skompresowanego poleceniem gzip.

zip

Tworzy archiwa .zip, które są kompatybilne z archiwami systemu Windows utworzonymi przy użyciu polecenia PKZIP.

Archiwum to plik, często skompresowany, w którym przechowywana jest grupa innych plików. Polecenie tar (patrz tabela 3.4) pozwala na tworzenie i wypakowywanie archiwów. Rozszerzenia .tar.bz2, .tar.gz i .tgz pozwalają na łatwe zidentyfikowanie skompresowanych archiwów tar i są często używane do przesyłania pakietów oprogramowania w sieci Internet. Tabela 3.4. Narzędzia do archiwizacji plików Nazwa narzędzia

Przeznaczenie

tar

Tworzy lub wypakowuje pliki archiwum.

Narzędzia wymienione w tabeli 3.5 pozwalają na określenie miejsca przechowywania danego narzędzia w lokalnym systemie plików. Na przykład możesz wyświetlić ścieżkę prowadzącą do danego narzędzia czy wyświetlić listę kompilatorów C++ dostępnych w danym systemie. Tabela 3.5. Narzędzia do lokalizacji Nazwa narzędzia

Przeznaczenie

locate/mlocate

Wyszukuje pliki w systemie lokalnym.

whereis

Wyświetla pełne ścieżki do narzędzi, plików kodu źródłowego lub stron podręcznika man.

which

Wyświetla pełną ścieżkę do narzędzia, które możesz uruchomić.

W tabeli 3.6 zamieszczamy zestawienie narzędzi, które wyświetlają szereg informacji o systemie lokalnym i użytkownikach. Korzystając z tych narzędzi, możesz łatwo poznać pełną nazwę użytkownika, status zalogowania, używaną powłokę i inne informacje.

Ćwiczenia  117

Tabela 3.6. Narzędzia wyświetlające informacje o systemie i użytkownikach Nazwa narzędzia

Przeznaczenie

finger

Wyświetla szczegółowe informacje o użytkownikach, łącznie z ich pełnymi nazwami.

free

Wyświetla informacje o wykorzystaniu pamięci w systemie.

hostname

Wyświetla nazwę systemu lokalnego.

uptime

Wyświetla informacje o czasie działania systemu i jego obciążeniu.

w

Wyświetla szczegółowe informacje o użytkownikach zalogowanych w lokalnym systemie.

who

Wyświetla informacje o użytkownikach zalogowanych w lokalnym systemie.

Polecenia zamieszczone w tabeli 3.7 pozwalają na komunikowanie się z innymi użytkownikami w sieci lokalnej. Tabela 3.7. Narzędzia do komunikacji między użytkownikami Nazwa narzędzia

Przeznaczenie

mesg

Zezwala na otrzymywanie lub blokuje otrzymywanie wiadomości wysyłanych poleceniem write.

write

Wysyła wiadomości do innych, zalogowanych użytkowników.

W tabeli 3.8 zamieszczono zestawienie różnych innych poleceń omawianych w tym rozdziale. Tabela 3.8. Narzędzia różne Nazwa narzędzia

Przeznaczenie

date

Wyświetla bieżącą datę i czas.

echo

Wyświetla na ekranie elementy podane w wierszu poleceń jako argument tego polecenia.

ĆWICZENIA 1. Jakich poleceń możesz użyć do sprawdzenia, kto jest zalogowany na określonym terminalu? 2. Jak możesz zapobiegać otrzymywaniu od innych użytkowników wiadomości wysyłanych za pomocą polecenia write? Dlaczego chciałbyś to zrobić? 3. Co się wydarzy, kiedy wykonasz polecenia zamieszczone poniżej, jeżeli plik o nazwie done już istnieje? $ cp to_do done $ mv to_do done

4. W jaki sposób możesz sprawdzić, jakie polecenia przeznaczone do edycji plików są dostępne w Twoim systemie? Wypisz listę takich narzędzi. 5. W jaki sposób możesz znaleźć numer telefonu do firmy ACME-Dostawy w pliku o nazwie telefony, w którym znajdują się nazwy firm i telefony kontaktowe? Jakiego polecenia możesz użyć do wyświetlenia zawartości tego pliku posortowanej w kolejności alfabetycznej? W jaki sposób możesz wyświetlić zawartość tego pliku, ale pozbawioną powtarzających się, sąsiadujących wierszy (duplikatów)? W jaki sposób możesz wyświetlić zawartość tego pliku, ale pozbawioną wszystkich duplikatów?

118  ROZDZIAŁ 3. NARZĘDZIA SYSTEMU LINUX 6. Co się wydarzy, jeżeli użyjesz polecenia diff do porównania zawartości dwóch plików binarnych, które nie są identyczne? (do utworzenia plików binarnych możesz użyć polecenia gzip). Wyjaśnij, dlaczego wyniki działania polecenia diff dla plików binarnych są zupełnie inne niż dla plików tekstowych (ASCII)? 7. Utwórz w swoim katalogu domowym plik .plan. Czy polecenie finger wyświetla zawartość Twojego pliku .plan? 8. Jaki będzie wynik działania polecenia which, jeżeli jako argumentu użyjesz nazwy polecenia zlokalizowanego w katalogu, który nie jest ujęty w ścieżce wyszukiwania? 9. Czy jakieś narzędzia omawiane w tym rozdziale można odnaleźć w więcej niż jednym katalogu? Jeżeli tak, to je wymień. 10. Przy użyciu polecenia file sprawdź wybrane pliki z katalogu /usr/bin. Ile różnych typów plików znalazłeś w tym katalogu? 11. Którego polecenia użyłbyś do wyświetlenia pierwszych kilku wierszy pliku raport? Jakiego polecenia możesz użyć do wyświetlenia kilku ostatnich wierszy tego pliku?

ĆWICZENIA ZAAWANSOWANE 12. Utwórz pliki kolor.1 i kolor.2, których używaliśmy w przykładzie przedstawionym na rysunku 3.8. Przetestuj je, uruchamiając polecenie diff -u. Czy otrzymałeś takie same rezultaty jak na rysunku? 13. Wykonaj dwa poniższe polecenia: $ echo cat $ cat echo

Wyjaśnij różnice między wynikami działania obu poleceń. 14. Powtórz ćwiczenie nr 5 przy użyciu pliku telefony.gz, czyli skompresowanej wersji listy firm i numerów telefonów. Zaproponuj więcej niż jedno podejście do odpowiedzi na każde z pytań i wyjaśnij, jak dokonałeś wyboru. 15. Odszukaj lub utwórz pliki, które: a) Polecenie gzip jest w stanie skompresować z wydajnością ponad 80 procent. b) Polecenie gzip jest w stanie skompresować z wydajnością poniżej 10 procent. c) Rozmiar pliku się zwiększy po skompresowaniu poleceniem gzip. d) Użyj polecenia ls -l do określenia rozmiarów plików w tym ćwiczeniu. Czy możesz scharakteryzować pliki z punktów a, b i c? 16. Starsze programu pocztowe nie potrafiły obsługiwać plików binarnych. Załóżmy, że za pomocą poczty elektronicznej chcesz wysłać plik skompresowany poleceniem gzip, które tworzy pliki binarne, a adresat używa starego programu pocztowego. Zajrzyj na strony podręcznika man polecenia uuencode, które zamienia pliki binarne do postaci plików ASCII. Zapoznaj się ze sposobem działania tego polecenia i spróbuj go użyć. a) Przy użyciu polecenia uuencode dokonaj konwersji skompresowanego pliku do postaci pliku ASCII. Czy otrzymany plik jest większy, czy mniejszy od pliku skompresowanego? Wyjaśnij różnicę (jeżeli polecenie uuencode nie jest dostępne w Twoim systemie, możesz je zainstalować za pomocą jednego z narzędzi omówionych w dodatku C; polecenie uuencode jest częścią pakietu sharutils). b) Czy użycie polecenia uuencode przed dokonaniem kompresji pliku ma sens? Uzasadnij odpowiedź.

4 System plików

W tym rozdziale:

Cele rozdziału

Hierarchiczny system plików

Po przeczytaniu tego rozdziału będziesz wiedział:  Jak zdefiniować hierarchiczny system plików, zwykłe pliki, pliki katalogów, katalog domowy, katalog roboczy i katalog nadrzędny.  Jakie są najlepsze praktyki tworzenia nazw plików.  Jak sprawdzić nazwę bieżącego katalogu roboczego.  Czym się różni bezwzględna ścieżka do pliku od ścieżki względnej.  Jak tworzyć i usuwać katalogi.  Jak wyświetlić listę plików z katalogu, jak usunąć wybrane pliki, jak kopiować i przenosić pliki między katalogami.  Jak wyświetlać standardowe katalogi systemu Linux oraz jaką rolę spełniają poszczególne katalogi.  Jak przeglądać i interpretować informacje o właścicielu i prawach dostępu do plików i katalogów.  Jak zmieniać prawa dostępu do plików i katalogów.  Jak rozszerzać kontrolę dostępu za pomocą list ACL.  Jakie są metody tworzenia dowiązań twardych i symbolicznych, czym się różnią i jakie mają zastosowanie.

Pliki katalogów i pliki zwykłe Katalog roboczy Twój katalog domowy Ścieżki do plików i katalogów Ścieżki względne Praca z katalogami Prawa dostępu ACL — lista kontroli dostępu Dowiązania twarde Dowiązania symboliczne Odwołania do dowiązań symbolicznych

120  ROZDZIAŁ 4. SYSTEM PLIKÓW System plików (ang. filesystem) to zbiór struktur danych zlokalizowanych na dysku i pozwalających na przechowywanie katalogów wypełnionych plikami. System plików przechowuje dane użytkowników oraz dane systemowe. W tym rozdziale omówimy organizację i terminologię linuksowego systemu plików; powiemy, czym są zwykłe pliki i czym różnią się od plików katalogów; wyjaśnimy zasady tworzenia nazw plików i katalogów. Dowiesz się również, w jaki sposób możesz tworzyć i usuwać katalogi, poruszać się w systemie plików i pracować z plikami przy użyciu ścieżek względnych i bezwzględnych. W dalszej części rozdziału omówimy ważne pliki i katalogi systemu Linux oraz zagadnienia związane z prawami dostępu do plików i katalogów oraz listami ACL (ang. Access Control List), które pozwalają na współużytkowanie wybranych plików przez wielu użytkowników. Na koniec omówimy dowiązania twarde i symboliczne, dzięki którym dany plik może jednocześnie znajdować się w więcej niż jednym katalogu. Więcej szczegółowych informacji na temat poleceń df, fsck, mkfs oraz tune2fs znajdziesz w części VI książki. Jeżeli używasz systemu OS X, zapoznaj się z dodatkiem D.

HIERARCHICZNY SYSTEM PLIKÓW Struktury hierarchiczne bardzo często przyjmują kształt piramidy. Jednym z przykładów takiej struktury są powiązania rodzinne — dana para ma dziecko, które w przyszłości ma kilkoro swoich dzieci, z których każde może mieć swoje dzieci i tak dalej. Taka hierarchiczna struktura rodzinna nosi nazwę drzewa genealogicznego (patrz rysunek 4.1).

Drzewo genealogiczne

Rysunek 4.1. Drzewo genealogiczne

System plików systemu Linux również ma strukturę podobną do drzewa genealogicznego, dlatego mówimy, że ma strukturę drzewa katalogów. Linuksowy system plików składa się ze zbioru połączonych ze sobą plików. Taka struktura pozwala na przechowywanie plików w zorganizowany sposób, dzięki czemu możesz szybko odnaleźć potrzebny plik. W standardowym systemie Linux każdy użytkownik otrzymuje jeden katalog, w którym może później tworzyć dowolną liczbę podkatalogów (poprzez tworzenie wielopoziomowych podkatalogów użytkownik może rozbudowywać strukturę swojego katalogu).

Drzewo katalogów

Pliki katalogów i pliki zwykłe  121

Zazwyczaj poszczególne podkatalogi są dedykowane do przechowywania plików związanych z jednym tematem, takim jak osoba, projekt czy zdarzenie. Ten sam temat ma również wpływ na to, czy taki podkatalog będzie miał kolejne, własne podkatalogi. Na przykład na rysunku 4.2 przedstawiono strukturę podkatalogu korespondencja, należącego do jednej z sekretarek w firmie X. Ten katalog zawiera trzy podkatalogi: biznes, notatki i osobiste. W katalogu biznes znajdziemy szereg plików, w których przechowywane są wszystkie pisma przygotowywane przez naszą sekretarkę. Jeżeli spodziewasz się, że np. dla klienta ACME-Mleko będziemy mieli wyjątkowo dużo dokumentów, to możemy się pokusić o utworzenie dla niego osobnego podkatalogu.

Podkatalogi

Rysunek 4.2. Katalogi sekretarki

Jedną z ogromnych zalet linuksowego systemu plików jest możliwość adaptowania się do potrzeb użytkowników. Możesz z tego skorzystać, organizując strukturę katalogów zgodnie z własnymi potrzebami, tak aby była dla Ciebie wygodna i użyteczna.

PLIKI KATALOGÓW I PLIKI ZWYKŁE Podobnie jak w przypadku drzewa genealogicznego drzewo katalogów reprezentujące system plików jest zazwyczaj przedstawiane „do góry nogami”, z katalogiem głównym root na samej górze1. Na rysunkach 4.2 i 4.3 widać, że drzewo katalogów „rośnie” w dół od „korzenia”, czyli katalogu głównego, ze ścieżkami łączącymi poszczególne pliki z katalogiem głównym. Na końcu każdej ścieżki znajduje się albo zwykły plik, albo plik katalogu. Inne pliki specjalne, które również mogą się pojawić na końcu ścieżki zapewniają dostęp do funkcji systemu operacyjnego. Zwykłe pliki, czy też po prostu pliki (jak będziemy je w skrócie nazywać), pojawiają się na końcu ścieżek, w których już nie można utworzyć kolejnych podkatalogów (podkatalog nie może się rozpoczynać od zwykłego pliku). Pliki katalogów, określane dla uproszczenia mianem katalogów lub folderów, są punktami, z których możemy wyprowadzić kolejne podkatalogi (na rysunkach 4.2 i 4.3 widać kilka pustych katalogów). Kiedy mówimy o drzewie katalogów, kierunek w górę oznacza przechodzenie do katalogów wyżej w hierarchii, w stronę katalogu głównego. Z kolei w dół oznacza coraz większe zagłębianie się w strukturze podkatalogów, czyli odchodzenie od katalogu głównego. Katalogi połączone bezpośrednio ścieżką dzielimy na katalogi nadrzędne (znajdujące się bliżej katalogu głównego niż katalog referencyjny) oraz katalogi podrzędne (znajdujące się dalej od katalogu głównego niż katalog referencyjny). Ścieżka do pliku to po prostu seria nazw kolejnych katalogów, które pozwalają śledzić drogę poprzez kolejne katalogi do celu. Więcej szczegółowych informacji na temat ścieżek znajdziesz w sekcji „Ścieżki do plików i katalogów” w nieco dalszej części rozdziału.

1

Gra słów; w j. ang. root oznacza również „korzeń”, „podstawa” — przyp. tłum.

122  ROZDZIAŁ 4. SYSTEM PLIKÓW

Rysunek 4.3. Katalogi i zwykłe pliki

NAZWY PLIKÓW Każdy plik posiada swoją nazwę. Maksymalna długość nazwy zależy od typu systemu plików; system Linux obsługuje kilka różnych systemów plików. Choć zdecydowana większość współczesnych systemów plików pozwala na stosowanie nazw plików o długości do 255 znaków, to jednak ciągle zdarzają się systemy, w których długość nazwy pliku jest ograniczona do mniejszej liczby znaków. W nazwie pliku możesz użyć niemal wszystkich znaków, jednak w celu ograniczenia nieporozumień i uniknięcia problemów w nazwach plików i katalogów powinieneś stosować:  Wielkie litery (A – Z).  Małe litery (a – z).  Cyfry (0 – 9).  Znak podkreślenia (_).  Kropkę (.).  Przecinek (,).

Podobnie jak dwójka dzieci tego samego rodzica, tak i dwa pliki znajdujące się w tym samym katalogu nie mogą mieć takiej samej nazwy (rodzice nadają dzieciom różne imiona, bo takie postępowanie po prostu ma sens; a system Linux po prostu tego wymaga). Z drugiej strony, pliki znajdujące się w różnych katalogach mogą mieć takie same nazwy (podobnie jak dzieci różnych rodziców mogą nosić takie same imiona). Nazwa pliku powinna sugerować zawartość lub przeznaczenie takiego pliku. Niestety zbyt często zdarza się, że nasze katalogi są pełne ważnych plików, mających zupełnie nic nie mówiące nazwy, takie jak adam1, roboczy, stary, nie mówiąc już o takich perełkach jak aaaaaa czy qwerty. Takie nazwy, aczkolwiek jak najbardziej dozwolone, nie są najlepszym wyborem, ponieważ nie pomogą Ci zorientować się, co jest przechowywane w danym pliku. Poniżej przedstawiamy kilka przykładów nazw plików, które zostały dobrze wybrane i zawierają informacje o zawartości pliku:  korespondencja,  styczeń,  kowalski,  raporty,  2001,  finanse.

Pliki katalogów i pliki zwykłe  123

Jeżeli chcesz udostępniać swoje pliki użytkownikom korzystającym z innych systemów operacyjnych, to może się zdarzyć tak, że długie nazwy plików trzeba będzie mocno zredukować, aby można było zróżnicować pliki już po kilku pierwszych znakach nazwy. Komputery pracujące pod kontrolą systemu DOS czy starszych wersji systemu Windows pozwalają na tworzenie nazw plików, które mają długość maksymalnie 8 znaków plus 3 znaki rozszerzenia. Niektóre systemy klasy UNIX dopuszczają tworzenie nazw plików o długości 14 znaków, a w starszych systemach Macintosh można plikom nadawać nazwy nawet 31-znakowe. Jeżeli nadajesz plikom krótkie nazwy, to można je łatwo wpisywać w wierszu poleceń; później możesz dodać do nich krótkie rozszerzenie, tak aby nie przekroczyć limitu długości nazwy w danym systemie plików. Z drugiej strony, wadą krótkich nazw jest to, że zazwyczaj nie są one tak opisowe jak długie nazwy plików.

Długość nazw plików

Długie nazwy pozwalają na nadawanie plikom nazw opisowych. Aby wspomagać pracę z plikami i zaoszczędzić Ci wpisywania, powłoka posiada efektywny mechanizm dopełniania nazw plików. Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Praca z plikami” w rozdziale 3. Nazwy plików mogą zawierać małe i wielkie litery, ale powinieneś zachować ostrożność. Wiele systemów plików rozróżnia wielkość liter w nazwach plików. Na przykład popularna rodzina systemów plików ext i UFS rozróżnia wielkość liter, stąd STYCZEŃ, Styczeń i styczeń to z ich punktu widzenia trzy różne nazwy, reprezentujące trzy różne pliki. Z kolei system plików FAT (stosowany przede wszystkim w nośnikach wymiennych) nie rozróżnia wielkości liter i wymienione wcześniej nazwy będą oznaczały ten sam plik. HFS+, czyli domyślny system plików OS X, nie rozróżnia wielkości liter. Więcej informacji na temat HFS+ znajdziesz w dodatku D.

Rozróżnianie wielkości liter

OSTRZEŻENIE Nie używaj spacji w nazwach plików Chociaż Linux pozwala na używanie znaków spacji w nazwach plików, to jednak powinieneś tego unikać. Ponieważ Spacja jest znakiem specjalnym, w wierszu poleceń musisz ją cytować. Jednak cytowanie znaków w wierszu poleceń może być bardzo trudne dla początkującego użytkownika, a nawet może sprawiać kłopoty użytkownikom doświadczonym. Zamiast znaków spacji w nazwach plików powinieneś używać kropek i znaków podkreślenia, np. jan.05.04.26 czy nowy_raport. Jeżeli pracujesz z plikami, których nazwy zawierają spacje (na przykład z plikami przeniesionymi z innego systemu operacyjnego), to w wierszu poleceń musisz cytować znaki spacji, poprzedzając je znakiem lewego ukośnika lub umieszczając całą nazwę w cudzysłowie. W przykładzie przedstawionym poniżej oba polecenia powodują wysłanie pliku o nazwie moje notatki na drukarkę. $ lpr moje\ notatki $ lpr "moje notatki"

ROZSZERZENIA NAZW PLIKÓW Rozszerzeniem nazwy pliku nazywamy końcową część nazwy pliku, która występuje po kropce. Rozszerzenia nazw plików przedstawionych w tabeli 4.1 ułatwiają szybką identyfikację zawartości pliku. Niektóre programy, takie jak na przykład kompilator języka C, używają domyślnego zestawu rozszerzeń nazw plików, aczkolwiek w większości przypadków stosowanie rozszerzeń jest opcjonalne — możesz używać ich w dowolny sposób, tak aby nazwa pliku była zrozumiała. W razie potrzeby możesz w nazwie pliku użyć kilku kropek — na przykład notes.4.10.54 czy raport.tar.gz. W systemie OS X pewne aplikacje używają rozszerzeń pliku w celu identyfikacji plików. Jednak większość aplikacji OS X do identyfikacji plików używa kodów i kodów kreatora.

124  ROZDZIAŁ 4. SYSTEM PLIKÓW Tabela 4.1. Rozszerzenia nazw plików Nazwa pliku z rozszerzeniem

Znaczenie rozszerzenia

compute.c

Plik źródłowy programu w języku C.

compute.o

Plik obiektowy utworzony po asemblacji pliku compute.c.

compute

Plik wykonywalny utworzony po skompilowaniu pliku compute.c.

memo.0410.txt

Plik tekstowy.

memo.pdf

Plik w formacie PDF; jego zawartość możesz przeglądać w środowisku graficznym za pomocą polecenia xpdf lub kpdf.

memo.ps

Plik w formacie PostScript; jego zawartość możesz przeglądać w środowisku graficznym za pomocą polecenia ghostscript lub kpdf.

memo.Z

Plik skompresowany poleceniem compress; do dekompresji możesz użyć polecenia uncompress lub gunzip.

memo.gz

Plik skompresowany poleceniem gzip; jego zawartość możesz przeglądać poleceniem zcat; do dekompresji możesz użyć polecenia gunzip.

memo.tgz lub memo.tar.gz

Plik archiwum tar, skompresowany poleceniem gzip.

memo.bz2

Plik skompresowany poleceniem bzip2; jego zawartość możesz przeglądać poleceniem bzcat; do dekompresji możesz użyć polecenia bunzip2.

memo.html

Plik HTML, którego zawartość możesz zobaczyć w przeglądarce sieciowej, takiej jak Firefox.

obraz.gif, obraz.jpg, obraz.jpeg, obraz.bmp, obraz.tif lub obraz.tiff

Plik zawierający informacje graficzne, takie jak zdjęcia.

UKRYTE NAZWY PLIKÓW Nazwa pliku zaczynająca się od kropki jest nazywana ukrytą nazwą pliku (taki plik jest nazywany po prostu plikiem ukrytym lub czasami plikiem niewidzialnym), ponieważ polecenie ls domyślnie nie wyświetla takich plików. Dopiero polecenie ls -a (ang. all) wyświetla nazwy wszystkich plików, nawet tych ukrytych. Nazwy plików startowych i konfiguracyjnych bardzo często rozpoczynają się od znaku kropki, dzięki czemu pozostają ukryte i nie „zaśmiecają” normalnego wyświetlania zawartości katalogu. W każdym katalogu występują również dwa specjalne elementy, oznaczone odpowiednio jedną i dwiema kropkami (. oraz .., patrz nieco dalej w rozdziale).

KATALOG ROBOCZY Kiedy jesteś zalogowany do systemu Linux w trybie tekstowym, to Twoja sesja powłoki jest zawsze przypisana do jakiegoś katalogu. Katalog, w którym aktualnie się znajdujesz, nosi nazwę katalogu roboczego lub inaczej katalogu bieżącego. Czasami takie powiązanie nabiera nieco bardziej materialnego wymiaru, kiedy mówimy „Jesteś w (lub pracujesz w) katalogu raporty”. Wbudowane polecenie powłoki pwd (ang. print working directory) wyświetla nazwę katalogu roboczego.

Polecenie pwd

TWÓJ KATALOG DOMOWY Kiedy pierwszy raz logujesz się do systemu Linux lub uruchamiasz okno emulatora terminala, katalogiem roboczym jest Twój katalog domowy. Aby wyświetlić nazwę katalogu domowego, zaraz po zalogowaniu się wykonaj polecenie pwd (patrz rysunek 4.4). Katalogi domowe użytkowników systemu Linux najczęściej znajdują się w /home, natomiast systemu OS X w /Users.

Ścieżki do plików i katalogów  125

login: kuba Password: Last login: Wed Oct 20 11:14:21 from 172.16.192.150 $ pwd /home/kuba

Rysunek 4.4. Logowanie do systemu i wyświetlenie nazwy katalogu domowego

Kiedy użyjesz polecenia ls bez żadnych argumentów, na ekranie terminala zostanie wyświetlona zawartość katalogu roboczego. Ponieważ Twój katalog domowy był do tej pory jedynym używanym przez Ciebie katalogiem, polecenie ls zawsze wyświetlało listę plików znajdujących się właśnie w tym katalogu (wszystkie pliki, które tworzyliśmy do tej pory, były przechowywane w Twoim katalogu roboczym).

PLIKI STARTOWE Pliki startowe, które pojawiają się w Twoim katalogu domowym, dostarczają powłoce oraz innym programom informacji o Tobie i Twoich preferencjach. W systemie OS X są one nazywane plikami konfiguracyjnymi lub plikami preferencji (patrz dodatek D). Bardzo często jeden z tych plików jest wykorzystywany do przekazania powłoce informacji o rodzaju terminala, z którego korzystasz (patrz dodatek B), oraz do uruchomienia polecenia stty (ang. set terminal) i ustawienia za jego pomocą kombinacji klawiszy służących do kasowania (patrz rozdział 2.) pojedynczych znaków oraz usuwania całego wiersza (patrz rozdział 2.). Pliki startowe zawierające odpowiedni zestaw poleceń powłoki mogą zostać utworzone w katalogu domowym przez Ciebie lub przez administratora systemu. Powłoka automatycznie wykonuje polecenia zapisane w plikach startowych za każdym razem, kiedy logujesz się do systemu. Ponieważ pliki startowe mają ukryte nazwy (jak pamiętasz, nazwy plików ukrytych rozpoczynają się od kropki), to do sprawdzenia, czy w Twoim katalogu domowym znajdują się takie pliki, musisz użyć polecenia ls -a. Więcej szczegółowych informacji na temat plików startowych znajdziesz w rozdziałach 8. (bash) i 9. (tcsh).

ŚCIEŻKI DO PLIKÓW I KATALOGÓW Każdy plik posiada powiązaną z nim ścieżkę dostępu, która jest szlakiem prowadzącym od katalogu głównego, poprzez hierarchię katalogów, aż do danego pliku lub katalogu. Jeżeli za ostatnim elementem ścieżki znajduje się znak prawego ukośnika (/), oznacza to, że taki element jest plikiem katalogu (mówiąc w uproszczeniu — katalogiem). Jeżeli znak prawego ukośnika znajduje się przed ostatnim elementem ścieżki, to taki element może być albo zwykłym plikiem, albo plikiem katalogu. Najprostszym przykładem ścieżki do pliku jest sama nazwa pliku — taka ścieżka wskazuje na plik o danej nazwie, znajdujący się w katalogu roboczym. W tej sekcji opowiemy, czym się różnią ścieżki względne od bezwzględnych oraz wyjaśnimy, jak i kiedy używać każdej z nich.

ŚCIEŻKI BEZWZGLĘDNE Główny katalog w hierarchii systemu plików nie posiada swojej odrębnej nazwy, jest nazywany po prostu katalogiem głównym i reprezentowany przez znak prawego ukośnika (/) pojawiający się samodzielnie lub jako pierwszy od lewej znak ścieżki dostępu do pliku.

/ (katalog główny)

Bezwzględna ścieżka dostępu do pliku rozpoczyna się od znaku prawego ukośnika (/), który reprezentuje katalog główny. Po znaku ukośnika znajduje się nazwa pliku zlokalizowanego w katalogu głównym. Ścieżka może być rozwijana dalej, poprzez kolejne podkatalogi, aż do osiągnięcia pliku czy katalogu docelowego. Nazwy poszczególnych katalogów w ścieżce oddzielone są od siebie znakami prawego ukośnika (/). Taki rodzaj ścieżki dostępu jest nazwany ścieżką bezwzględną, ponieważ bezwarunkowo prowadzi od katalogu głównego, poprzez wszystkie katalogi pośrednie, aż do pliku czy

126  ROZDZIAŁ 4. SYSTEM PLIKÓW katalogu docelowego. Zazwyczaj na końcu bezwzględnej ścieżki dostępu do katalogu nie dodajemy po nazwie katalogu znaku /, aczkolwiek taki format zapisu może być użyty do podkreślenia, że ostatni element ścieżki jest katalogiem, a nie plikiem (na przykład /home/kuba/). Element ścieżki znajdujący się po prawej stronie ostatniego znaku ukośnika jest nazywany prostą nazwą pliku, nazwą pliku lub nazwą bazową. Na rysunku 4.5 przedstawiono przykłady bezwzględnych ścieżek dostępu do plików i katalogów w części hierarchii systemu plików.

Rysunek 4.5. Bezwzględne ścieżki dostępu

Korzystając ze ścieżek bezwzględnych, możesz pracować z dowolnymi plikami w systemie lokalnym (zakładając oczywiście, że masz do nich odpowiednie prawa dostępu) niezależnie od tego, z jakiego katalogu roboczego wydajesz polecenie. Na przykład dawid wykonał polecenie wyświetlenia zawartości katalogu /etc/ssh, przedstawione poniżej, pracując ze swojego katalogu domowego: $ pwd /home/dawid $ ls /etc/ssh moduli ssh_host_dsa_key ssh_config ssh_host_dsa_key.pub sshd_config ssh_host_key

ssh_host_key.pub ssh_host_rsa_key ssh_host_rsa_key.pub

ZNAK TYLDY (~) W NAZWIE ŚCIEŻKI W innej formie ścieżki bezwzględnej powłoka rozwija ciąg znaków ~/ (tylda i prawy ukośnik) znajdujący się na początku ścieżki do postaci pełnej ścieżki do Twojego katalogu domowego. Korzystając z takiego skrótu, możesz wyświetlić zawartość pliku startowego .bashrc z dowolnego katalogu za pomocą następującego polecenia: $ less ~/.bashrc

Za pomocą znaku tyldy można szybko odwoływać się do ścieżek prowadzących do Twojego katalogu domowego lub do katalogów domowych innych użytkowników. Powłoka systemu rozwija znak tyldy, po którym następuje nazwa użytkownika, do pełnej ścieżki bezwzględnej do katalogu domowego tego użytkownika. Na przykład kuba może sprawdzić zawartość pliku .bashrc użytkownika dawid za pomocą następującego polecenia (zakładając oczywiście, że ma do tego odpowiednie prawa dostępu): $less ~dawid/.bashrc

Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Rozwijanie znaku tyldy” w rozdziale 8.

Praca z katalogami  127

ŚCIEŻKI WZGLĘDNE Ścieżka względna przedstawia drogę, jaką należy przejść od katalogu roboczego do danego pliku — inaczej mówiąc, taka ścieżka jest tworzona względem katalogu roboczego. Każda ścieżka, która nie rozpoczyna się od katalogu głównego (reprezentowany przez znak prawego ukośnika /) lub znaku tyldy (~) jest ścieżką względną. Podobnie jak w przypadku ścieżek bezwzględnych ścieżki względne mogą przechodzić przez wiele katalogów. Najprostszą formą ścieżki względnej jest sama nazwa pliku, która identyfikuje dany plik w bieżącym katalogu roboczym. Przykłady zaprezentowane w następnych sekcjach wykorzystują zarówno ścieżki względne, jak i bezwzględne.

ZNACZENIE KATALOGU ROBOCZEGO Aby uzyskać dostęp do pliku znajdującego się w katalogu roboczym, wystarczy Ci tylko sama nazwa pliku. Jednak aby uzyskać dostęp do pliku znajdującego się w innym katalogu, musisz użyć ścieżki. Wpisywanie długich ścieżek jest irytujące i nudne, a co gorsza, zwiększa możliwość popełnienia błędu. Takie „niebezpieczeństwa” są znacznie mniejsze, jeżeli pracujesz w środowisku graficznym, gdzie po prostu klikasz nazwy plików czy ikony. Dla każdego zadania możesz wybrać sobie odpowiedni katalog roboczy, tak aby zminimalizować potrzebę wpisywania długich ścieżek. Wybranie takiego czy innego katalogu roboczego nie ma żadnego wpływu na to, czy możesz wykonywać takie czy inne zadania — ale po prostu ułatwia ich wykonywanie.

OSTRZEŻENIE Korzystając ze ścieżek względnych, musisz pamiętać, który katalog jest bieżącym katalogiem roboczym Lokalizacja pliku, do którego uzyskujesz dostęp za pomocą ścieżki względnej, jest zależna od katalogu roboczego (jak już wspominaliśmy, ścieżka względna jest tworzona względem katalogu roboczego). Zanim zaczniesz tworzyć czy wpisywać ścieżkę względną, powinieneś zawsze upewnić się, który katalog jest aktualnie katalogiem roboczym. Aby to sprawdzić, powinieneś użyć polecenia pwd. Jeżeli tworzysz plik tekstowy przy użyciu edytora vim, a w rzeczywistości znajdujesz się w innym katalogu roboczym, niż myślałeś, to nowy plik może zostać utworzony w zupełnie nieoczekiwanym miejscu. Kiedy korzystasz ze ścieżek bezwzględnych, to lokalizacja bieżącego katalogu roboczego nie ma żadnego znaczenia. Na przykład polecenie przedstawione poniżej powoduje, że za pomocą edytora vim będziesz zawsze edytował plik o nazwie notatki znajdujący się w Twoim katalogu domowym. $ vim ~/notatki

Rzuć okiem na rysunek 4.6. Pliki, które znajdują się bezpośrednio w katalogu roboczym, mogą być wskazywane przy użyciu samych nazw plików. Jeżeli dany plik znajduje się w podkatalogu katalogu roboczego, to możesz się do niego odwołać za pomocą krótkiej ścieżki względnej, takiej jak na przykład dwie nazwy oddzielone od siebie znakiem prawego ukośnika. Kiedy operujesz plikami zlokalizowanymi w złożonej strukturze katalogów, zastosowanie ścieżek względnych może zaoszczędzić Ci wiele czasu i pomoże uniknąć niepotrzebnej irytacji. Jeżeli wybierzesz taki katalog roboczy, w którym znajduje się większość plików niezbędnych do wykonania danego zadania, to będziesz mógł użyć mniejszej ilości długich, kłopotliwych ścieżek.

PRACA Z KATALOGAMI W tej sekcji dowiesz się, w jaki sposób możesz tworzyć nowe katalogi (polecenie mkdir), przechodzić między katalogami (polecenie cd), usuwać katalogi (polecenie rm), używać ścieżek tak, aby ułatwić sobie wykonywanie zadania, oraz kopiować i przenosić pliki między katalogami. Sekcję zakończymy krótkim podsumowaniem najważniejszych, standardowych plików i katalogów linuksowego systemu plików.

128  ROZDZIAŁ 4. SYSTEM PLIKÓW

Rysunek 4.6. Względne ścieżki dostępu

POLECENIE MKDIR — TWORZENIE KATALOGÓW Polecenie mkdir pozwala na tworzenie nowych katalogów. Argumentem (patrz słowniczek na końcu książki) tego polecenia jest nazwa ścieżki prowadzącej do tworzonego katalogu. Polecenia przedstawione poniżej tworzą strukturę katalogów przedstawioną na rysunku 4.7. Przedstawione na rysunku obramowania nowych katalogów mają nieco jaśniejszy odcień i są połączone liniami przerywanymi.

Rysunek 4.7. Struktura plików i katalogów utworzona w omawianym przykładzie

Wyniki działania polecenia pwd, przedstawione na rysunku 4.8, pokazują, że użytkownik kuba pracuje w swoim katalogu roboczym (/home/kuba), a polecenie ls pokazuje, że w tym katalogu znajdują się pliki o nazwach demo, nazwy i temp. Korzystając z polecenia mkdir, użytkownik kuba tworzy katalog o nazwie literatura, będący podkatalogiem katalogu domowego. Użytkownik kuba, tworząc podkatalog, używa ścieżki względnej (prostej nazwy pliku), ponieważ chce, aby katalog literatura był podkatalogiem bieżącego katalogu roboczego. Oczywiście kuba mógł do utworzenia tego katalogu użyć jednego z wariantów ścieżki bezwzględnej: mkdir /home/kuba/literatura, mkdir ~kuba/literatura czy mkdir ~/literatura.

Praca z katalogami  129

$ pwd /home/kuba $ ls demo nazwy temp $ mkdir literatura $ ls demo literatura nazwy temp $ ls -F demo literatura/ nazwy temp $ ls literatura $

Rysunek 4.8. Polecenie mkdir

Kolejne polecenie ls przedstawione na rysunku 4.8 sprawdza obecność nowego katalogu. Opcja -F polecenia ls powoduje wyświetlenie znaków prawego ukośnika po nazwach katalogów oraz znaku gwiazdki po nazwie każdego pliku wykonywalnego (skrypt powłoki, narzędzie czy aplikacja). Jeżeli wykonasz polecenie ls, którego argumentem będzie nazwa katalogu, polecenie ls wyświetli zawartość tego katalogu. Ostatnie polecenie ls nie wyświetla żadnych nazw plików, ponieważ katalog literatura jest pusty. Polecenia przedstawione poniżej pokazują dwa sposoby, których użytkownik kuba może użyć do utworzenia katalogu promocje, będącego podkatalogiem nowo utworzonego katalogu literatura. W pierwszej metodzie sprawdzamy, czy katalog /home/kuba jest katalogiem roboczym, i następnie korzystamy ze ścieżki względnej: $ pwd /home/kuba $ mkdir literatura/promocje

W drugiej metodzie korzystamy po prostu ze ścieżki bezwzględnej: $ mkdir /home/kuba/literatura/promocje

Użycie opcji -p (ang. parents) w poleceniu mkdir powoduje, że polecenie to utworzy katalogi literatura i promocje w jednym przebiegu: $ pwd /home/kuba $ ls demo names temp $ mkdir -p literatura/promocje

lub $ mkdir -p /home/kuba/literatura/promocje

POLECENIE CD — ZMIANA KATALOGU ROBOCZEGO Polecenie cd (ang. change directory) pozwala na zmianę katalogu roboczego na inny. Pamiętaj, że polecenie to w żaden sposób nie zmienia zawartości katalogu roboczego. Na rysunku 4.9 przedstawiono dwa sposoby zmiany bieżącego katalogu roboczego na katalog /home/kuba/literatura, co zostanie potwierdzone przez uruchomienie polecenia pwd. W pierwszej metodzie użytkownik kuba korzysta z polecenia cd, którego argumentem jest ścieżka bezwzględna. Wykonanie tego polecenia powoduje, że katalogiem roboczy staje się katalog literatura. Jeżeli korzystasz ze ścieżki bezwzględnej, to nie ma żadnego znaczenia, w jakim katalogu roboczym się znajdujesz w momencie wykonania takiego polecenia. $ cd /home/kuba/literatura $ pwd /home/kuba/literatura $ cd $ pwd /home/kuba $ cd literatura $ pwd /home/kuba/literatura

Rysunek 4.9. Polecenie cd pozwala na zmianę katalogu roboczego

130  ROZDZIAŁ 4. SYSTEM PLIKÓW Wykonanie polecenia pwd potwierdza dokonanie zmian. Jeżeli użyjesz polecenia cd bez żadnych argumentów, to bieżącym katalogiem roboczym stanie się Twój katalog domowy — ten sam, w którym „lądujesz” zaraz po zalogowaniu się do systemu. Drugie polecenie cd (patrz rysunek 4.9) nie posiada żadnych argumentów, stąd po jego wykonaniu katalogiem roboczym jest katalog domowy użytkownika kuba. Teraz wiedząc, że znajduje się w swoim katalogu domowym, użytkownik kuba używa prostej nazwy pliku do zmiany katalogu roboczego na katalog literatura (cd literatura) i następnie potwierdza dokonanie zmiany poleceniem pwd.

KATALOGI . ORAZ .. Polecenie mkdir automatycznie umieszcza w każdym nowo utworzonym katalogu dwa elementy: pierwszy oznaczony jest pojedynczym znakiem kropki (.), a oznaczenie drugiego składa się z dwóch kropek (..). Pojedyncza kropka (.) jest synonimem ścieżki do bieżącego katalogu roboczego i może być używana w jej zastępstwie. Z kolei dwie kropki (..) są synonimem katalogu nadrzędnego do bieżącego katalogu roboczego. Oba elementy są ukryte, ponieważ ich nazwy rozpoczynają się od znaku kropki. W przykładzie przedstawionym poniżej katalogiem roboczym jest katalog literatura. W tym przykładzie katalog .. wykorzystywany jest trzykrotnie: po raz pierwszy do wyświetlenia zawartości katalogu nadrzędnego (/home/kuba), po raz drugi do skopiowania pliku memoA do katalogu nadrzędnego i wreszcie po raz trzeci do ponownego wyświetlenia zawartości katalogu nadrzędnego: $ pwd /home/kuba/literatura $ ls .. demo literatura nazwy temp $ cp memoA .. $ ls .. demo literatura memoA nazwy temp

Po użyciu polecenia cd do zmiany katalogu roboczego na katalog promocje (podkatalog katalogu literatura) użytkownik kuba może użyć ścieżki względnej do wywołania edytora vim i edytowania pliku znajdującego się w jego katalogu domowym: $ cd promocje $ vim ../../nazwy

Ścieżek bezwzględnych, względnych lub prostych nazw plików możesz używać wszędzie tam, gdzie dane polecenie czy narzędzie wymaga użycia nazwy pliku lub ścieżki dostępu. Takie stwierdzenie jest prawdziwe dla poleceń ls, vim, mkdir, rm oraz zdecydowanej większości innych poleceń i narzędzi systemu Linux.

WSKAZÓWKA Katalog roboczy kontra katalog domowy Pamiętaj, że katalog roboczy to nie jest to samo co katalog domowy. Twój katalog domowy nie zmienia się przez cały czas trwania sesji z systemem Linux, a co więcej, zazwyczaj nie zmienia się również między sesjami. Zaraz po zalogowaniu zawsze „lądujesz” w tym samym katalogu — swoim katalogu domowym. W przeciwieństwie do katalogu domowego katalog roboczy może się zmieniać tak często, jak to tylko jest potrzebne. Katalog roboczy bywa też często nazywany katalogiem bieżącym. Kiedy zalogujesz się do systemu, Twoim katalogiem roboczym domyślnie staje się katalog domowy i pozostaje nim dopóty, dopóki nie użyjesz polecenia cd do zmiany na inny katalog roboczy. Jeżeli użytkownik kuba przejdzie do katalogu domowego użytkownika dawid, to katalog domowy użytkownika dawid stanie się katalogiem roboczym użytkownika kuba.

Praca z katalogami  131

POLECENIE RMDIR — USUWANIE KATALOGÓW Polecenie rm (ang. remove directory) pozwala na usuwanie katalogów. Nie możesz usunąć bieżącego katalogu roboczego oraz katalogu zawierającego inne pliki niż (.) i (..). Jeżeli chcesz usunąć katalog, w którym znajdują się jakieś pliki, najpierw musisz użyć polecenia rm do usunięcia wszystkich plików z tego katalogu i dopiero potem możesz usunąć sam katalog. Nie musisz (a w zasadzie nie możesz) usuwać plików (.) i (..); polecenie rmdir automatycznie zrobi to za Ciebie. Polecenie przedstawione poniżej usuwa katalog promocje: $ rmdir /home/kuba/literatura/promocje

Polecenie rm posiada opcję -r (składnia polecenia z użyciem tej opcji wygląda nazwa_pliku), której użycie powoduje rekursywne usunięcie wszystkich plików i

następująco: rm -r podkatalogów znaj-

dujących się w danym katalogu i na końcu usunięcie samego katalogu.

OSTRZEŻENIE Polecenia rm -r powinieneś używać z wielką ostrożnością (a najlepiej nie używać go wcale) Choć polecenie rm -r jest bardzo wygodne, musisz używać go z wielką ostrożnością. Nigdy nie powinieneś używać go z wieloznacznymi nazwami plików, takimi jak *. Będąc nieostrożnym, możesz jednym, prostym poleceniem z łatwością usunąć całą zawartość katalogu domowego.

KORZYSTANIE ZE ŚCIEŻEK Jeżeli chcesz poeksperymentować z przykładem przedstawionym poniżej, powinieneś użyć edytora tekstu do utworzenia pliku o nazwie lista. Zamiast tego możesz również użyć polecenia touch do utworzenia pustego pliku:

Polecenie touch

$ cd $ pwd /home/kuba $ touch lista

W poniższym przykładzie katalogiem domowym jest /home/kuba. Polecenie cp zostaje użyte do skopiowania pliku o nazwie lista do katalogu /home/kuba/literatura/promocje (jeżeli w poprzednim przykładzie skasowałeś katalog promocje, to teraz powinieneś utworzyć go ponownie). Skopiowany plik będzie nosił nazwę lista.0210. $ cp lista literatura/promocje/lista.0210

Jeżeli użytkownik kuba nie zmienił katalogu roboczego na inny, może teraz użyć polecenia przedstawionego poniżej do edytowania utworzonej przed chwilą kopii pliku:

vim

$ vim literatura/promocje/lista.0210

Jeżeli kuba nie będzie chciał używać długich ścieżek przy odwołaniach do pliku, może za pomocą polecenia cd zmienić katalog roboczy na promocje i dopiero wtedy użyć edytora vim: $ cd literatura/promocje $ pwd /home/kuba/literatura/promocje $ vim lista.0210

Aby nowym katalogiem roboczym stał się nadrzędny katalog bieżącego katalogu roboczego (czyli /home/kuba/literatura), użytkownik kuba może wykonać polecenie przedstawione poniżej, które korzysta z oznaczenia katalogu (..): $ cd .. $ pwd /home/kuba/literatura

132  ROZDZIAŁ 4. SYSTEM PLIKÓW

POLECENIA MV I CP — PRZENOSZENIE LUB KOPIOWANIE PLIKÓW W rozdziale 3. wykorzystywaliśmy polecenie mv do zmieniania nazw plików. Polecenie mv posiada jednak więcej zastosowań — możesz używać go również do przenoszenia plików z jednego katalogu do drugiego (zmieniając tym samym ścieżkę do pliku). Kiedy używasz polecenia mv do przenoszenia plików między katalogami, ma ono następującą składnię: mv lista_plików katalog_docelowy

Jeżeli katalogiem roboczym jest /home/kuba, to użytkownik kuba może przenieść pliki nazwy oraz temp z bieżącego katalogu roboczego do katalogu literatura za pomocą polecenia przedstawionego poniżej: $ mv nazwy temp literatura

Wykonanie tego polecenia zmienia bezwzględne ścieżki dostępu do plików nazwy i temp z /home/kuba/ nazwy i /home/kuba/temp na odpowiednio /home/kuba/literatura/nazwy i /home/kuba/literatura/temp, tak jak to zostało przedstawione na rysunku 4.10. Podobnie jak większość poleceń systemu Linux, również polecenie mv pozwala na korzystanie ze względnych i bezwzględnych ścieżek dostępu.

Rysunek 4.10. Zastosowanie polecenia mv do przeniesienia plików nazwy i temp

W miarę postępującej pracy z systemem Linux i tworzenia coraz większej ilości plików w celu utrzymania porządku będziesz musiał tworzyć za pomocą polecenia mkdir kolejne katalogi i rozmieszczać w nich pliki. Polecenie mv jest bardzo użyteczne w takich sytuacjach i pozwoli Ci na szybkie i wygodne przenoszenie plików w hierarchii katalogów. Polecenie cp działa niemal dokładnie w taki sam sposób jak z podanej listy, tworzy w katalogu docelowym ich kopie.

mv,

z tym że zamiast przenosić pliki

POLECENIE MV — PRZENOSZENIE KATALOGÓW Oprócz plików polecenie mv może w taki sam sposób przenosić całe katalogi. Składnia polecenia w takiej sytuacji jest bardzo podobna, z tym że zamiast listy plików do przeniesienia musisz podać listę katalogów: mv lista_katalogów katalog_docelowy

Jeżeli katalog_docelowy nie istnieje, argument lista_katalogów musi zawierać nazwę tylko jednego katalogu, która zostanie zmieniona na nazwę określoną przez argument katalog_docelowy (inaczej mówiąc, w takiej sytuacji polecenie mv dokona po prostu zmiany nazwy katalogu). Za pomocą polecenia mv możesz zmieniać nazwy katalogów, ale nie możesz kopiować ich zawartości przy użyciu polecenia

Praca z katalogami  133

cp

dopóty, dopóki nie użyjesz opcji -r (ang. recursive). Więcej szczegółowych informacji na temat innych sposobów kopiowania i przenoszenia katalogów, a także omówienie poleceń cpio, pax i tar znajdziesz w części VI książki.

WAŻNE PLIKI I KATALOGI DOMYŚLNE Początkowo pliki systemu Linux w poszczególnych dystrybucjach i wersjach nie były rozmieszczane w standardowych lokalizacjach systemu plików. Taka dowolność i duże rozproszenie plików powodowało duże trudności w tworzeniu dokumentacji i zarządzaniu systemem Linux, a co gorsza, powodowało, że utworzenie pakietu oprogramowania, który mógłby być skompilowany i uruchomiony na wszystkich wersjach systemu Linux, było praktycznie niemożliwe. Pierwszym standardem dla linuksowego systemu plików był FSSTND (ang. Linux Filesystem Standard), opublikowany w roku 1994. Na początku roku 1995 rozpoczęto prace nad opracowaniem szerszego standardu, pokrywającego wiele systemów klasy UNIX, o nazwie FHS (ang. Linux Filesystem Hierarchy Standard; patrz www.pathname.com/fhs/). Nieco później standard FHS został włączony do projektu LSB (ang. Linux Standard Base; patrz http://www.linuxfoundation.org/collaborate/workgroups/lsb), podgrupy FSG (ang. Free Standards Group). Finalnie FSG połączyło się z organizacją OSDL (ang. Open Source Development Labs), co w efekcie zaowocowało powstaniem organizacji Linux Foundation (patrz http://www.linuxfoundation.org/). Na rysunku 4.11 przedstawiono lokalizację wybranych, ważnych plików i katalogów zdefiniowanych przez FHS. Znaczenie wielu przedstawionych na rysunku katalogów stanie się jasne po przeczytaniu dalszych rozdziałów tej książki.

Rysunek 4.11. Typowa struktura linuksowego systemu plików, oparta na zaleceniach FHS

W zestawieniu przedstawionym poniżej zamieszczamy krótkie opisy niektórych katalogów z listy FHS oraz kilku innych, wybranych katalogów. Warto jednak zauważyć, że większość dystrybucji nie korzysta ze wszystkich katalogów wymienionych w standardzie FHS. Pamiętaj, że nie zawsze można określić funkcję katalogu po jego nazwie. Na przykład w katalogu /opt przechowywane są różne dodatkowe pakiety oprogramowania, a w katalogu /opt/etc znajdziesz pliki konfiguracyjne dla oprogramowania z katalogu /opt. /

Katalog główny, obecny we wszystkich linuksowych systemach plików jest nadrzędnym obiektem wszystkich plików i katalogów w systemie Linux. Katalog główny nie posiada nazwy i jest reprezentowany przez samodzielny znak prawego ukośnika (/) lub znak prawego ukośnika znajdujący się na początku ścieżki dostępu. Podstawowe pliki wykonywalne. Przechowuje pliki wykonywalne dostępne dla wszystkich użytkowników oraz pliki niezbędne do uruchomienia systemu w trybie single-user.

/bin

Statyczne pliki programu rozruchowego. Zawiera wszystkie pliki niezbędne do uruchomienia systemu.

/boot

Pliki urządzeń. Zawiera pliki reprezentujące urządzenia peryferyjne, takie jak napędy dyskowe, terminale i drukarki. Poprzednio w tym katalogu były przechowywane pliki wszystkich urządzeń. Narzędzie udev tworzy dynamiczny katalog urządzeń, dzięki któremu w katalogu /dev znajdują się tylko pliki urządzeń zainstalowanych w danym systemie.

/dev

134  ROZDZIAŁ 4. SYSTEM PLIKÓW Pliki konfiguracyjne systemu lokalnego. Przechowuje pliki administracyjne, konfiguracyjne i inne pliki systemowe. System OS X zamiast pliku /etc/passwd używa technologii Open Directory.

/etc

Pliki konfiguracyjne dla pakietów oprogramowania z katalogu /opt.

/etc/opt

Plik konfiguracyjne lokalnego serwera X Window System.

/etc/X11

Katalogi domowe użytkowników. Katalogi domowe poszczególnych użytkowników mają zazwyczaj postać podkatalogów w katalogu /home. Na przykład: zakładając, że katalogi domowe użytkowników przechowywane są w katalogu /home, bezwzględna ścieżka do katalogu domowego użytkownika dawid będzie miała postać /home/dawid. W systemie OS X katalogi domowe użytkowników są przechowywane w katalogu /Users.

/home

/lib

Współużytkowane biblioteki systemowe.

/lib/modules

Moduły jądra systemu.

/mnt

Punkty montowania dla tymczasowo montowanych systemów plików.

/opt

Dodatkowe (opcjonalne) pakiety oprogramowania.

/proc

Wirtualny system plików dla jądra systemu oraz informacji o stanie procesów.

/root

Katalog domowy użytkownika root.

Dane czasu wykonania (ang. runtime data). System plików tmpfs (zamontowany, ale przechowywany w pamięci RAM), w którym zapisane są pliki poprzednio ukryte w katalogu /dev i innych. Więcej szczegółowych informacji na ten temat znajdziesz na stronie http://lists.fedoraproject.org/ pipermail/devel/2011-March/150031.html.

/run

Podstawowe, systemowe pliki wykonywalne (binaria). W katalogach /sbin i /usr/sbin przechowywane są narzędzia używane przez administratorów systemu. W katalogu /sbin znajdują się również narzędzia niezbędne podczas uruchamiania systemu, a w katalogu /usr/sbin narzędzia wykorzystywane wtedy, kiedy system jest już uruchomiony.

/sbin

/sys

Pseudosystem plików dla urządzeń.

/tmp

Pliki tymczasowe.

Katalog przechowujący katalogi domowe użytkowników w OS X. Katalogi domowe użytkowników OS X są najczęściej umieszczane w katalogu /Users. Natomiast katalogi domowe użytkowników systemu Linux najczęściej znajdują się w /home.

/Users

Drugorzędowa hierarchia dla współużytkowanych danych użytkownika. Tradycyjnie znajdują się tutaj podkatalogi zawierające informacje wykorzystywane przez system operacyjny. Pliki w podkatalogach katalogu /usr nie zmieniają się zbyt często i mogą być współużytkowane przez kilka systemów.

/usr

Polecenia i narzędzia użytkowników. Znajdziesz tutaj standardowe programy narzędziowe systemu Linux — głównie binaria, które nie są potrzebne w trybie single-user.

/usr/bin

/usr/games

Gry i programy edukacyjne.

/usr/include

Pliki nagłówkowe używane przez programy w języku C.

/usr/lib

Biblioteki.

Hierarchia lokalna. Przechowuje ważne pliki i katalogi lokalne dodawane do systemu. Możesz znaleźć tam takie podkatalogi jak bin, games, include, lib, sbin, share i src.

/usr/local /usr/sbin

Dodatkowe, administracyjne pliki wykonywalne (binaria). Patrz /sbin.

Prawa dostępu  135

Dane niezależne od architektury systemu. Znajdziesz tam takie podkatalogi jak dict, doc, games, info, locale, man, misc, terminfo i zoneinfo.

/usr/share

/usr/share/doc

Dokumentacja.

/usr/share/info

Podstawowy katalog systemu GNU info.

/usr/share/man

Podręczniki man.

/usr/src

Kod źródłowy.

Dane często ulegające zmianom. W tym katalogu przechowywane są pliki, których zawartość często zmienia się podczas działania systemu. Najczęściej spotykanymi przykładami takich plików są pliki tymczasowe, pliki dzienników systemowych, pliki kolejek wydruku i skrzynki pocztowe użytkowników. Znajdziesz tutaj takie podkatalogi jak cache, lib, lock, log, mail, opt, run, spool, tmp i yp.

/var

Pliki dzienników. Zawiera m.in. dzienniki takie jak lastlog (zapis ostatniego logowania poszczególnych użytkowników), messages (komunikaty systemowe demona syslogd) i wtmp (zapis wszystkich zdarzeń logowania i wylogowania).

/var/log

Miejsce przechowywania danych z oczekujących zadań. W tym katalogu znajdziesz takie katalogi jak anacron, at, cron, lpd, mail, mqueue, samba i inne. Plik /var/mail jest zazwyczaj dowiązaniem do katalogu /var/spool/mail.

/var/spool

PRAWA DOSTĘPU Większość dystrybucji obsługuje dwie metody kontrolowania tego, kto może mieć dostęp do danego pliku i na jakim poziomie: tradycyjne prawa dostępu do plików oraz listy ACL (ang. Access Control List). W tej sekcji omówimy zagadnienia związane z tradycyjnymi, linuksowymi prawami dostępu. Więcej szczegółowych informacji na temat list ACL, które zapewniają możliwość znacznie bardziej szczegółowego zdefiniowania poziomów dostępu, znajdziesz w sekcji „ACL — lista kontroli dostępu” w dalszej części tego rozdziału. Dostęp do pliku mogą uzyskać trzy typy użytkowników: właściciel pliku (ang. owner), członek grupy, która jest powiązana z danym plikiem (ang. group), oraz wszyscy inni użytkownicy (ang. other). Użytkownik może użyć zwykłego pliku na jeden z trzech sposobów: próbując odczytać dane z pliku, zapisać dane do pliku lub próbując wykonać plik (inaczej mówiąc, uruchomić plik wykonywalny).

POLECENIE LS -L — WYŚWIETLANIE PRAW DOSTĘPU Kiedy wywołasz polecenie ls z opcją -l oraz nazwą jednego lub więcej plików, polecenie ls wyświetli po jednym wierszu informacji dla każdego pliku (patrz punkt „Wyniki działania polecenia ls” w rozdziale 2., gdzie znajdziesz informacje o formacie wyświetlania wyników polecenia ls przyjętym w naszej książce). W przykładzie przedstawionym poniżej polecenie ls zostało użyte do wyświetlenia informacji o dwóch plikach. Plik o nazwie list.0210 zawiera treść korespondencji, a plik sprawdzanie_pisowni zawiera skrypt powłoki, czyli program napisany w wysokopoziomowym języku programowania powłoki: $ ls -l sprawdzanie_pisowni list.0210 -rwxr-xr-x. 1 mateusz pubs 766 03-21 14:02 sprawdzanie_pisowni -rw-r--r--. 1 mateusz pubs 6193 02-10 14:22 list.0210

Patrząc od lewej do prawej strony, każdy wiersz wyników działania polecenia ls ekranie zawiera następujące informacje (patrz rysunek 4.12):  Typ pliku (pierwszy znak).  Lista praw dostępu do pliku (kolejnych 9 znaków).

-l

wyświetlany na

136  ROZDZIAŁ 4. SYSTEM PLIKÓW

Rysunek 4.12. Kolumny danych wyświetlane przez polecenie ls -l  Flaga listy ACL (obecna, jeżeli plik posiada przypisaną listę ACL).  Liczba dowiązań do tego pliku (patrz sekcja „Dowiązania” w dalszej części tego rozdziału).  Nazwa konta właściciela pliku (zazwyczaj jest to użytkownik, który utworzył dany plik).  Nazwa grupy, z którą dany plik jest powiązany.  Rozmiar pliku w znakach (bajtach).  Data i czas utworzenia lub ostatniej modyfikacji pliku.  Nazwa pliku

W kolumnie Typ pliku o nazwie list.02010 (pierwsza kolumna wyników działania polecenia ls) jest wyświetlany znak myślnika (-), co oznacza, że jest to zwykły plik (dla katalogów w tym miejscu wyświetlana jest litera d, patrz tabela 18.26 w rozdziale 18.). Następne trzy znaki określają prawa dostępu do pliku dla właściciela pliku: r oznacza prawo do odczytu danych z pliku, w oznacza prawo do zapisu danych do pliku, a x oznacza prawo do wykonania pliku. Znak - w którejś z tych kolumn oznacza, że właściciel nie posiada danego prawa do pliku. W podobny sposób kolejne trzy znaki reprezentują prawa dostępu do pliku dla grupy i wreszcie ostatnie trzy znaki reprezentują prawa dostępu dla wszystkich innych użytkowników. W naszym przykładzie właściciel ma prawo czytania i zapisywania pliku list.0201, grupa i inni użytkownicy mogą go tylko czytać, a nikt nie ma prawa do wykonania tego pliku. Choć prawo wykonania pliku może zostać przypisane dowolnemu plikowi, to jednak taka operacja nie ma zupełnie sensu w przypadku plików zawierających takie dokumenty jak list. Z kolei plik sprawdzanie_pisowni jest wykonywalnym skryptem powłoki, stąd prawa do wykonania takiego pliku są w jego przypadku jak najbardziej uzasadnione (właściciel, grupa i inni użytkownicy mają prawo do wykonania tego pliku). Więcej informacji na ten temat znajdziesz w części VI książki.

POLECENIE CHMOD — ZMIANA PRAW DOSTĘPU Schemat praw dostępu do plików w systemie Linux pozwala Ci nadać innym użytkownikom prawa dostępu do plików, którymi chcesz się podzielić, a jednocześnie umożliwia pełną ochronę prywatnych plików przed dostępem osób niepowołanych. W zależności od sytuacji możesz na przykład pozwolić innym użytkownikom na odczytywanie i zapisywanie plików (co jest bardzo wygodne na przykład w sytuacji, kiedy cały zespół użytkowników pracuje nad jednym projektem). W przypadku innych plików możesz zezwolić tylko na odczytywanie zawartości (na przykład plików zawierających specyfikację projektu). Możesz również zezwolić tylko na zapisywanie wybranych plików (podobnie jak w przypadku Twojej skrzynki pocztowej, do której inni użytkownicy mogą wysyłać swoje wiadomości, ale nie mogą z niej odczytywać Twojej poczty). W podobny sposób możesz zabezpieczyć całe katalogi przez odczytywaniem i przeglądaniem (więcej o tym za chwilę).

Prawa dostępu  137

BEZPIECZEŃSTWO Użytkownik z uprawnieniami root ma dostęp do wszystkich plików w systemie Istnieje pewien wyjątek, jeśli chodzi o prawa dostępu opisywane w tej sekcji. Każdy użytkownik, który otrzyma uprawnienia użytkownika root, posiada z definicji pełny dostęp do wszystkich plików, niezależnie od ich właściciela i ustawionych przez niego praw dostępu. Oczywiście jeżeli zawartość pliku jest zaszyfrowana, prawo do odczytu zawartości pliku nie oznacza, że zawartość takiego pliku zostanie automatycznie odszyfrowana. Właściciel pliku określa, którzy użytkownicy mają dostęp do jego plików i na jakim poziomie. Kiedy jesteś właścicielem pliku, możesz użyć polecenia chmod (ang. change mode) do zmiany praw dostępu do wybranego pliku. Polecenie chmod może przyjmować argumenty symboliczne (względne) lub numeryczne (bezwzględne).

ARGUMENTY SYMBOLICZNE POLECENIA CHMOD W przykładzie przedstawionym poniżej wykorzystujemy argumenty symboliczne polecenia chmod do nadania (+) prawa odczytu i zapisu (rw) dla wszystkich (a) użytkowników: $ ls -l list.0210 -rw-r-----. 1 mateusz pubs 6193 02-10 14:22 list.0210 $ chmod a+rw list.0210 $ ls -l list.0210 -rw-rw-rw-. 1 mateusz pubs 6193 02-10 14:22 list.0210

WSKAZÓWKA Aby wykonać skrypt powłoki, musisz mieć prawa do odczytu tego pliku Ponieważ powłoka musi odczytać skrypt powłoki (plik tekstowy zawierający szereg poleceń powłoki) przed wykonaniem poleceń w nim zawartych, to aby wykonać skrypt powłoki, musisz mieć prawa do odczytu jego pliku. Dodatkowo jeżeli chcesz wykonać taki skrypt z poziomu wiersza poleceń powłoki systemu, musisz również posiadać odpowiednie prawa do jego wykonania. W przeciwieństwie do skryptów powłoki binaria (programy) nie muszą być wcześniej odczytywane; zamiast tego są wykonywane bezpośrednio. Aby uruchomić program binarny, wystarczy, że posiadasz tylko prawa do jego wykonania. Za pomocą argumentów symbolicznych polecenia chmod możesz modyfikować istniejące prawa dostępu. Zmiana, jakiej dokonuje dany argument, zależy od istniejących praw dostępu (inaczej mówiąc, zmiana jest robiona względem istniejących praw dostępu). W kolejnym przykładzie polecenie chmod usuwa (-) prawo odczytu (r) i prawo wykonania (x) dla innych użytkowników (o). Prawa właściciela pliku i grupy nie ulegają zmianie: $ ls -l sprawdzanie_pisowni -rwxr-xr-x. 1 mateusz pubs 766 03-21 14:02 sprawdzanie_pisowni $ chmod o-rx sprawdzanie_pisowni $ ls -l sprawdzanie_pisowni -rwxr-x---. 1 mateusz pubs 766 03-21 14:02 sprawdzanie_pisowni

Oprócz argumentów a (ang. all; wszyscy użytkownicy) i o (ang. other; inni, pozostali użytkownicy) możesz używać również takich argumentów jak g (ang. group; grupa) oraz u (ang. user; użytkownik, aczkolwiek w tym kontekście określenie użytkownik odnosi się do właściciela pliku, który może, ale nie musi być użytkownikiem takiego pliku). Na przykład polecenie chmod a+x nadaje prawa wykonania pliku dla wszystkich użytkowników (właściciela, grupy i pozostałych, innych użytkowników), a polecenie chmod go-rwx usuwa wszystkie prawa dostępu wszystkim użytkownikom oprócz właściciela pliku.

138  ROZDZIAŁ 4. SYSTEM PLIKÓW WSKAZÓWKA Polecenie chmod — o dla innych użytkowników, u dla właściciela Korzystając z polecenia chmod, wielu użytkowników zakłada, że argument o oznacza właściciela pliku (ang. owner) — tak się jednak nie dzieje. Argument o pochodzi od ang. other, czyli inni użytkownicy, podczas gdy u pochodzi od ang. user (użytkownik) i oznacza właściciela pliku. Jeżeli chcesz łatwiej zapamiętać znaczenie i kolejność poszczególnych argumentów, powinieneś zapamiętać akronim UGO (ang. user-group-other; użytkownik-grupa-pozostali), który dobrze obrazuje sposób nadawania praw.

ARGUMENTY NUMERYCZNE POLECENIA CHMOD Do określenia listy praw dostępu dla polecenia chmod możesz również użyć argumentów numerycznych. Zamiast z liter i symboli określających poszczególne prawa dostępu w poprzednich przykładach argumenty numeryczne składają się z trzech liczb zapisanych w systemie ósemkowym (czwarta liczba, będąca prefiksem argumentu numerycznego, steruje atrybutami setuid i setgid, o których powiemy za chwilę). Pierwsza cyfra argumentu określa prawa właściciela pliku, druga prawa grupy, a trzecia pozostałych użytkowników. Wartość 1 nadaje prawo do wykonania pliku, wartość 2 prawo zapisu do pliku, a wartość 4 prawo odczytu zawartości pliku. Wartość cyfry reprezentującej wynikowe prawa dla właściciela pliku, grupy i innych użytkowników tworzymy poprzez wykonanie logicznej operacji OR (dodawanie) na wartościach przedstawionych powyżej, tak jak to zostało zilustrowane w kolejnych przykładach. Zastosowanie argumentu numerycznego dla polecenia chmod powoduje bezwzględne ustawienie praw dostępu, inaczej mówiąc, prawa dostępu są ustawiane, a nie modyfikowane, jak to było w przypadku argumentów symbolicznych. W przykładzie przedstawionym poniżej polecenie chmod zmienia prawa dostępu, tak że tylko właściciel pliku może go odczytywać i zapisywać; poprzedni zestaw praw dostępu nie ma tutaj żadnego znaczenia. Cyfra 6 na pierwszej pozycji argumentu numerycznego daje właścicielowi prawo odczytu (4) i zapisu (2). Pozostałe cyfry 0 usuwają wszystkie ewentualnie istniejące do tej pory prawa dostępu dla grupy i dla pozostałych użytkowników: $ chmod 600 list.0210 $ ls -l list.0210 -rw-------. 1 mateusz pubs 6193 02-10 14:22 list.0210

W kolejnym przykładzie cyfra 7 (4 + 2 + 1) na pierwszej pozycji argumentu daje właścicielowi pliku prawo odczytu, zapisu i wykonania pliku. Wartość 5 (4 + 1) na kolejnych pozycjach daje grupie i pozostałym użytkownikom prawa odczytu i wykonania pliku. $ chmod 755 sprawdzanie_pisowni $ ls -l sprawdzanie_pisowni -rwxr-xr-x. 1 mateusz pubs 766 03-21 14:02 sprawdzanie_pisowni

Więcej przykładów argumentów numerycznych zmieniających prawa dostępu znajdziesz w tabeli 4.2. Tabela 4.2. Przykłady argumentów numerycznych zmieniających prawa dostępu Tryb

Znaczenie

777

Właściciel, grupa i pozostali użytkownicy mają prawo odczytu, zapisu i wykonania pliku.

755

Właściciel ma prawo odczytu, zapisu i wykonania pliku, grupa i pozostali użytkownicy mają prawo odczytu i wykonania pliku.

711

Właściciel ma prawo odczytu, zapisu i wykonania pliku, grupa i pozostali użytkownicy mają prawo wykonania pliku.

644

Właściciel ma prawo odczytu i zapisu pliku, grupa i pozostali użytkownicy mają prawo odczytu pliku.

640

Właściciel ma prawo odczytu i zapisu pliku, grupa ma prawo odczytu pliku, a pozostali użytkownicy nie mają żadnego prawa dostępu do pliku.

Prawa dostępu  139

Aby dowiedzieć się, w jaki sposób użyć polecenia chmod do nadania plikowi statusu pliku wykonywalnego, powinieneś zajrzeć do sekcji „Polecenie chmod — tworzenie plików wykonywalnych” w rozdziale 8. Więcej szczegółowych informacji na temat argumentów numerycznych i samego polecenia chmod znajdziesz w części VI książki.

ATRYBUTY SETUID I SETGID — SPECJALNE PRAWA DOSTĘPU Kiedy wykonujesz plik, który ma ustawiony identyfikator użytkownika (ang. setuid — set user ID), proces wykonujący plik pracuje na poziomie uprawnień właściciela pliku. Na przykład: jeżeli uruchomisz program posiadający ustawiony identyfikator setuid, który usuwa wszystkie pliki w katalogu, możesz usunąć pliki w dowolnym katalogu właściciela tego pliku, nawet jeżeli normalnie nie posiadasz uprawnień do wykonania takiego zadania. Analogicznie ustawienie identyfikatora grupy (ang. setgid — set group ID) daje procesowi wykonującemu plik prawa grupy, z którą powiązany jest wykonywany plik.

BEZPIECZEŃSTWO Ograniczaj do minimum korzystanie z programów z ustawionymi atrybutami setuid i setgid, których właścicielem jest root. Wszystkie pliki wykonywalne, których właścicielem jest użytkownik root i które posiadają ustawiony atrybut setuid, po uruchomieniu posiadają prawa użytkownika root, nawet jeżeli zostały uruchomione przez innego użytkownika. Taki rodzaj programów zapewnia duże uprawnienia, ponieważ za ich pomocą można zrobić to wszystko, co może zrobić użytkownik root (oczywiście wszystko zależy od tego, do jakich celów został zaprojektowany dany program). W podobny sposób wszystkie pliki wykonywalne, które należą do grupy root i posiadają ustawiony atrybut setgid, posiadają po uruchomieniu rozszerzony zestaw uprawnień. Ze względu na ogromne możliwości takich programów i potencjalne szkody, jakie może spowodować ich nieostrożne użycie, warto unikać niepotrzebnego, nieprzemyślanego tworzenia programów posiadających ustawiony atrybut setuid, których właścicielem jest użytkownik root, oraz programów z ustawionym atrybutem setgid należących do grupy root. Ze względu na potencjalne zagrożenia związane z ich stosowaniem wiele systemów ogranicza ich użycie. Jednym z programów, który musi funkcjonować z ustawionym atrybutem setuid, jest polecenie passwd. Przykład zamieszczony poniżej pokazuje użytkownika pracującego z uprawnieniami root i używającego polecenia chmod z argumentami symbolicznymi do nadania jednemu z programów atrybutu setuid oraz innemu programowi atrybutu setgid. Wyniki działania polecenia ls -l potwierdzają nadanie atrybutu setuid, wyświetlając literkę s w kolumnie prawa wykonania dla właściciela pliku, oraz atrybutu setgid, wyświetlając literkę s w kolumnie prawa wykonania dla grupy: # ls -l mójprogram* -rwxr-xr-x. 1 root pubs -rwxr-xr-x. 1 root pubs # chmod u+s mójprogram1 # chmod g+s mójprogram2 # ls -l mójprogram* -rwsr-xr-x. 1 root pubs -rwxr-sr-x. 1 root pubs

362804 03-21 15:38 mójprogram1 189960 03-21 15:38 mójprogram2

362804 03-21 15:38 mójprogram1 189960 03-21 15:38 mójprogram2

W kolejnym przykładzie używamy argumentów numerycznych polecenia chmod do dokonania takich samych zmian jak w poprzednim przykładzie. Kiedy do określenia praw dostępu używamy czterech cyfr, nadanie pierwszej cyfrze wartości 1 ustawia tzw. bit lepkości (ang. sticky bit), wartości 2 ustawia atrybut setgid, a wartości 4 ustawia atrybut setuid: # ls -l mójprogram* -rwxr-xr-x. 1 root pubs 362804 -rwxr-xr-x. 1 root pubs 189960 # chmod 4755 mójprogram1 # chmod 2755 mójprogram2 # ls -l mójprogram* -rwsr-xr-x. 1 root pubs 362804 -rwxr-sr-x. 1 root pubs 189960

03-21 15:38 mójprogram1 03-21 15:38 mójprogram2

03-21 15:38 mójprogram1 03-21 15:38 mójprogram2

140  ROZDZIAŁ 4. SYSTEM PLIKÓW BEZPIECZEŃSTWO Nigdy nie nadawaj skryptom powłoki atrybutu setuid Nigdy nie powinieneś nadawać skryptom powłoki atrybutu setuid. Istnieje kilka dobrze znanych technik wykorzystania takich skryptów do przełamania zabezpieczeń systemu.

PRAWA DOSTĘPU DO KATALOGÓW Poszczególne prawa dostępu w przypadku katalogów nieco zmieniają znaczenie. Choć trzy wymieniane wcześniej typy użytkowników mogą odczytywać z katalogu i zapisywać dane do katalogu, to jednak nie można już „wykonać” katalogu. Z tego powodu prawo wykonania w przypadku katalogów zostało nieco przedefiniowane i oznacza, że użytkownik posiadający takie prawo może przejść do tego katalogu poleceniem cd i (lub) przeglądać pliki, do których ma prawo odczytu. Jak widać, nie ma to nic wspólnego z wykonywaniem plików. Jeżeli dla danego katalogu posiadasz tylko prawo wykonania, możesz użyć polecenia ls do wyświetlenia informacji o pliku (plikach) znajdujących się w tym katalogu (pod warunkiem że znasz ich nazwy). Nie możesz użyć polecenia ls do wyświetlenia listy wszystkich plików znajdujących się w tym katalogu. W przykładzie przedstawionym poniżej użytkownik dawid najpierw sprawdza, czy jest zalogowany na swoim koncie użytkownika, następnie sprawdza uprawnienia na katalogu info znajdującym się w katalogu domowym użytkownika kuba. Aby sprawdzić prawa dostępu do katalogów, możesz użyć polecenia ls z opcjami -d (ang. directory) oraz -l (ang. long): $ who am i dawid pts/7 2011-07-21 10:02 $ ls -ld /home/kuba/info drwx-----x. 2 kuba pubs 4096 08-21 09:31 /home/kuba/info $ ls -l /home/kuba/info ls: nie można otworzyć katalogu /home/kuba/info: Brak dostępu

Literka d z lewej strony wiersza informacji wyświetlanego przez polecenie ls wskazuje, że /home/kuba/info jest katalogiem. Użytkownik kuba posiada prawo odczytu, zapisu i wykonania; członkowie grupy pubs nie mają żadnych praw dostępu, a pozostali użytkownicy mają tylko prawo wykonania (co pokazuje literka x na końcu ciągu znaków reprezentującego prawa dostępu). Ponieważ użytkownik dawid nie ma prawa odczytu z tego katalogu, polecenie ls -l wyświetla komunikat o wystąpieniu błędu. Jeżeli użytkownik dawid określi nazwę pliku, o którym chce uzyskać informacje, polecenie ls wyświetli żądane informacje. Dzieje się tak dlatego, że w ten sposób dawid nie odczytuje informacji o całej zawartości katalogu, ale tylko przegląda informacje o wybranych plikach — taką możliwość daje mu posiadane prawo wykonania katalogu. Użytkownik dawid posiada również prawo odczytu pliku o nazwie notatki, dzięki czemu do wyświetlenia zawartości tego pliku może bez problemu użyć polecenia cat; dawid nie może jednak wyświetlić zawartości pliku raport_finansowy, ponieważ nie posiada prawa odczytu tego pliku: $ ls -l /home/kuba/info/raport_finansowy /home/kuba/info/notatki -rw-------. 1 kuba pubs 34 08-21 09:31 /home/kuba/info/raport_finansowy -rw-r--r--. 1 kuba pubs 30 08-21 09:32 /home/kuba/info/notatki $ cat /home/kuba/info/notatki To jest zawartość pliku o nazwie notatki. $ cat /home/kuba/info/raport_finansowy cat: /home/kuba/info/raport_finansowy: Brak dostępu.

Nieco później użytkownik kuba nadaje wszystkim pozostałym użytkownikom prawo odczytu do katalogu info: $ chmod o+r /home/kuba/info

ACL — lista kontroli dostępu  141

Kiedy dawid sprawdza, jakie ma prawa dostępu do katalogu info, dowiaduje się, że posiada zarówno prawo odczytu, jak i wykonania tego katalogu. Teraz wykonanie polecenia ls -ld wyświetla zawartość katalogu info, ale dawid nadal nie może odczytywać zawartości pliku raport_finansowy (ograniczenie to jest związane z prawami dostępu do pliku, a nie z prawami do katalogu). Wreszcie na koniec użytkownik dawid próbuje utworzyć przy użyciu polecenia touch (patrz rozdział 18.) plik o nazwie nowyplik. Jeżeli użytkownik kuba nadałby użytkownikowi dawid prawa zapisu w katalogu info, to wtedy dawid mógłby w nim tworzyć nowe pliki. $ ls -ld /home/kuba/info drwx---r-x. 2 kuba pubs 4096 08-21 09:31 /home/kuba/info $ ls -l /home/kuba/info -rw-------. 1 kuba pubs 34 08-21 09:31 raport_finansowy -rw-r--r--. 1 kuba pubs 30 08-21 09:32 notatki $ cat /home/kuba/info/raport_finansowy cat: raport_finansowy: Brak dostępu $ touch /home/kuba/info/nowyplik touch: nie można dotknąć '/home/kuba/info/nowyplik': Brak dostępu

ACL — LISTA KONTROLI DOSTĘPU ACL (ang. Access Control List), czyli lista kontroli dostępu, zapewnia znacznie bardziej rozbudowaną i dokładną kontrolę dostępu do plików w porównaniu ze standardowymi uprawnieniami w systemie Linux (patrz nieco wcześniej w rozdziale). Zastosowanie list ACL pozwala na szczegółowe zdefiniowanie poziomu dostępu do plików i katalogów dla poszczególnych użytkowników. Ponieważ zastosowanie list ACL może mieć pewien wpływ na zmniejszenie wydajności systemu, nie powinieneś włączać list ACL w systemach plików przechowujących pliki systemowe, gdzie tradycyjne linuksowe prawa dostępu są w zupełności wystarczające. Powinieneś również uważać podczas kopiowania, przenoszenia i archiwizowania plików — nie wszystkie narzędzia radzą sobie z zachowaniem list ACL podczas wykonywania takich operacji. Pamiętaj także, że nie możesz kopiować plików z listami ACL do systemów plików, które takich list nie obsługują. Lista ACL składa się z zestawu reguł. Poszczególne reguły określają, jaki poziom dostępu do pliku posiada dany użytkownik czy grupa. Istnieją dwa rodzaje reguł: reguły dostępu (ang. access rules) oraz reguły domyślne (ang. default rules) — w dokumentacji systemu jest mowa co prawda o listach access ACL oraz default ACL, aczkolwiek wyróżniamy tylko jeden rodzaj list ACL. Inaczej mówiąc, istnieje jeden typ list ACL i dwa rodzaje reguł, które na takich listach mogą się znajdować. Reguła dostępu zawiera informacje o prawach dostępu dla pojedynczego pliku lub katalogu. Domyślne reguły ACL odnoszą się tylko do katalogów i określają domyślne prawa dostępu dla wszystkich plików w katalogu, dla których nie zostały zdefiniowane szczegółowe listy ACL.

OSTRZEŻENIE Większość narzędzi nie zachowuje list ACL Jeżeli użyjesz polecenia cp z opcją -p (ang. preserve) lub -a (ang. archive), to podczas kopiowania plików listy ACL zostaną zachowane. Polecenie mv również zachowuje listy ACL. Jeżeli polecenie cp wywołane z opcją -p lub -a nie jest w stanie podczas kopiowania plików zachować list ACL (dotyczy to również polecenia mv), to mimo to operacja zostaje wykonana, ale na ekranie wyświetlany jest komunikat o wystąpieniu błędu: $ mv raport /tmp mv: zachowanie uprawnień dla '/tmp/raport': Operacja nie jest obsługiwana

Inne narzędzia, takie jak tar, cpio i dump, nie obsługują list ACL. Aby skopiować struktury katalogów razem z listami ACL, powinieneś użyć polecenia cp z opcją -a. Nie możesz skopiować list ACL do systemu plików, który ich nie obsługuje, lub do systemu plików, w którym obsługa list ACL nie została włączona.

142  ROZDZIAŁ 4. SYSTEM PLIKÓW

WŁĄCZANIE OBSŁUGI LIST ACL Poniżej przedstawiono informacje o sposobie włączenia obsługi list ACL w systemie Linux. Jeżeli używasz systemu OS X, zapoznaj się z dodatkiem D. Zanim będziesz mógł korzystać z list ACL, musisz zainstalować pakiet oprogramowania o nazwie acl. Oficjalnie większość dystrybucji systemu Linux obsługuje listy ACL tylko w systemach plików ext2, ext3 oraz ext4, aczkolwiek nieformalna obsługa list ACL jest dostępna również w innych systemach plików. Aby skorzystać z list ACL w systemie plików ext2, ext3 lub ext4, musisz zamontować dane urządzenie z opcją acl (domyślnie wybierana jest opcja no_acl). Na przykład: jeżeli chcesz zamontować urządzenie reprezentowane przez /home tak, aby można było korzystać z list ACL dla plików w katalogach domowych, powinieneś dodać opcję acl do listy opcji w pliku /etc/fstab: $ grep home /etc/fstab LABEL=/home /home

ext4

defaults,acl

1 2

Zanim będziesz mógł korzystać z list ACL po zmianie wpisów w pliku fstab, musisz ponownie zamontować wolumin /home. Jeżeli nikt oprócz Ciebie nie korzysta z systemu, możesz odmontować i zamontować go ponownie (pracując na poziomie uprawnień użytkownika root), pod warunkiem że bieżący katalog roboczy nie znajduje się w hierarchii woluminu /home. Zamiast tego możesz również użyć opcji remount polecenia mount do ponownego zamontowania woluminu /home będącego w użyciu:

Opcja remount

# mount -v -o remount /home /dev/sda3 on /home type ext4 (rw,acl)

PRACA Z REGUŁAMI DOSTĘPU Polecenie setfacl modyfikuje listę ACL pliku, a polecenie getfacl wyświetla aktualną listę ACL danego pliku. Wymienione narzędzie jest dostępne jedynie w systemie Linux. Jeżeli używasz OS X, to musisz użyć polecenia chmod, jak przedstawiono w dodatku D. Kiedy użyjesz polecenia getfacl do wyświetlenia informacji o pliku, który nie posiada przypisanej listy ACL, polecenie wyświetla takie same informacje jak polecenie ls -a, aczkolwiek w nieco innym formacie: $ ls -l raport -rw-r--r--. 1 kuba pubs 9537 01-12 23:17 raport $ getfacl raport # file: raport # owner: kuba # group: pubs user::rwgroup::r-other::r--

Pierwsze trzy wiersze wyników działania polecenia getfacl tworzą nagłówek, w którym wyświetlana jest nazwa pliku, właściciel pliku oraz grupa, z którą dany plik jest powiązany. Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Polecenie ls -l — wyświetlanie praw dostępu” we wcześniejszej części tego rozdziału. Jeżeli użyjesz polecenia getfacl z opcją --omit-header (lub po prostu w skrócie --omit), wiersze nagłówka nie będą wyświetlane: $ getfacl --omit-header report user::rwgroup::r-other::r--

W wierszu, który rozpoczyna się od słowa user, dwa znaki dwukropka (::) bez żadnych innych znaków między nimi oznaczają, że wiersz definiuje prawa dostępu dla właściciela pliku. Podobnie dwa znaki dwukropka w wierszu group oznaczają, że ten wiersz definiuje prawa dostępu dla grupy. Pamiętaj jednak, że dwa znaki dwukropka w wierszu other zostały tam umieszczone tylko i wyłącznie dla zachowania spójności zapisu — żadna nazwa nie może być powiązana z grupą other.

ACL — lista kontroli dostępu  143

Polecenie setfacl --modify (lub -m) pozwala na dodanie lub modyfikację jednej lub więcej reguł z listy ACL danego pliku. Format polecenia jest następujący: setfacl --modify ugo:nazwa:prawa lista-plików

gdzie ugo może być jedną z liter u, g lub o (dla wskazania, że polecenie będzie modyfikowało listę ACL dla odpowiednio użytkownika, grupy lub pozostałych użytkowników), nazwa to nazwa użytkownika lub grupy, dla których definiujemy uprawnienia, prawa to lista praw dostępu w formacie symbolicznym lub bezwzględnym i wreszcie lista-plików to lista plików, dla których definiujemy prawa dostępu. Jeżeli definiujesz prawa dla pozostałych użytkowników (o), musisz pominąć argument nazwa. Lista uprawnień w formacie symbolicznym do określenia praw dostępu wykorzystuje litery (rwx, r-x i tak dalej), podczas gdy uprawnienia w formacie bezwzględnym używają liczb zapisanych w formacie ósemkowym. Jak pamiętasz, polecenie chmod wykorzystuje trzy zestawy uprawnień lub trzy liczby ósemkowe (po jednej dla właściciela, grupy i innych użytkowników), polecenie setfacl wykorzystuje pojedynczy zestaw uprawnień lub pojedynczą liczbę ósemkową, reprezentujące prawa dostępu dla użytkownika lub grupy reprezentowanych przez argumenty ugo oraz nazwa. Więcej szczegółowych informacji na temat polecenia chmod znajdziesz w sekcji „Polecenie chmod — zmiana praw dostępu” we wcześniejszej części tego rozdziału, natomiast o symbolicznej lub bezwzględnej reprezentacji praw dostępu umieszczono w części VI książki. Na przykład oba polecenia przedstawione poniżej dodają regułę do listy ACL pliku raport, która nadaje użytkownikowi mateusz prawo odczytu i zapisu: $ setfacl --modify u:mateusz:rw- raport

lub $ setfacl --modify u:mateusz:6 raport $ getfacl raport # file: raport # owner: kuba # group: pubs user::rwuser:mateusz:rwgroup::r-mask::rwother::r--

Wiersz user:mateusz:rw- wskazuje, że użytkownik mateusz posiada prawo odczytu i zapisu (rw-) pliku. Więcej szczegółowych informacji na temat oznaczania praw dostępu znajdziesz w sekcji „Prawa dostępu” we wcześniejszej części tego rozdziału. Więcej szczegółowych informacji na temat wiersza rozpoczynającego się od znacznika mask znajdziesz w ramce „Informacje dodatkowe — maska uprawnień efektywnych”. Kiedy dany plik posiada przypisaną listę ACL, polecenie ls — dzieje się tak, nawet jeżeli lista ACL jest pusta: $ ls -l raport -rw-rw-r--+ 1 kuba

-l

wyświetla po liście praw znak plus (+)

pubs 9537 01-12 23:17 raport

Jak pokazuje kolejny przykład, polecenie setfacl może zostać użyte do zmodyfikowania reguł listy ACL. Warto zauważyć, że za pomocą tego polecenia można definiować więcej niż jedną regułę naraz: $ setfacl -m u:mateusz:r--,u:dawid:rw- raport $ getfacl --omit-header raport user::rwuser:mateusz:r-user:dawid:rwgroup::r-mask::rwother::r--

144  ROZDZIAŁ 4. SYSTEM PLIKÓW INFORMACJE DODATKOWE MASKA UPRAWNIEŃ EFEKTYWNYCH Wiersz wyników działania polecenia getfacl, rozpoczynający się od znacznika mask, określa maskę uprawnień efektywnych. Taka maska może ograniczać efektywne prawa dostępu do pliku nadawane grupom i użytkownikom z listy ACL, nie ma jednak żadnego wpływu na prawa właściciela pliku i grupy, z którą plik jest powiązany — inaczej mówiąc, maska nie ma żadnego wpływu na tradycyjne, linuksowe prawa dostępu. Ponieważ jednak polecenie setfacl zawsze ustawia maskę uprawnień efektywnych na najmniej restrykcyjne uprawnienia z listy ACL, maska sama z siebie nie daje żadnego efektu, dopóki nie zostanie wprost ustawiona po zdefiniowaniu listy ACL dla pliku. Maskę uprawnień możesz zdefiniować, umieszczając zamiast argumentu ugo słowo mask (w takiej sytuacji musisz również pominąć w wywołaniu polecenia setfacl argument nazwa). Polecenie przedstawione poniżej ustawia maskę efektywnych uprawnień dla pliku raport na prawo tylko do odczytu: $ setfacl -m mask::r-- raport

Na poniższym przykładzie wiersz ze znacznikiem mask pokazuje, że efektywne prawa dostępu do pliku zostały ograniczone do odczytu (r--). W wierszu definiującym prawa użytkownika mateusz nadal widać, że posiada on prawo odczytu i zapisu, jednak komentarz po prawej stronie tego wiersza precyzuje, że efektywne prawa tego użytkownika zostały ograniczone tylko do odczytu: $ getfacl raport # file: raport # owner: kuba # group: pubs user::rwuser:mateusz:rwgroup::r-mask::r-other::r--

#effective:r--

Opcja -x usuwa z listy ACL reguły dla danego użytkownika lub grupy. Użycie tej opcji nie ma żadnego wpływu na prawa dostępu właściciela pliku lub grupy, z którą plik jest powiązany. W kolejnym przykładzie polecenie setfacl zostało użyte do usunięcia reguły nadającej użytkownikowi mateusz dostęp do pliku: $ setfacl -x u:mateusz raport $ getfacl --omit-header raport user::rwuser:dawid:rwgroup::r-mask::rwother::r--

Kiedy używasz opcji -x, nie możesz określać uprawnień. Zamiast tego powinieneś podać tylko argument ugo i nazwa. Opcja -b, po której następuje tylko nazwa pliku, powoduje usunięcie wszystkich reguł oraz całej listy ACL z danego pliku lub katalogu. Zarówno polecenie setfacl, jak i getfacl posiadają wiele opcji. Aby wyświetlić krótki opis dostępnych opcji, powinieneś wywołać te polecenia z opcją --help lub zajrzeć na strony podręcznika man tych poleceń.

DEFINIOWANIE REGUŁ DOMYŚLNYCH DLA KATALOGU Katalog przedstawiony na poniższym przykładzie początkowo nie posiada żadnej listy ACL. Polecenie setfacl wykorzystuje opcję -d (ang. default) do dodania dwóch reguł domyślnych do listy ACL katalogu dir. Utworzone reguły mają zastosowanie do wszystkich plików znajdujących się w katalogu dir, które nie mają własnych list ACL. Reguły nadają członkom grupy pubs prawa odczytu i wykonania, a członkom grupy adm prawa odczytu, zapisu i wykonania.

ACL — lista kontroli dostępu  145

$ ls -ld dir drwx------. 2 kuba pubs 4096 02-12 23:15 dir $ getfacl dir # file: dir # owner: kuba # group: pubs user::rwx group::--other::--$ setfacl -d -m g:pubs:r-x,g:adm:rwx dir

Wyniki działania polecenia ls przedstawione poniżej pokazują, że katalog dir posiada teraz listę ACL (po prawej stronie listy praw wyświetlany jest znak +). Każda z domyślnych reguł listy ACL, wyświetlanych poleceniem getfacl, rozpoczyna się od ciągu znaków default:. Pierwsze dwie reguły domyślne oraz ostatnia reguła domyślna definiują prawa dostępu dla właściciela pliku, dla grupy, z którą plik jest powiązany, oraz dla pozostałych użytkowników. Wymienione trzy reguły definiują tradycyjne prawa dostępu i mają pierwszeństwo przed regułami listy ACL. Reguły trzecia i czwarta określają prawa dostępu dla grup pubs i adm, a następna, piąta z kolei reguła definiuje maskę uprawnień efektywnych. $ ls -ld dir drwx------+ 2 kuba pubs 4096 02-12 23:15 dir $ getfacl dir # file: dir # owner: kuba # group: pubs user::rwx group::--other::--default:user::rwx default:group::--default:group:pubs:r-x default:group:adm:rwx default:mask::rwx default:other::---

Pamiętaj, że reguły domyślne mają zastosowanie do plików przechowywanych w danym katalogu, które nie mają przypisanych własnych dedykowanych list ACL. Osobne reguły dostępu możesz również zdefiniować dla samego katalogu. Kiedy w katalogu posiadającym listę ACL z regułami domyślnymi tworzysz nowy plik, maska efektywnych uprawnień dla tego pliku jest tworzona na bazie tradycyjnych praw dostępu do tego pliku. W niektórych przypadkach maska może nadpisać domyślne reguły listy ACL. W kolejnym przykładzie polecenie touch zostało użyte do utworzenia w katalogu dir pliku o nazwie nowy. Wyniki działania polecenia ls pokazują, że utworzony plik posiada listę ACL. W oparciu o wartość maski umask (patrz rozdział 18.) zarówno właściciel pliku, jak i grupa powiązana z plikiem otrzymują prawa odczytu i zapisu do pliku. Maska uprawnień jest ustawiona na prawo odczytu i zapisu, zatem efektywnie grupa pubs posiada prawo odczytu, a grupa adm prawa odczytu i zapisu. Żadna z grup nie posiada prawa wykonania pliku. $ cd dir $ touch nowy $ ls -l nowy -rw-rw----+ 1 kuba pubs 0 02-13 00:39 nowy $ getfacl --omit nowy user::rwgroup::--group:pubs:r-x #effective:r-group:adm:rwx #effective:rwmask::rwother::---

146  ROZDZIAŁ 4. SYSTEM PLIKÓW Jeżeli zmienisz tradycyjne prawa dostępu do tego pliku na prawo odczytu, zapisu i wykonania dla właściciela i grupy, maska uprawnień efektywnych zmieni się na odczyt, zapis i wykonanie, a grupy zdefiniowane w domyślnych regułach listy ACL otrzymają prawa wykonania pliku. $ chmod 770 nowy $ ls -l nowy -rwxrwx---+ 1 kuba pubs 0 02-13 00:39 nowy $ getfacl --omit nowy user::rwx group::--group:pubs:r-x group:adm:rwx mask::rwx other::---

DOWIĄZANIA Dowiązanie (ang. link) jest wskaźnikiem do pliku. Za każdym razem, kiedy tworzysz plik przy użyciu polecenia vim, touch, cp czy innych sposobów, umieszczasz w katalogu wskaźnik, który łączy nazwę pliku z miejscem na dysku, w którym przechowywane są dane. Kiedy w poleceniu podajesz nazwę pliku, pośrednio wskazujesz miejsce na dysku, w którym znajdują się interesujące Cię informacje. Współużytkowanie plików może być użyteczne na przykład w sytuacji, kiedy dwóch lub więcej użytkowników pracuje nad tym samym projektem i musi wymieniać między sobą informacje. Tworząc dodatkowe dowiązania do wybranych plików, możesz ułatwić innym użytkownikom korzystanie z tych plików. Aby udostępnić wybrany plik innemu użytkownikowi, najpierw powinieneś nadać takiemu użytkownikowi prawa odczytu i zapisu do pliku (patrz nieco wcześniej w rozdziale). Możesz również zmienić prawa dostępu do katalogu, w którym znajduje się plik, tak aby użytkownik miał prawo odczytu, zapisu lub wykonania (patrz nieco wcześniej w rozdziale). Kiedy prawa zostaną już odpowiednio przydzielone, użytkownik może utworzyć dowiązanie do pliku, tak że każdy z użytkowników będzie mógł dostać się do tego pliku z osobnej hierarchii katalogów. Dowiązania mogą być również bardzo przydatne dla pojedynczych użytkowników, posiadających bardzo rozbudowane struktury katalogów. Dzięki tworzeniu dowiązań możesz dokonywać złożonej klasyfikacji skrośnej plików w hierarchii katalogów, używając różnych kryteriów klasyfikacji dla różnych zadań. Na przykład: jeżeli korzystasz z układu plików i katalogów przedstawionego na rysunku 4.2, plik o nazwie lista_zadań może znajdować się w każdym z podkatalogów katalogu korespondencja: osobiste, notatki i biznes. Jeżeli organizacja i śledzenie wszystkich zadań do wykonania sprawia Ci kłopoty, możesz w katalogu korenspondencja utworzyć osobny katalog o nazwie lista_zadań. Następnie możesz utworzyć dowiązania poszczególnych podkatalogów do tego katalogu. Na przykład możesz utworzyć dowiązanie pliku lista_zadań znajdującego się w katalogu notatki do pliku notatki znajdującego się w katalogu lista_zadań. Taki zestaw dowiązań został przedstawiony na rysunku 4.13.

Rysunek 4.13. Zastosowanie dowiązań do klasyfikacji skrośnej plików

Dowiązania  147

Choć przedstawione rozwiązanie może się wydawać nieco złożone, taka technika pozwala na utrzymywanie wszystkich list zadań do wykonania wygodnie w jednym miejscu. Jednak kiedy pracujesz nad tworzeniem listów, pisaniem notatek czy zajmujesz się sprawami osobistymi, poprzez dowiązanie odpowiednia lista zadań jest dostępna w katalogu danego zadania.

WSKAZÓWKA Kilka słów o dowiązaniach twardych Istnieją dwa rodzaje dowiązań: dowiązania twarde (ang. hard links) oraz dowiązania symboliczne (ang. soft links). Dowiązania twarde są rozwiązaniem dużo starszym i pomału wychodzącym już dziś z użycia. Cała sekcja opisująca dowiązania twarde została oznaczona jako materiał dodatkowy (opcjonalny), zatem możesz go spokojnie pominąć (aczkolwiek materiał ten porusza zagadnienia związane z i-węzłami oraz daje Ci pewien wgląd w wewnętrzną strukturę systemu plików).

INFORMACJE DODATKOWE DOWIĄZANIA TWARDE Dowiązanie twarde w katalogu wygląda po prostu jak kolejny plik. Jeżeli plik docelowy znajduje się w tym samym katalogu co plik dowiązania, dowiązanie musi mieć inną nazwę, ponieważ w jednym katalogu nie mogą się znajdować dwa pliki o tej samej nazwie. Dowiązanie twarde do pliku możesz utworzyć wyłącznie w systemie plików, w którym znajduje się plik docelowy.

POLECENIE LN — TWORZENIE DOWIĄZAŃ TWARDYCH Polecenie ln (ang. link) użyte bez opcji -s (lub --symbolic) tworzy dowiązanie twarde do istniejącego pliku. Składania polecenia jest następująca: ln istniejący-plik nowe-dowiązanie

W przykładzie zamieszczonym poniżej użytkownik dawid tworzy dowiązanie przedstawione na rysunku 4.14 poprzez utworzenie nowego dowiązania o nazwie /home/kuba/list do istniejącego pliku o nazwie wersja_robocza, znajdującego się w katalogu domowym użytkownika dawid: $ pwd /home/dawid $ ln wersja_robocza /home/kuba/list

Rysunek 4.14. Dwa dowiązania do tego samego pliku: /home/kuba/list oraz /home/dawid/wersja_robocza

148  ROZDZIAŁ 4. SYSTEM PLIKÓW

Nowe dowiązanie pojawi się w katalogu domowym użytkownika kuba i będzie miało nazwę list. W rzeczywistości użytkownik kuba prawdopodobnie będzie musiał zmienić prawa dostępu do swojego katalogu domowego, tak aby użytkownik dawid mógł utworzyć w nim dowiązanie. Pomimo że dowiązanie pojawi się w katalogu domowym użytkownika kuba, to jednak jego właścicielem pozostaje dawid, ponieważ to on utworzył plik dowiązania. Polecenie ln tworzy dodatkowy wskaźnik do istniejącego pliku, ale nie tworzy kopii tego pliku. Ponieważ istnieje tylko jedna kopia pliku, informacje o pliku — takie jak prawa dostępu, właściciel czy czas ostatniej modyfikacji — będą takie same dla wszystkich dowiązań, różne będą tylko nazwy dowiązań. Na przykład: kiedy użytkownik dawid dokona zmian w pliku /home/dawid/wersja_robocza, to użytkownik kuba zobaczy u siebie zmiany w pliku /home/kuba/list.

POLECENIE CP KONTRA POLECENIE LN Sekwencja poleceń przedstawiona poniżej potwierdza, że polecenie ln nie tworzy dodatkowej kopii pliku. W przykładzie najpierw tworzymy nowy plik, potem używamy polecenia ln do utworzenia dowiązania, zmieniamy zawartość pliku poprzez dowiązanie i sprawdzamy, czy zmieniła się zawartość oryginalnego pliku: $ cat plik_a To jest plik A. $ ln plik_a plik_b $ cat plik_b To jest plik A. $ vim plik_b ... $ cat plik_b To jest plik B po dokonaniu modyfikacji. $ cat plik_a To jest plik B po dokonaniu modyfikacji.

Jeżeli spróbujesz dokonać takiego samego eksperymentu, używając polecenia cp zamiast polecenia ln, i dokonasz modyfikacji kopii pliku, to różnica zawartości tych dwóch plików stanie się natychmiast widoczna. Po dokonaniu zmian w kopii pliku zawartość obu plików jest różna: $ cat plik_c To jest plik C. $ cp plik_c plik_d $ cat plik_d To jest plik C. $ vim plik_d ... $ cat plik_d To jest plik D po dokonaniu modyfikacji. $ cat plik_c To jest plik C.

Polecenia ls z opcją -l, po której następuje lista plików, możesz użyć do potwierdzenia, że informacje o plikach są identyczne w przypadku plików dowiązanych, a różne w przypadku plików, które nie są ze sobą związane. W przykładzie przedstawionym poniżej liczba 2 w kolumnie dowiązań (po lewej stronie nazwy właściciela pliku, którym jest kuba) informuje, że do plików plik_a oraz plik_b utworzone są po dwa dowiązania (z poprzedniego przykładu):

Polecenie ls a liczba dowiązań

$ ls -l plik_a plik_b plik_c plik_d -rw-r--r--. 2 kuba pubs 33 05-24 10:52 -rw-r--r--. 2 kuba pubs 33 05-24 10:52 -rw-r--r--. 1 kuba pubs 16 05-24 10:55 -rw-r--r--. 1 kuba pubs 33 05-24 10:57

plik_a plik_b plik_c plik_d

Choć w tym przykładzie łatwo odgadnąć, które pliki są ze sobą powiązane, to jednak polecenie ls nie pokazuje tego wprost.

Dowiązania  149

Użycie polecenia ls z opcją -i w niedwuznaczny sposób pokazuje, które pliki są ze sobą powiązane. Opcja -i powoduje wyświetlenie numerów i-węzłów (ang. inode) poszczególnych plików. I-węzeł jest strukturą kontrolną używaną do opisu plików. (HFS+, czyli domyślny system plików w OS X, nie zawiera i-węzłów, ale dzięki jego schematowi wydaje się, że je posiada). Jeżeli dwie nazwy plików mają taki sam numer i-węzła, to znaczy, że korzystają z tej samej struktury kontrolnej pliku i są dowiązaniami do tego samego pliku. W przeciwnej sytuacji, kiedy dwie nazwy plików mają różne numery i-węzłów, to znaczy, że są to dwa różne pliki. W przykładzie przedstawionym poniżej wyraźnie widać, że pliki o nazwach plik_a oraz plik_b mają taki sam numer i-węzła, a pliki o nazwach plik_c oraz plik_d mają różne numery i-węzłów:

Polecenie ls a i-węzły

$ ls -i plik_a plik_b plik_c plik_d 3534 plik_a 3534 plik_b 5800 plik_c 7328 plik_d

Wszystkie dowiązania do plików są tak samo ważne — system operacyjny nie jest w stanie rozpoznać kolejności, w jakiej były tworzone poszczególne dowiązania do tego samego pliku. Jeżeli do danego pliku zostały utworzone dwa dowiązania, możesz usunąć jedno z nich i nadal mieć dostęp do pliku za pośrednictwem drugiego dowiązania. Na przykład możesz usunąć dowiązanie, za pomocą którego utworzyłeś plik, a mimo to możesz nadal korzystać z tego pliku dopóty, dopóki pozostało choć jedno dowiązanie do tego pliku. Dopiero usunięcie ostatniego dowiązania twardego powoduje usunięcie pliku z dysku.

DOWIĄZANIA SYMBOLICZNE Oprócz dowiązań twardych system Linux potrafi również obsługiwać dowiązania symboliczne (ang. symbolic links lub symlink), nazywane również dowiązaniami miękkimi (ang. soft links). Dowiązanie twarde jest wskaźnikiem do pliku (pozycja w katalogu bezpośrednio wskazująca dany i-węzeł), podczas gdy dowiązania symboliczne są pośrednim wskaźnikiem do pliku (inaczej mówiąc, jest to wpis w katalogu zawierający ścieżkę do pliku będącego twardym dowiązaniem do pliku). Odwołanie do dowiązania symbolicznego oznacza odniesienie się do pliku wskazywanego przez dane dowiązanie, a nie pracę z samym dowiązaniem. Więcej informacji na temat odwoływania się do dowiązań symbolicznych znajdziesz w dalszej części rozdziału.

Odwoływanie się do dowiązań symbolicznych

Dowiązania symboliczne zostały opracowane ze względu na ograniczenia, jakie niosło ze sobą stosowanie dowiązań twardych. Na przykład nie możesz utworzyć dowiązania twardego do katalogu, ale bez problemu możesz utworzyć do niego dowiązanie symboliczne.

Zalety dowiązań symbolicznych

Bardzo często w strukturze plików systemów linuksowych można spotkać kilka systemów plików. Ponieważ każdy z systemów plików przechowuje struktury kontrolne (na przykład tablice i-węzłów czy innych struktur systemu plików) tylko własnych plików, tworzenie dowiązań twardych pomiędzy plikami rezydującymi na różnych systemach plików po prostu nie jest możliwe. Z kolei dowiązanie symboliczne może wskazywać na dowolny plik, niezależnie od jego położenia w strukturze plików. Kiedy tworzysz dowiązania wyłącznie pomiędzy plikami w obrębie Twojego katalogu domowego, to po prostu nie zauważysz tego ograniczenia. Ogromną zaletą dowiązań symbolicznych jest to, że mogą wskazywać na nieistniejący plik. Taka możliwość jest bardzo przydatna na przykład w sytuacji, kiedy potrzebujesz dowiązania do pliku, który jest okresowo usuwany i tworzony na nowo. Dowiązania twarde przez cały czas wskazują na „usunięty” plik, który w rzeczywistości jest utrzymywany „przy życiu”, nawet jeżeli zostanie utworzony nowy plik. W przeciwieństwie do takiego zachowania dowiązania symboliczne będą zawsze wskazywały na nowo utworzony plik i nie mają wpływu na to, kiedy usuniesz stary plik. Na przykład możemy utworzyć dowiązanie symboliczne wskazujące na plik, który jest okresowo tworzony i usuwany w systemie kontroli wersji kodu źródłowego, plik obiektowy tworzony od nowa przez kompilator języka C za każdym razem, kiedy uruchamiasz polecenie make, czy okresowo archiwizowany plik dziennika systemowego. Dowiązania symboliczne są o wiele bardziej uniwersalnym rozwiązaniem niż dowiązania twarde, ale posiadają również swoje wady. Wszystkie dowiązania twarde mają taki sam status jak pliki i są dokładnie w taki sam sposób traktowane. W przypadku dowiązań symbolicznych tak nie jest. Plik

150  ROZDZIAŁ 4. SYSTEM PLIKÓW posiadający kilka dowiązań twardych przypomina w pewnym sensie osobę posiadającą legalnie kilka nazwisk (jak to się czasami dzieje w przypadku zamężnych kobiet). W tej analogii dowiązania symboliczne odgrywają raczej rolę przezwisk czy też jak kto woli, ksywki — każdy może mieć jedno czy nawet wiele przezwisk, ale mają one znacznie niższy status niż legalne nazwisko. W kolejnych sekcjach omówimy najważniejsze właściwości i cechy dowiązań symbolicznych.

POLECENIE LN — TWORZENIE DOWIĄZAŃ SYMBOLICZNYCH Polecenie ln z opcją --symbolic (lub w skrócie -s) tworzy dowiązanie symboliczne. W przykładzie przedstawionym poniżej tworzymy dowiązanie symboliczne o nazwie /tmp/s3 do pliku suma, znajdującego się w katalogu domowym użytkownika kuba. Kiedy użyjemy polecenia ls -l do wyświetlenia dowiązań symbolicznych, zobaczymy, że polecenie to wyświetla nazwę dowiązania i nazwę pliku, na który to dowiązanie wskazuje. Pierwszym znakiem wiersza z informacjami o dowiązaniu symbolicznym jest litera l (od ang. link): $ ln --symbolic /home/kuba/suma /tmp/s3 $ ls -l /home/kuba/suma /tmp/s3 -rw-rw-r--. 1 kuba pubs 38 06-12 09:51 /home/kuba/suma lrwxrwxrwx. 1 kuba pubs 14 06-12 09:52 /tmp/s3 -> /home/kuba/suma $ cat /tmp/s3 To jest suma.

Rozmiary i czasy ostatniej modyfikacji obu plików są różne. W przeciwieństwie do dowiązań twardych dowiązania symboliczne do pliku nie posiadają takich samych informacji jak plik. Polecenia ln możesz również użyć do utworzenia dowiązania symbolicznego do katalogu. Kiedy użyjesz opcji --symbolic, polecenie ln będzie działało dokładnie tak samo w przypadku katalogu, jak i w przypadku zwykłego pliku.

OSTRZEŻENIE Tworząc dowiązania symboliczne, zawsze używaj ścieżek bezwzględnych Dowiązania symboliczne są literałami i nie otrzymują żadnych informacji zwrotnych o katalogach. Dowiązanie wskazujące na ścieżkę względną (zawierającą proste nazwy plików) będzie zawsze „zakładało”, że ścieżka została utworzona względem katalogu, w którym znajduje się dowiązanie symboliczne (a nie katalogu, w którym znajduje się element docelowy). W przykładzie przedstawionym poniżej dowiązanie wskazuje na plik o nazwie suma, znajdujący się w katalogu /tmp. Ponieważ taki plik nie istnieje, wywołanie polecenia cat kończy się wyświetleniem komunikatu o błędzie: $ pwd /home/kuba $ ln --symbolic suma /tmp/s4 $ ls -l /home/kuba/suma /tmp/s4 lrwxrwxrwx. 1 kuba pubs 3 06-12 10:13 /tmp/s4 -> suma -rw-rw-r--. 1 kuba pubs 38 06-12 09:51 /home/kuba/suma $ cat /tmp/s4 cat: /tmp/s4: Nie ma takiego pliku ani katalogu

INFORMACJE DODATKOWE POLECENIE CD A DOWIĄZANIA SYMBOLICZNE Jeżeli przy zmianie katalogu jako argumentu polecenia cd użyjesz dowiązania symbolicznego, rezultaty mogą być dosyć nieoczekiwane, zwłaszcza jeżeli nie zdawałeś sobie sprawy z tego, że użyłeś dowiązania symbolicznego. Jeżeli użyjesz polecenia cd do zmiany katalogu roboczego na katalog reprezentowany przez dowiązanie symboliczne, wbudowane polecenie powłoki pwd (patrz rozdział 5.) wyświetli nazwę tego dowiązania. Jednak polecenie pwd zlokalizowane w katalogu /bin/pwd zawsze wyświetla nazwę dowiązanego katalogu, a nie

Dowiązania  151

pliku dowiązania, niezależnie od tego, jak się w takim katalogu znalazłeś. Możesz użyć opcji -P (Physical) polecenia pwd w celu wyświetlenia dowiązanego katalogu. Wymieniona opcja powoduje wyświetlenie ścieżki dostępu niezawierającej dowiązań symbolicznych. $ ln -s /home/kuba/oceny /tmp/oceny.old $ pwd /home/kuba $ cd /tmp/oceny.old $ pwd /tmp/oceny.old $ /bin/pwd /home/kuba/oceny $ pwd –P /home/kuba/oceny

Kiedy ponownie przejdziesz do katalogu nadrzędnego, znajdziesz się w katalogu, w którym znajduje się plik dowiązania symbolicznego: $ cd .. $ pwd /tmp $ /bin/pwd /tmp

W systemie OS X /tmp jest dowiązaniem symbolicznym do /private/tmp. Jeżeli używasz systemu OS X, po wydaniu polecenia cd .. w powyższym przykładzie przekonasz się, że katalogiem roboczym jest /private/tmp.

POLECENIE RM — USUWANIE DOWIĄZANIA Kiedy tworzysz nowy plik, na „dzień dobry” tworzone jest do niego jedno dowiązanie twarde. Następnie możesz skasować taki plik lub, używając terminologii systemu Linux, usunąć dowiązanie do tego pliku przy użyciu polecenia rm. Kiedy usuniesz ostatnie istniejące twarde dowiązanie do pliku, nie będziesz dłużej w stanie korzystać z zapisanych w pliku informacji, a system operacyjny zwolni przestrzeń na dysku zajmowaną przez ten plik, dzięki czemu może być ona wykorzystana przez inne pliki. Przestrzeń na dysku jest zwalniana nawet w sytuacji, kiedy istnieją jakieś dowiązania symboliczne prowadzące do tego pliku. Jeżeli istnieje wiele dowiązań twardych do takiego pliku, możesz usunąć jedno lub kilka z nich i nadal możesz korzystać z pliku za pośrednictwem dowolnego z pozostałych dowiązań. W przeciwieństwie do systemów DOS czy Windows Linux nie pozwala na łatwe odzyskanie raz skasowanego pliku. Oczywiście osoba posiadająca odpowiednie umiejętności zwykle jest w stanie odzyskać usunięte pliki. Kiedy usuniesz wszystkie twarde dowiązania do pliku, nie będziesz w stanie dostać się do takiego pliku za pośrednictwem istniejącego dowiązania symbolicznego. W przykładzie przedstawionym poniżej polecenie cat informuje, że plik total nie istnieje, ponieważ jest to dowiązanie symboliczne do pliku, który został wcześniej usunięty: $ ls -l suma -rw-r--r--. 1 kuba pubs 981 05-24 11:05 suma $ ln -s suma total $ rm suma $ cat total cat: total: Nie ma takiego pliku ani katalogu $ ls -l total lrwxrwxrwx. 1 kuba pubs 6 05-24 11:09 total -> suma

Kiedy usuwasz plik, powinieneś również usunąć wszystkie prowadzące do niego dowiązania symboliczne. Pliki dowiązań symbolicznych możesz usuwać dokładnie w taki sam sposób jak inne pliki: $ rm total

152  ROZDZIAŁ 4. SYSTEM PLIKÓW

ODWOŁANIA DO DOWIĄZAŃ SYMBOLICZNYCH Nazwa pliku jest wskaźnikiem do konkretnego pliku. Dowiązanie symboliczne to plik, którego nazwa odwołuje się do innego pliku (to znaczy pliku docelowego) bez faktycznego wskazywania wspomnianego pliku docelowego — to po prostu odniesienie do pliku docelowego. Więcej informacji na temat dowiązań symbolicznych przedstawiono we wcześniejszej części rozdziału. Odwołanie (ang. dereference) do dowiązania symbolicznego oznacza podążanie za dowiązaniem prowadzącym do pliku docelowego, a nie pracę z samym dowiązaniem. Kiedy odwołujesz się do dowiązania symbolicznego, tak naprawdę odwołujesz się do wskaźnika prowadzącego do pliku (nazwy pliku docelowego). Wyrażenie no-dereference to podwójne przeczenie i oznacza w tym przypadku element źródłowy. Dlatego użycie terminu no-dereference względem dowiązania symbolicznego oznacza pracę z samym dowiązaniem, a nie wskazywanym przez niego plikiem docelowym. Wiele narzędzi posiada opcje odwołania i braku odwołania do pliku docelowego, zwykle nazwane odpowiednio -L (--dereference) i -P (--no-dereference). Pewne narzędzia, np. chgrp, cp i ls, posiadają częściową opcję odwołania, zwykle wywoływaną za pomocą -H. Po użyciu opcji -H narzędzie odwołuje się do plików wymienionych w poleceniu, a nie do plików znalezionych podczas poruszania się po hierarchii katalogu podanego w poleceniu. Poniżej przedstawiono dwa przykłady użycia opcji -L (--dereference) i -H (częściowe odwołanie) — pierwszy dla polecenia ls, natomiast drugi dla polecenia chgrp. Zaprezentowana zostanie także opcja -P (--no-dereference) polecenia chgrp.

ODWOŁANIE DO DOWIĄZANIA SYMBOLICZNEGO W POLECENIU LS Większość narzędzi domyślnie stosuje opcję --no-dereference, ale wiele narzędzi jej nie posiada. Na przykład używane w większości dystrybucji systemy Linux narzędzie GNU ls nie posiada opcji -P (--no-dereference), natomiast narzędzie BSD ls ją ma (system OS X został utworzony na bazie BSD).

Brak opcji

W przedstawionym poniżej przykładzie polecenie ls wraz z opcją -l powoduje wyświetlenie informacji o plikach znajdujących się w katalogu roboczym i nie odwołuje się do dowiązania symbolicznego dawid.notatka. Po prostu wyświetla dowiązanie symboliczne wraz ze ścieżką dostępu do pliku, do którego prowadzi dowiązanie (czyli do pliku docelowego). Pierwszy znak w wierszu dawid.notatka to litera l oznaczająca, że wiersz opisuje dowiązanie symboliczne. Użytkownik kuba utworzył dowiązanie symboliczne i jest jego właścicielem. $ ls -l -rw-r--r--. 1 kuba pubs 1129 04-10 15:53 notatkaD -rw-r--r--. 1 kuba pubs 14198 04-10 15:56 notatkaE lrwxrwxrwx. 1 kuba pubs 19 04-10 15:57 dawid.notatka -> /home/kuba/dawid/notatkaA

W kolejnym poleceniu został wskazany plik, do którego prowadzi dowiązanie symboliczne (czyli plik docelowy), i nastąpiło wyświetlenie informacji o wspomnianym pliku. Typ, prawa dostępu, właściciel i czas ostatniej modyfikacji pliku są inne niż w przypadku dowiązania symbolicznego. Dawid utworzył ten plik i jest jego właścicielem. $ ls -l /home/kuba/dawid/notatkaA -rw-r--r--. 1 dawid dawid 2126 04-10 15:54 /home/kuba/dawid/notatkaA

W następnym przykładzie użyto opcji -L (--dereference) polecenia ls w celu wyświetlenia informacji o plikach znajdujących się w katalogu roboczym i odwołania się do dowiązania symbolicznego dawid.notatka. Polecenie wyświetla więc plik, do którego prowadzi dowiązanie (czyli plik docelowy). Pierwszy znak w wierszu dawid.notatka to myślnik (-) oznaczający, że wiersz opisuje zwykły plik. Polecenie powoduje wyświetlenie takich samych informacji o pliku notatkaA jak w poprzednim poleceniu. Wyjątkiem jest tylko wyświetlenie nazwy dowiązania (dawid.notatka) zamiast nazwy pliku docelowego (notatkaA).

-L (--dereference)

Dowiązania  153

$ ls -lL -rw-r--r--. 1 kuba pubs 1129 04-10 15:53 notatkaD -rw-r--r--. 1 kuba pubs 14198 04-10 15:56 notatkaE -rw-r--r--. 1 dawid dawid 2126 04-10 15:54 dawid.notatka

Jeśli nie podasz dowiązania symbolicznego jako argumentu polecenia ls, opcja -H (częściowe odwołanie, to krótszy zapis opcji) powoduje wyświetlenie takich samych informacji jak w przypadku użycia opcji -l.

Opcja -H

$ ls -lH -rw-r--r--. 1 kuba pubs 1129 04-10 15:53 notatkaD -rw-r--r--. 1 kuba pubs 14198 04-10 15:56 notatkaE lrwxrwxrwx. 1 kuba pubs 19 04-10 15:57 dawid.notatka -> /home/kuba/dawid/notatkaA

Jeśli zaś podasz dowiązanie symboliczne jako argument polecenia ls, opcja -H spowoduje odwołanie się do wskazanego dowiązania i wyświetlenie informacji o pliku, do którego prowadzi to dowiązanie (pliku docelowego, w omawianym przykładzie to notatkaA). Podobnie jak w przypadku opcji -L odwołanie do pliku odbywa się poprzez nazwę dowiązania symbolicznego. $ ls -lH dawid.notatka -rw-r--r--. 1 dawid dawid 2126 04-10 15:54 dawid.notatka

W kolejnym przykładzie powłoka używa gwiazdki (*) w celu przygotowania listy nazw plików znajdujących się w katalogu roboczym i przekazania tej listy poleceniu ls. Określenie niejednoznacznego odwołania, które odnosi się do dowiązania symbolicznego, powoduje otrzymanie takich samych wyników jak w przypadku wyraźnego odwołania się do dowiązania symbolicznego. Po prostu polecenie ls nie wie, że zostało wywołane z niejednoznacznym odwołaniem do pliku, i przetwarza listę plików otrzymanych z powłoki. $ ls -lH * -rw-r--r--. 1 kuba pubs 1129 04-10 15:53 notatkaD -rw-r--r--. 1 kuba pubs 14198 04-10 15:56 notatkaE -rw-r--r--. 1 dawid dawid 2126 04-10 15:54 dawid.notatka

INFORMACJE DODATKOWE Narzędzie readlink wyświetla bezwzględną ścieżkę dostępu do pliku i jeśli potrzeba, odwołuje się do dowiązania symbolicznego. Po użyciu opcji -f (--canonicalize) polecenie readlink uwzględnia zagnieżdżone dowiązania symboliczne, poza ostatnim wszystkie dowiązania muszą istnieć. Spójrz na przykład:

readlink

$ ls -l /etc/alternatives/mta-mailq lrwxrwxrwx. 1 root root 23 01-11 15:35 /etc/alternatives/mta-mailq -> /usr/bin/mailq.sendmail $ ls -l /usr/bin/mailq.sendmail lrwxrwxrwx. 1 root root 25 01-11 15:32 /usr/bin/mailq.sendmail -> ../sbin/sendmail.sendmail $ readlink -f /etc/alternatives/mta-mailq /usr/sbin/sendmail.sendmail

ODWOŁANIE DO DOWIĄZANIA SYMBOLICZNEGO W POLECENIU CHGRP W poniższym przykładzie przedstawiono różnicę pomiędzy opcjami -H i -L, tym razem w poleceniu chgrp. Początkowo wszystkie pliki i katalogi znajdujące się w katalogu roboczym są powiązane z grupą kuba:

Brak opcji

$ ls -lR .: -rw-r--r-- 1 kuba kuba 102 07-02 12:31 bb drwxr-xr-x 2 kuba kuba 4096 07-02 15:34 dir1 drwxr-xr-x 2 kuba kuba 4096 07-02 15:33 dir4 ./dir1: -rw-r--r-- 1 kuba kuba 102 07-02 12:32 dd lrwxrwxrwx 1 kuba kuba 7 07-02 15:33 dir4.link -> ../dir4 ./dir4: -rw-r--r-- 1 kuba kuba 125 07-02 15:33 gg -rw-r--r-- 1 kuba kuba 375 07-02 15:33 hh

154  ROZDZIAŁ 4. SYSTEM PLIKÓW Wywołanie polecenia chgrp wraz z opcjami -R i -H (w przypadku polecenia chgrp opcja -H nie działa bez opcji -R) powoduje odwołanie się tylko do tych dowiązań symbolicznych, które zostały podane w poleceniu lub znajdują się w katalogu wymienionym w poleceniu. Narzędzie chgrp zmienia grupę powiązaną z plikami wskazywanymi przez wspomniane dowiązania. Polecenie nie odwołuje się do dowiązań symbolicznych znalezionych podczas podróży po hierarchii katalogów i nie zmienia samych dowiązań symbolicznych. Wchodząc do hierarchii dir1, polecenie chgrp nie zmienia dir4.link, ale zmieni dir4, czyli katalog wskazywany przez dowiązanie dir4.link.

Opcja -H

$ chgrp -RH pubs bb dir1 $ ls -lR .: -rw-r--r-- 1 kuba pubs 102 07-02 12:31 bb drwxr-xr-x 2 kuba pubs 4096 07-02 15:34 dir1 drwxr-xr-x 2 kuba pubs 4096 07-02 15:33 dir4 ./dir1: -rw-r--r-- 1 kuba pubs 102 07-02 12:32 dd lrwxrwxrwx 1 kuba kuba 7 07-02 15:33 dir4.link -> ../dir4 ./dir4: -rw-r--r-- 1 kuba kuba 125 07-02 15:33 gg -rw-r--r-- 1 kuba kuba 375 07-02 15:33 hh

OSTRZEŻENIE Opcja -H w systemie OS X W systemie OS X opcja -H polecenia chgrp działa nieco odmiennie niż w systemie Linux. W OS X polecenie chgrp -RH powoduje zmianę grupy dowiązania symbolicznego znalezionego w katalogu wymienionym w poleceniu, natomiast nie następuje zmiana pliku, do którego prowadzi dowiązanie. (Nie występuje więc sytuacja braku odwołania się do dowiązania symbolicznego). Po wydaniu powyższych poleceń w systemie OS X grupa powiązana z dir4 nie zostanie zmieniona, ale zmieniona będzie grupa powiązana z dir4.link. Jeżeli w systemie OS X działanie Twojego programu zależy od sposobu funkcjonowania opcji -H, przetestuj dokładnie swój program i upewnij się, że działa zgodnie z oczekiwaniami. Wywołanie polecenia chgrp wraz z opcjami -R i -L (w przypadku polecenia chgrp opcja -L nie działa bez opcji -R) powoduje odwołanie się do wszystkich dowiązań symbolicznych, zarówno podanych w poleceniu, jak i znalezionych podczas podróży po hierarchii katalogów. Polecenie nie zmienia samych dowiązań symbolicznych. Zmienione zostaną pliki w katalogu wskazywanym przez dowiązanie dir4.link.

Opcja -L

$ chgrp -RL pubs bb dir1 $ ls -lR .: -rw-r--r-- 1 kuba pubs 102 07-02 12:31 bb drwxr-xr-x 2 kuba pubs 4096 07-02 15:34 dir1 drwxr-xr-x 2 kuba pubs 4096 07-02 15:33 dir4 ./dir1: -rw-r--r-- 1 kuba pubs 102 07-02 12:32 dd lrwxrwxrwx 1 kuba kuba 7 07-02 15:33 dir4.link -> ../dir4 ./dir4: -rw-r--r-- 1 kuba pubs 125 07-02 15:33 gg -rw-r--r-- 1 kuba pubs 375 07-02 15:33 hh

Wywołanie polecenia chgrp wraz z opcjami -R i -P (w przypadku polecenia chgrp opcja -P nie działa bez opcji -R) powoduje brak odwołań do dowiązań symbolicznych. Polecenie nie zmienia grupy dowiązań symbolicznych.

Opcja -P

Podsumowanie rozdziału  155

$ ls -l bb* -rw-r--r-- 1 kuba zach 102 07-02 12:31 bb lrwxrwxrwx 1 kuba zach 2 07-02 16:02 bb.link -> bb $ chgrp -PR pubs bb.link $ ls -l bb* -rw-r--r-- 1 kuba kuba 102 07-02 12:31 bb lrwxrwxrwx 1 kuba pubs 2 07-02 16:02 bb.link -> bb

PODSUMOWANIE ROZDZIAŁU System Linux posiada hierarchiczną, drzewiastą strukturę systemu plików, która pozwala na efektywną organizację i porządkowanie plików tak, aby można je było szybko odnaleźć. W strukturze plików systemu Linux wyróżniamy zwykłe pliki i pliki katalogów. W katalogach przechowywane są pliki danych oraz pliki innych katalogów (podkatalogów). W zwykłych plikach przechowywane mogą być dane tekstowe, programy czy zdjęcia. Nadrzędnym elementem wszystkich plików jest katalog główny, który jest reprezentowany przez samodzielny znak prawego ukośnika (/) lub pierwszy od lewej znak prawego ukośnika w nazwie ścieżki do pliku. Większość systemów plików systemu Linux obsługuje nazwy plików składające się maksymalnie z 255 znaków. Jednak niezależnie od tego dobrą praktyką jest nadawanie plikom prostych i intuicyjnych nazw, wskazujących na ich zawartość. Rozszerzenia nazw plików mogą ułatwić identyfikację typu plików. Po zalogowaniu się do systemu jesteś zawsze przypisany do katalogu roboczego. Zaraz po zalogowaniu katalogiem roboczym jest Twój katalog domowy i pozostaje nim aż do momentu zmiany katalogu przy użyciu polecenia cd. Bezwzględna ścieżka do pliku rozpoczyna się od katalogu głównego i zawiera nazwy wszystkich katalogów występujących „po drodze” do pliku. Ścieżka bezwzględna rozpoczyna się od znaku prawego ukośnika, reprezentującego katalog główny, po którym następują nazwy poszczególnych katalogów oddzielone od siebie kolejnymi znakami prawego ukośnika (z wyjątkiem ostatniego katalogu w przypadku kiedy ścieżka wskazuje na plik katalogu). Ścieżka względna jest podobna do ścieżki bezwzględnej, z tym że podaje ścieżkę do pliku, rozpoczynając od bieżącego katalogu roboczego. Prosta nazwa pliku jest ostatnim elementem ścieżki i kiedy występuje samodzielnie, jest pewną formą ścieżki względnej — reprezentuje plik w bieżącym katalogu roboczym. W linuksowym systemie plików znajdziesz szereg ważnych katalogów, takich jak na przykład /usr/bin, gdzie przechowywana jest większość narzędzi systemu Linux, czy /dev, w którym przechowywane są pliki urządzeń (wiele z nich reprezentuje urządzenia fizyczne). Bardzo ważnym, standardowym plikiem systemu Linux jest /etc/passwd, w którym przechowywane są informacje o użytkownikach, takie jak nazwa konta czy pełna nazwa użytkownika. Jednymi z najważniejszych atrybutów plików są prawa dostępu, które określają, kto i na jakim poziomie może uzyskać dostęp do pliku. Istnieją trzy grupy użytkowników, dla których można zdefiniować prawa dostępu do pliku: właściciel pliku, grupa, z którą dany plik jest powiązany, i pozostali użytkownicy. Istnieją trzy poziomy dostępu do pliku: odczyt danych z pliku, zapis danych do pliku i wykonanie pliku. Polecenie ls z opcją -l wyświetla prawa dostępu do plików. W przypadku katalogów prawo wykonania oznacza, że katalog może być przeszukiwany przez użytkownika. Właściciel pliku lub użytkownik pracujący z uprawnieniami użytkownika root mogą użyć polecenia chmod do zmiany praw dostępu do pliku. Polecenie chmod pozwala nadawać prawa odczytu, zapisu i wykonania właścicielowi pliku, grupie i pozostałym użytkownikom.

156  ROZDZIAŁ 4. SYSTEM PLIKÓW Listy kontrolne ACL umożliwiają bardziej rozbudowaną i dokładną kontrolę dostępu do plików w porównaniu ze standardowymi uprawnieniami w systemie Linux. Zastosowanie list ACL pozwala na szczegółowe zdefiniowanie poziomu dostępu do plików i katalogów dla poszczególnych użytkowników. Nie wszystkie narzędzia wspierają obsługę list ACL. W zwykłych plikach przechowywane są dane użytkowników, takie jak teksty, programy czy zdjęcia. Katalog to swego rodzaju kontener, w którym przechowywane są informacje o innych plikach i podkatalogach. I-węzeł to struktura danych przechowywana na dysku, w której zapisywane są wszystkie informacje niezbędne do istnienia pliku. Każdy i-węzeł posiada swój unikatowy numer. W katalogach wszystkie nazwy przechowywanych plików są powiązane z odpowiednimi i-węzłami. Dowiązanie to wskaźnik do pliku. Do każdego pliku można utworzyć wiele dowiązań, dzięki czemu możesz łatwo udostępniać dany plik innym użytkownikom lub powodować, że dany plik jest widoczny w więcej niż jednym katalogu. Ponieważ istnieje tylko jedna kopia pliku, do której możemy utworzyć wiele dowiązań, modyfikacja pliku dokonana za pośrednictwem jednego z dowiązań jest natychmiast „widziana” za pośrednictwem pozostałych dowiązań. Nie możesz utworzyć twardego dowiązania do katalogu ani do plików znajdujących się w innych systemach plików. Takich ograniczeń nie ma w przypadku tworzenia dowiązań symbolicznych. W tabeli 4.3 przedstawiono zestawienie narzędzi omawianych w tym rozdziale. Tabela 4.3. Narzędzia omawiane w rozdziale 4. Narzędzie

Funkcja

cd

Zmiana bieżącego katalogu roboczego.

chmod

Zmienia prawa dostępu do plików.

getfacl

Wyświetla listę kontrolną ACL danego pliku.

ln

Tworzy dowiązanie do istniejącego pliku.

mkdir

Tworzy nowy katalog.

pwd

Wyświetla ścieżkę bieżącego katalogu roboczego.

rmdir

Usuwa katalog.

setfacl

Modyfikuje listę kontrolną ACL danego pliku.

ĆWICZENIA 1. Podaj, które ścieżki wymienione poniżej są bezwzględne lub względne, a które to proste nazwy plików: a) ACME-Mleko b) korespondencja/biznes/ACME-Mleko c) /home/kuba d) /home/kuba/literatura/promocje e) .. f) list.0210 2. Wypisz nazwy poleceń, których możesz użyć do wykonania poniższych operacji: a) Spowodować, aby bieżącym katalogiem roboczym był Twój katalog domowy. b) Zidentyfikować bieżący katalog roboczy.

Ćwiczenia  157

3. W bieżącym katalogu roboczym /home/kuba znajduje się podkatalog literatura. Podaj trzy zestawy poleceń, za pomocą których możesz utworzyć w katalogu literatura podkatalog klasyka. Podaj również przykłady kilku zestawów poleceń, których mógłbyś użyć do usunięcia katalogu klasyka wraz z całą jego zawartością. 4. Polecenie df wyświetla szereg informacji o wszystkich zamontowanych systemach plików. Użyj polecenia df z opcją -h (ang. human-readable) i odpowiedz na następujące pytania: a) Ile systemów plików jest zamontowanych w Twoim systemie Linux? b) W którym systemie plików przechowywany jest Twój katalog domowy? c) Zakładając, że odpowiedź na pytanie 4a brzmi „dwa” lub więcej, spróbuj utworzyć twarde dowiązanie do pliku znajdującego się w innym systemie plików. Jaki komunikat otrzymałeś? Co się stanie, jeżeli spróbujesz utworzyć dowiązanie symboliczne do tego samego pliku? 5. Załóżmy, że posiadasz plik dowiązany do pliku, którego właścicielem jest inny użytkownik. W jaki sposób możesz upewnić się, że zmiany wprowadzane do pliku nie są już dłużej udostępniane? 6. Aby wykonać to ćwiczenie, musisz posiadać prawo odczytu pliku /etc/passwd. Aby odpowiedzieć na poniższe pytania, użyj polecenia cat lub less do wyświetlenia zawartości pliku /etc/passwd. Przeanalizuj informacje zawarte w poszczególnych polach tego pliku, opisujące użytkowników systemu lokalnego. a) Jaki znak jest wykorzystywany do oddzielania poszczególnych pól w pliku /etc/passwd? b) Ile pól opisuje każdego użytkownika? c) Ilu użytkowników jest w Twoim systemie lokalnym? d) Z ilu różnych powłok korzystają użytkownicy Twojego systemu? (Wskazówka: Sprawdź zawartość ostatniego pola dla poszczególnych użytkowników). e) Drugie pole w pliku /etc/passwd przechowuje hasło użytkownika (w postaci zakodowanej). Jeżeli w polu hasła znajduje się znak x, oznacza to, że Twój system wykorzystuje mechanizm cieniowania haseł i przechowuje hasła w innym miejscu. Czy Twój system korzysta z cieniowania haseł? 7. Jeżeli pliki /home/dawid/wersja_robocza oraz /home/kuba/list są dowiązaniami do tego samego pliku i będzie miała miejsce następująca sekwencja zdarzeń, jakie daty będą zapisane w nagłówku listu? a) Użytkownik kuba wykonuje polecenie vim list. b) Użytkownik dawid wykonuje polecenie vim wersja_robocza. c) Użytkownik dawid zmienia datę w nagłówku listu na 2011-01-31, zapisuje plik i kończy pracę z edytorem vim. d) Użytkownik kuba zmienia datę w nagłówku listu na 2011-02-01, zapisuje plik i kończy pracę z edytorem vim. 8. Załóżmy, że dany użytkownik należy do grupy, która posiada pełne prawa dostępu do pliku o nazwie lista_zadań, ale sam użytkownik jako właściciel pliku nie posiada żadnych praw do tego pliku. Opisz, jakie operacje może w takiej sytuacji wykonywać użytkownik (właściciel) na pliku lista_zadań. Jakie polecenie może wykonać użytkownik (właściciel), aby nadać sobie pełne prawa do pliku? 9. Czy w katalogu głównym znajdują się jakieś podkatalogi, których zawartość możesz przeglądać jako zwykły użytkownik? Czy w katalogu głównym znajdują się jakieś podkatalogi, których zawartości nie może przeglądać zwykły użytkownik? Uzasadnij odpowiedź. 10. Załóżmy, że posiadasz strukturę katalogów przedstawioną na rysunku 4.2 i masz następujące prawa do katalogów: d--x--x--- 3 dawid pubs 512 2010-03-10 15:16 biznes drwxr-xr-x 2 dawid pubs 512 2010-03-10 15:16 biznes/ACME-Mleko

158  ROZDZIAŁ 4. SYSTEM PLIKÓW Dla każdej kategorii praw dostępu — właściciela, grupy i pozostałych użytkowników — opisz, co wydarzy się po uruchomieniu każdego z poleceń przedstawionych poniżej. Załóż, że katalogiem roboczym jest katalog nadrzędny katalogu korespondencja i że plik ACME-Sery może być odczytywany przez każdego użytkownika. a) cd korespondencja/biznes/ACME-Mleko b) ls -l korespondencja/biznes c) cat korespondencja/biznes/ACME-Sery

ĆWICZENIA ZAAWANSOWANE 11. Co to jest i-węzeł? Co się dzieje z i-węzłem, jeżeli przenosisz plik w inne miejsce systemu plików? 12. Na co wskazuje element .. w katalogu? Jaki katalog jest reprezentowany przez ten element w katalogu głównym (/)? 13. Jak możesz utworzyć plik o nazwie -i? Które techniki tworzenia plików nie będą działały, a których będziesz mógł użyć? W jaki sposób możesz usunąć plik o nazwie -i? 14. Załóżmy, że w katalogu roboczym znajduje się pojedynczy plik o nazwie andor. Jaki komunikat o błędzie pojawi się na ekranie, kiedy spróbujesz wykonać następujące polecenie: $ mv andor and\/or

15.

16. 17. 18.

W jakich okolicznościach możesz uruchomić takie polecenie bez wygenerowania błędu? Polecenie ls -i wyświetla nazwy plików poprzedzone numerami i-węzłów (patrz nieco wcześniej w rozdziale). Napisz polecenie, które wyświetli pary numer i-węzła/nazwa pliku dla plików z katalogu roboczego, posortowane według numerów i-węzłów. (Wskazówka: Użyj symbolu potoku). Czy sądzisz, że administrator systemu ma dostęp do programu pozwalającego na dekodowanie haseł użytkowników? Uzasadnij odpowiedź (patrz ćwiczenie 6.). Czy można odróżnić dowiązanie twarde od pliku? Inaczej mówiąc, mając nazwę pliku, czy możesz sprawdzić, czy został utworzony przy użyciu polecenia ln? Uzasadnij odpowiedź. Wyjaśnij komunikaty o błędach występujące w sekwencji poleceń przedstawionej poniżej: $ ls -l drwxrwxr-x. 2 kuba pubs 1024 03-02 17:57 dirtmp $ ls dirtmp $ rmdir dirtmp rmdir: nie udało się usunąć 'dirtmp': Katalog nie jest pusty $ rm dirtmp/* rm: Nie ma takiego pliku ani katalogu.

5 Powłoka systemu Linux

W tym rozdziale:

Cele rozdziału

Wiersz poleceń

Po przeczytaniu tego rozdziału będziesz wiedział:  Jak opisać proste polecenie.  Jaka jest składnia komend wydawanych z wiersza poleceń i jak uruchamiać polecenia z opcjami i argumentami.  Jak powłoka interpretuje składnię komend wpisywanych w wierszu poleceń.  Jak przekierować wyjście polecenia do pliku? Jak zapisywać wyniki działania poleceń w nowym pliku i jak dołączać je do pliku istniejącego.  Jak przesyłać dane z pliku na wejście polecenia.  Jak łączyć polecenia przy użyciu potoków.  Jak uruchamiać polecenia do pracy w tle.  Jak korzystać z symboli wieloznacznych w nazwach plików.  Jakie są różnice pomiędzy plikami wykonywalnymi a wbudowanymi poleceniami powłoki.

Standardowe wejście i standardowe wyjście danych Przekierowania Potoki danych Uruchamianie poleceń pracujących w tle Polecenie kill — zakończenie zadania działającego w tle Generowanie i rozwijanie nazw plików Wbudowane polecenia powłoki

160  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX W tym rozdziale przyjrzymy się bliżej powłoce systemu i powiemy, w jaki sposób można korzystać z niektórych jej mechanizmów. Omówimy na przykład składnię komend wydawanych z wiersza poleceń i opiszemy, w jaki sposób powłoka przetwarza wiersz polecenia, a następnie inicjuje uruchomienie odpowiedniego programu. W tym rozdziale wyjaśnimy również, w jaki sposób można przekierować standardowe wyjście i wejście poleceń, tworzyć w wierszu poleceń filtry i potoki danych oraz uruchamiać programy do działania w tle. W końcowej części rozdziału omówimy rozwijanie nazw plików oraz wyjaśnimy, w jaki sposób możesz korzystać z tego mechanizmu podczas codziennej pracy. O ile nie zaznaczono inaczej, przykłady w tym rozdziale mają zastosowanie w powłokach Bourne Again Shell (bash) i TC Shell (tcsh). Wygląd wyników działania poszczególnych poleceń może się nieco różnić w zależności od wykorzystywanej powłoki, stąd przykłady zamieszczone w tej książce mogą wyglądać trochę inaczej niż na ekranie Twojego komputera. Więcej szczegółowych informacji na temat powłoki bash znajdziesz w rozdziale 8., powłoki tcsh w rozdziale 9., a na temat pisania i wykonywania skryptów powłoki bash — w rozdziale 10.

WIERSZ POLECEŃ W tej książce używamy określenia polecenie w odniesieniu zarówno do komendy, którą wpisujesz w wierszu poleceń, jak i programu, którego wywołanie taka komenda powoduje.

Polecenie

Wiersz poleceń obejmuje proste polecenie (patrz poniżej), potokowanie (patrz „Potoki danych” w dalszej części rozdziału) i listę (patrz „Listy” w dalszej części rozdziału).

Wiersz poleceń

PROSTE POLECENIA Powłoka systemu uruchamia dany program po wpisaniu w wierszu poleceń odpowiedniej komendy. Na przykład po wydaniu komendy ls powłoka uruchamia program narzędziowy o nazwie ls. Wydając odpowiednie komendy, możesz spowodować, że powłoka będzie uruchamiała różne typy programów — takie jak skrypty powłoki, aplikacje czy nawet Twoje własne programy. Wiersz, w którym wpisywane są komendy oraz ich opcje i argumenty, jest nazywany wierszem poleceń powłoki. W kolejnych punktach zostaną przedstawione proste polecenia. Pełny, techniczny opis prostego polecenia znajdziesz w dalszej części rozdziału.

SKŁADNIA Składnia komend definiuje kolejność poszczególnych elementów oraz sposób ich oddzielania od siebie w wierszu poleceń. Kiedy po zakończeniu wpisywania komendy naciskasz klawisz Enter, powłoka przegląda wpisany wiersz polecenia i sprawdza poprawność jego składni. Składnia podstawowych poleceń wygląda następująco: polecenie [arg1] [arg2] ... [argn]

Poszczególne elementy wpisywane w wierszu poleceń muszą być od siebie oddzielone jednym lub kilkoma znakami spacji. Pierwszy element, polecenie, oznacza nazwę polecenia, które chcesz wykonać, [arg1] do [argn] to argumenty wywoływanego polecenia, a to wciśnięcie klawisza kończącego wpisywanie komendy w wierszu poleceń. Nawiasy kwadratowe w składni polecenia oznaczają, że poszczególne argumenty są opcjonalne. Nie wszystkie polecenia wymagają podawania argumentów, niektóre polecenia w ogóle nie akceptują argumentów, inne pozwalają na używanie zmiennej liczby argumentów, a jeszcze inne wymagają podania dokładnie określonej liczby argumentów. Opcje, czyli specjalny rodzaj argumentów, w wierszu poleceń są zazwyczaj poprzedzane jednym lub dwoma myślnikami (lub po prostu jak kto woli, znakami minus: -).

Wiersz poleceń  161

NAZWY POLECEŃ Niektóre bardzo użyteczne polecenia systemu Linux do uruchomienia potrzebują tylko nazwy i nie wymagają podawania żadnych argumentów. Na przykład samo polecenie ls, wywołane bez argumentów, wyświetla na ekranie zawartość katalogu roboczego. Polecenia, które wymagają podawania argumentów, zazwyczaj wyświetlają w takiej sytuacji krótką informację o sposobie użycia danego polecenia i jego składni. Taki sam komunikat zazwyczaj pojawia się również w sytuacji, kiedy polecenie wymagające podawania argumentów zostanie wywołane z niewłaściwą liczbą argumentów.

Informacja o sposobie użycia polecenia

Na przykład polecenie mkdir (tworzenie katalogów) wymaga podania argumentu reprezentującego nazwę katalogu, który chcesz utworzyć. Jeżeli taki argument nie zostanie podany, polecenie wyświetli na ekranie następujący komunikat: $ mkdir mkdir: brakujący argument Spróbuj 'mkdir --help' dla uzyskania informacji.

ARGUMENTY W terminologii wiersza poleceń każda sekwencja znaków oddzielona znakami spacji jest nazywana tokenem lub rzadziej słowem. Tokenem jest każdy argument polecenia, taki jak nazwa pliku, ciąg znaków, liczba czy inny obiekt związany z wykonywanym poleceniem. Na przykład argumentem polecenia vim czy emacs jest nazwa pliku, który będzie edytowany.

Tokeny

W przykładzie przedstawionym poniżej wykorzystujemy polecenie temp i nadania jej nazwy kopia_temp:

cp

do utworzenia kopii pliku

$ cp temp kopia_temp

Argumenty są numerowane, począwszy od samego polecenia, które jest po prostu argumentem o numerze zero. W powyższym przykładzie polecenie cp to argument o numerze 0, temp to argument o numerze 1, a kopia_temp to argument o numerze 2. Polecenie cp wymaga podania w wierszu poleceń co najmniej dwóch argumentów. Pierwszym argumentem jest nazwa istniejącego pliku, a drugim — nazwa pliku, który będzie utworzony lub nadpisany. W tym przypadku argumenty nie są opcjonalne — aby polecenie zadziałało poprawnie, musisz podać oba argumenty. Jeżeli podczas próby wywołania polecenia cp podasz niewłaściwą liczbę lub niewłaściwy rodzaj argumentów, na ekranie zostanie wyświetlony komunikat o sposobie użycia tego polecenia. Aby się o tym przekonać, wpisz polecenie cp i naciśnij klawisz Enter.

OPCJE Opcja to specjalny rodzaj argumentu, który modyfikuje sposób działania polecenia. Wywołując polecenie, bardzo często możesz podać więcej niż jedną opcję, zmieniając wiele aspektów działania polecenia jednocześnie. Opcje są związane z danym programem i są interpretowane przez ten program, a nie powłokę systemu. Przyjęło się, że opcje są osobnymi argumentami polecenia i zazwyczaj są wpisywane zaraz po nazwie polecenia (przed pozostałymi argumentami, takimi jak na przykład nazwa pliku). Wiele narzędzi wymaga, aby opcje były poprzedzone znakiem myślnika, aczkolwiek jest to wymaganie poszczególnych programów, a nie samej powłoki. Opcje programów GNU są często poprzedzane dwoma myślnikami. Na przykład użycie opcji --help wyświetla na ekranie informację o sposobie użycia polecenia (czasami takie informacje potrafią być bardzo rozbudowane). Na rysunku 5.1 przedstawiono wyniki działania polecenia ls. Pierwsze polecenie zostało wywołane bez żadnych opcji. Domyślnie polecenie ls wyświetla zawartość bieżącego katalogu roboczego, gdzie nazwy plików i katalogów są wyświetlone w kolejności alfabetycznej i posortowane w kolumnach. Kolejne polecenie ls zostało wywołane z opcją -r (ang. reverse order; ponieważ ls jest narzędziem

162  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX GNU, możesz również zamiast opcji -r użyć opcji --reverse), która powoduje wyświetlenie listy plików w odwrotnej kolejności alfabetycznej i nadal posortowanej w kolumnach. Następne polecenie ls, wywołane z opcją -x, powoduje, że lista plików zostaje wyświetlona w kolejności alfabetycznej i tym razem posortowana w wierszach. $ ls dawid hologramy marek obrazy rupiecie test historia madzia normy osobiste temp $ ls -r test rupiecie obrazy marek hologramy dawid temp osobiste normy madzia historia $ ls -x dawid historia hologramy madzia marek normy obrazy osobiste rupiecie temp test $ ls -rx test temp rupiecie osobiste obrazy normy marek madzia hologramy historia dawid

Rysunek 5.1. Zastosowanie opcji

Kiedy chcesz użyć kilku opcji, możesz zazwyczaj połączyć wiele jednoliterowych opcji w jeden argument rozpoczynający się od myślnika (pamiętaj, aby nie oddzielać poszczególnych argumentów od siebie znakami spacji). W taki sposób nie możesz łączyć opcji, które są poprzedzone dwoma myślnikami. Dokładne zasady łączenia opcji zależą od konkretnego programu. Na rysunku 5.1 widać, że opcje -r oraz -x zostały połączone. Użycie tych opcji razem powoduje, że polecenie ls wyświetla listę plików w odwrotnej kolejności alfabetycznej i posortowaną w wierszach. Większość poleceń pozwala na stosowanie dowolnej kolejności podawania opcji, stąd polecenie ls -xr daje dokładnie takie same wyniki jak ls -rx. Wykonanie polecenia ls -x -r również będzie miało identyczny efekt.

Łączenie opcji

WSKAZÓWKA Opcja --help Bardzo wiele narzędzi wywołanych z opcją --help wyświetla (nieraz bardzo rozbudowane) informacje o sposobie użycia polecenia. Wszystkie narzędzia, które powstały w ramach projektu GNU, akceptują tę opcję. Poniżej zamieszczamy przykład takiego komunikatu wyświetlanego przez polecenie bzip2: $ bzip2 --help bzip2, a block-sorting file compressor.

Version 1.0.6, 6-Sept-2010.

usage: bzip2 [flags and input files in any order] -h --help print this message -d --decompress force decompression -z --compress force compression -k --keep keep (don't delete) input files -f --force overwrite existing output files (...) If invoked as `bzip2', default action is to compress. as `bunzip2', default action is to decompress. as `bzcat', default action is to decompress to stdout. (...)

Niektóre narzędzia posiadają opcje wywołania, które same wymagają podania swoich własnych argumentów. Na przykład polecenie gcc (kompilator języka C) posiada opcję -o (ang. output) wymagającą wpisania nazwy pliku wykonywalnego, który ma zostać wygenerowany przez kompilator gcc. Zazwyczaj argument opcji jest oddzielony od samej opcji znakiem spacji, na przykład:

Argumenty opcji

$ gcc -o prog prog.c

Wiersz poleceń  163

Niektóre narzędzia wymagają użycia znaku równości pomiędzy opcją i jej argumentem. Na przykład szerokość danych wyjściowych polecenia diff można określić na dwa sposoby: $ diff -W 60 plikA plikB

lub $ diff --width=60 plikA plikB

WSKAZÓWKA Wyświetlanie przyjaznych dla użytkownika rozmiarów plików — opcja -h Większość narzędzi wyświetlających listy plików podaje rozmiary plików w bajtach. Takie rozwiązanie sprawdza się całkiem nieźle, dopóki pracujemy ze stosunkowo niewielkimi plikami. Jednak w przypadku plików, których wielkość mierzona jest w megabajtach czy gigabajtach, odczytywanie rozmiarów w bajtach zaczyna być kłopotliwe. Aby tego uniknąć, możesz użyć opcji -h (lub --human-readable), dzięki czemu rozmiary plików będą wyświetlane odpowiednio w kilobajtach, megabajtach lub gigabajtach. Aby się przekonać, jak to działa, poeksperymentuj z poleceniami df -h (raportowanie zajętości dysku) oraz ls -lh. Inna konwencja zapisu pozwala na używanie argumentów takich jak nazwy plików, które same z siebie rozpoczynają się od znaku myślnika. Jeśli na przykład z jakiegoś powodu dany plik nosi nazwę -l, to polecenie przedstawione poniżej staje się niejednoznaczne:

Argumenty, które rozpoczynają się od znaku myślnika

$ ls -l

Takie polecenie może być interpretowane dwojako: jako żądanie wyświetlenia listy plików z bieżącego katalogu roboczego w długim formacie (opcja -l) lub jako żądanie wyświetlenia pliku o nazwie -l. W praktyce takie polecenie zostanie zinterpretowane na ten pierwszy sposób i polecenie ls wyświetli na ekranie listę plików znajdujących się w bieżącym katalogu roboczym. Jeżeli to tylko możliwe, zdecydowanie powinieneś unikać tworzenia plików o nazwach rozpoczynających się od znaku myślnika. Jeżeli jednak z takiego czy innego powodu musisz korzystać z takich plików, pamiętaj, że wiele poleceń wykorzystuje konwencję, w której użycie argumentu -- (dwa kolejne myślniki) wskazuje na miejsce zakończenia wprowadzania opcji (i automatycznie miejsce rozpoczęcia wprowadzania argumentów). Aby ujednoznacznić polecenie z poprzedniego przykładu, możesz napisać tak: $ ls -- -l

Zastosowanie dwóch kolejnych myślników do oznaczenia miejsca zakończenia wprowadzania opcji jest jednak tylko konwencją, a nie żelazną regułą, stąd wiele poleceń po prostu się do niej nie stosuje (na przykład find). Jednak niewątpliwie zastosowanie tej konwencji w wielu przypadkach mocno ułatwia użytkownikowi życie, stąd pisząc własne programy czy skrypty powłoki, które wymagają podawania opcji, powinieneś jej używać. W przypadku narzędzi, które nie akceptują opisanej wyżej konwencji, istnieją inne sposoby podawania nazw plików, które rozpoczynają się od myślnika. Na przykład możesz użyć kropki i znaku prawego ukośnika dla wskazania, że nazwa pliku, która po nich następuje, odnosi się do pliku znajdującego się w bieżącym katalogu roboczym: $ ls ./-l

Zamiast tego możesz również użyć bezwzględnej ścieżki do pliku: $ ls /home/kuba/-l

164  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX INFORMACJE DODATKOWE PROSTE POLECENIA W tym miejscu znajdują się informacje dodatkowe o składni wiersza poleceń. To uzupełnienie informacji przedstawionych na początku rozdziału. Proste polecenie składa się z zera lub większej liczby przypisań zmiennych i wiersza poleceń. Na jego końcu znajduje się operator kontrolny (np. &, ;, | lub znak nowego wiersza — patrz rozdział 8.). Proste polecenie ma następującą składnię: [nazwa=wartość ...] wiersz-poleceń

Każdej nazwie powłoka przypisuje wartość i umieszcza ją w środowisku programu wywoływanego przez wiersz-poleceń, aby była dostępna dla programu wywołującego i jego procesów potomnych. Pary nazwa=wartość powłoka przetwarza od lewej do prawej strony, jeśli więc dana nazwa zostanie użyta więcej niż tylko jeden raz, to pierwszeństwo ma wartość znajdująca się po prawej stronie. Wiersz-poleceń może zawierać operatory przekierowania, np. < i >. Stanem wyjścia prostego polecenia jest po prostu jego wartość zwrotna. W powłoce tcsh konieczne jest użycie env w celu umieszczenia zmiennych w środowisku wywoływanego programu bez deklarowania zmiennych w powłoce. Przedstawione poniżej polecenia pokazują, jak można przypisać wartość nazwie (zmiennej) i umieścić wspomnianą nazwę w środowisku programu potomnego. Zmienna nie jest dostępna dla aktualnie używanej powłoki (program nadrzędny). Skrypt o nazwie echo_ee wyświetla wartość zmiennej ee. Pierwsze wywołanie echo_ee pokazuje, że zmienna ee nie została ustawiona w powłoce potomnej wywołującej dany skrypt. Jeżeli wywołanie skryptu echo_ee będzie poprzedzone przypisaniem wartości zmiennej ee, w powłoce potomnej skrypt wyświetli tę wartość. Ostatnie polecenie pokazuje, że zmienna ee nie jest ustawiona w powłoce wywołującej skrypt.

Umieszczanie zmiennej w środowisku potomnym

$ cat echo_ee echo "Wartość zmiennej ee wynosi: $ee" $ ./echo_ee Wartość zmiennej ee wynosi: $ ee=88 ./echo_ee Wartość zmiennej ee wynosi: 88 $ echo $ee $

PRZETWARZANIE WIERSZA POLECEŃ Podczas wpisywania komendy w wierszu poleceń sterownik urządzenia tty systemu Linux (część jądra systemu Linux) sprawdza kolejne znaki, aby „zobaczyć”, czy któryś z wpisanych znaków nie wymaga podjęcia natychmiastowej akcji. Na przykład: kiedy naciśniesz kombinację klawiszy Ctrl+H (aby skasować znak) lub Ctrl+U (aby skasować cały wiersz), sterownik urządzenia tty od razu dokonuje odpowiednich modyfikacji w wierszu poleceń, tak że powłoka nigdy nie otrzymuje znaków czy wierszy, które zostały przez Ciebie usunięte. Bardzo często podobne modyfikacje mają miejsce w sytuacji, kiedy naciśniesz kombinację klawiszy Ctrl+W (aby usunąć całe wpisane słowo). Jeżeli wpisany znak nie wymaga natychmiastowej akcji, sterownik urządzenia tty zapisuje taki znak w buforze i oczekuje na wpisanie kolejnego znaku. Kiedy zakończysz wpisywanie wiersza poleceń naciśnięciem klawisza Enter, sterownik przekazuje polecenie zapisane w buforze do powłoki, która rozpoczyna jego przetwarzanie. Kiedy powłoka systemu rozpoczyna przetwarzanie wiersza poleceń, pobiera cały wiersz i dzieli go na poszczególne części składowe (patrz rysunek 5.2). Następnie wyszukiwana jest nazwa polecenia, która zazwyczaj jest pierwszym elementem wiersza polecenia, wpisywanym zaraz po wyświetleniu znaku zachęty (nazwa polecenia jest argumentem o numerze 0). W celu odnalezienia polecenia powłoka pobiera ciąg znaków od początku wiersza poleceń aż do pierwszego separatora

Przetwarzanie wiersza poleceń

Wiersz poleceń  165

Rysunek 5.2. Algorytm przetwarzania wiersza poleceń

(znaku tabulacji lub spacji) i następnie szuka polecenia o nazwie pasującej do pobranego ciągu znaków. Nazwa polecenia (pierwszy token) może być wpisana w wierszu polecenia jako prosta nazwa pliku lub jako pełna ścieżka. Na przykład polecenie ls możesz wywołać na jeden z dwóch przedstawionych poniżej sposobów: $ ls

lub $ /bin/ls

INFORMACJE DODATKOWE Powłoka nie wymaga, aby nazwa programu pojawiała się w wierszu poleceń jako pierwsza, możesz więc korzystać na przykład z następującej struktury poleceń: $ >bb ) informuje powłokę, że powinna przekierować strumień danych napływający ze standardowego wyjścia danego polecenia do pliku zamiast na ekran (patrz rysunek 5.6). Składnia takiej komendy w wierszu poleceń jest następująca: polecenie [argumenty] > nazwa_pliku

170  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX

Rysunek 5.6. Przekierowywanie standardowego wyjścia polecenia polecenie to nazwa dowolnego pliku wykonywalnego (takiego jak narzędzie czy aplikacja), argumenty to lista wymaganych i opcjonalnych argumentów polecenia, a nazwa_pliku to nazwa

gdzie

zwykłego pliku, do którego zostaną przekierowane wyniki działania polecenia. Na rysunku 5.7 przedstawiono przykład przekierowania standardowego wyjścia polecenia cat. Porównaj ten rysunek z sytuacją przedstawioną na rysunku 5.5, gdzie standardowe wejście i standardowe wyjście są przypisane odpowiednio do klawiatury i ekranu. W przykładzie na rysunku 5.7 dane napływające na wejście polecenia są pobierane z klawiatury. Użyty w wierszu polecenia symbol przekierowania wyjścia powoduje, że powłoka systemu przekierowuje strumień danych wypływający ze standardowego wyjścia polecenia cat do pliku o nazwie przykład.txt (którego nazwa została wpisana po symbolu przekierowania). $ cat > przykład.txt To jest tekst wprowadzany przez użytkownika z klawiatury i kopiowany do pliku poleceniem cat. Aby zasygnalizować koniec pliku, naciśnij kombinację klawiszy Ctrl+D.

$

Rysunek 5.7. Polecenie cat z wyjściem przekierowanym do pliku

OSTRZEŻENIE Przekierowanie wyjścia może skasować istniejącą zawartość pliku — część I Korzystając z przekierowania strumienia danych z wyjścia polecenia do pliku, powinieneś zachować szczególną ostrożność. Jeżeli plik o podanej nazwie istnieje, to powłoka usunie jego zawartość i zastąpi ją nowymi danymi. Więcej szczegółowych informacji na ten temat znajdziesz we wskazówce „Przekierowanie wyjścia może skasować istniejącą zawartość pliku — część II” w dalszej części tego rozdziału. Po uruchomieniu polecenia i wpisaniu tekstu przedstawionego na rysunku 5.7 cały wpisany z klawiatury tekst zapisany zostanie w pliku o nazwie przykład.txt. Aby wyświetlić zawartość tego pliku, możesz teraz użyć polecenia cat i jako argument tego polecenia podać nazwę pliku przykład.txt. W kolejnej sekcji zaprezentujemy jeszcze inny sposób użycia polecenia cat do wyświetlenia zawartości pliku. Rysunek 5.7 pokazuje, że przekierowanie standardowego wyjścia polecenia cat jest wygodnym sposobem tworzenia plików tekstowych bez używania edytora tekstu. Poważną wadą takiego rozwiązania jest jednak to, że kiedy po wpisaniu danego wiersza naciśniesz klawisz Enter, to nie masz już możliwości edytowania wprowadzonego tekstu. Pamiętaj, że podczas wprowadzania tekstu możesz korzystać z klawisza usuwania znaku oraz wiersza. Jak widać, opisana powyżej metoda jest wygodnym sposobem szybkiego tworzenia prostych plików tekstowych.

Standardowe wejście i standardowe wyjście danych  171

Na rysunku 5.8 pokazano, w jaki sposób możesz wykorzystać polecenie cat oraz symbol przekierowania wyjścia do konkatenacji (czyli inaczej łączenia) zawartości kilku plików w jeden. Pierwsze trzy polecenia wyświetlają zawartość trzech kolejnych plików: papier, taśmy i pióra. Kolejne polecenie cat posiada trzy argumenty będące nazwami trzech kolejnych plików. Kiedy wywołasz to polecenie z więcej niż jedną nazwą pliku, polecenie cat skopiuje zawartość kolejnych plików po jednym na raz na standardowe wyjście, które następnie zostaje przekierowane za pomocą odpowiedniego symbolu do pliku o nazwie zamówienia. Ostatnie polecenie cat pokazuje, że zawartość pliku zamówienia składa się z połączonej zawartości trzech plików składowych. $ cat papier 2000 arkuszy papieru firmowego, data zamówienia $ cat taśma 1 rolka korektora w taśmie, data zamówienia 5 rolek taśmy przezroczystej, data zamówienia $ cat pióra 12 sztuk wiecznych piór, data zamówienia $ cat papier taśma pióra > zamówienia $ cat zamówienia 2000 arkuszy papieru firmowego, data zamówienia 1 rolka korektora w taśmie, data zamówienia 5 rolek taśmy przezroczystej, data zamówienia 12 sztuk wiecznych piór, data zamówienia $

— 7 październik - 14 październik - 28 październik - 4 październik — -

7 październik 14 październik 28 październik 4 październik

Rysunek 5.8. Zastosowanie polecenia cat do łączenia plików

PRZEKIEROWYWANIE STANDARDOWEGO WEJŚCIA POLECENIA Standardowe wejście polecenia może być przekierowywane w niemal identyczny sposób jak standardowe wyjście. Symbol przekierowania wejścia ( pomarańcze cat: pomarańcze: plik wejściowy jest plikiem wyjściowym

Pomimo iż polecenie cat wyświetliło komunikat o wystąpieniu błędu, powłoka skasowała zawartość istniejącego pliku pomarańcze. Nowy plik o nazwie pomarańcze będzie miał identyczną zawartość jak plik gruszki, ponieważ pierwszą operacją, jaką powłoka wykonuje po znalezieniu znaku przekierowania wyjścia (>), jest usunięcie zawartości oryginalnego pliku pomarańcze. Jeżeli chcesz połączyć zawartość dwóch plików w jeden większy, użyj polecenia cat do skopiowania zawartości dwóch plików do pliku tymczasowego i następnie użyj polecenia mv do zmiany nazwy pliku tymczasowego: $ cat pomarańcze gruszki > temp $ mv temp pomarańcze

Zjawisko, które pokażemy w kolejnym przykładzie, jest jeszcze gorsze. Użytkownik wywołujący polecenie chciał przeszukać zawartość plików a, b i c pod kątem występowania słowa jabłko i przekierować wyniki działania polecenia grep do pliku o nazwie a.wyniki. Niestety użytkownik popełnił niewielki błąd i wpisał nazwę pliku wyjściowego jako a wyniki, przez przypadek wpisując spację w miejsce kropki: $ grep jabłko a b c > a wyniki grep: wyniki: Nie ma takiego pliku ani katalogu

Powłoka posłusznie usunęła zawartość pliku o nazwie a i następnie uruchomiła polecenie grep. Komunikat o wystąpieniu błędu może się pojawić po pewnej chwili, co może utwierdzić Cię w fałszywym przekonaniu, że polecenie działa poprawnie. Nawet po zobaczeniu na ekranie komunikatu o błędzie nie zawsze od razu będziesz sobie zdawał sprawę z tego, że właśnie skasowałeś zawartość pliku a.

OPCJA NOCLOBBER — ZABEZPIECZENIE PRZED NADPISANIEM PLIKU Powłoka posiada opcję o nazwie noclobber, która pozwala zabezpieczyć się przed nadpisaniem pliku przy użyciu przekierowania. Aby włączyć mechanizm ochrony, powinieneś ustawić zmienną noclobber, używając polecenia set -o noclobber. Takie samo polecenie, ale z opcją +o wyłącza opcję noclobber. Kiedy opcja noclobber jest włączona, próba przekierowania strumienia danych wyjściowych do istniejącego pliku powoduje, że powłoka wyświetla na ekranie odpowiedni komunikat o błędzie i anuluje wykonanie polecenia. W przykładzie przedstawionym poniżej najpierw przy użyciu polecenia touch tworzymy plik, następnie ustawiamy opcję noclobber i próbujemy przekierować do tego pliku wyniki działania polecenia echo. Następnie wyłączamy opcję noclobber i ponownie próbujemy przekierować do pliku wyniki działania polecenia echo.

Standardowe wejście i standardowe wyjście danych  173

(Powłoka bash): $ touch tmp $ set -o noclobber $ echo "Cześć! Jak się masz?" > tmp bash: tmp: nie można nadpisać istniejącego pliku $ set +o noclobber $ echo "Cześć! Jak się masz?" > tmp

(Powłoka tcsh): $ touch tmp $ set noclobber $ echo "Cześć! Jak się masz?" > tmp tmp: Plik istnieje. $ unset noclobber $ echo "Cześć! Jak się masz?" > tmp

Włączoną opcję noclobber możesz obejść, dodając po symbolu przekierowania symbol potoku (>|). W przykładzie przedstawionym poniżej użytkownik tworzy plik poprzez przekierowanie wyników działania polecenia date. Następnie użytkownik ustawia zmienną noclobber i ponownie przekierowuje wyniki działania polecenia do tego samego pliku. Tym razem powłoka wyświetla komunikat o błędzie. Dalej użytkownik wstawia symbol potoku po symbolu przekierowania i powłoka zezwala na nadpisanie pliku. $ date > tmp2 $ set -o noclobber $ date > tmp2 bash: tmp: nie można nadpisać istniejącego pliku $ date >| tmp2

Więcej informacji na temat używania opcji noclobber w powłoce tcsh znajdziesz w rozdziale 9.

OSTRZEŻENIE Nie polegaj wyłącznie na opcji noclobber Dołączanie danych na końcu istniejącego pliku jest znacznie łatwiejsze niż dwuetapowa procedura opisana w poprzednim ostrzeżeniu, aczkolwiek powinieneś zawsze zwracać uwagę, aby dołączając dane, użyć dwóch znaków większości, a nie jednego. Jeżeli przypadkowo użyjesz tylko jednego znaku większości, a zmienna noclobber nie jest ustawiona, taka wpadka zakończy się usunięciem zawartości pliku przez powłokę. Nawet jeżeli zmienna noclobber jest ustawiona, dobrą praktyką jest regularne tworzenie i przechowywanie kopii zapasowych plików, z którymi pracujesz — tak na wszelki wypadek. Opcja noclobber może co prawda uchronić Cię przed przypadkowym nadpisaniem zawartości pliku w wyniku przekierowania strumienia danych ze standardowego wyjścia polecenia, ale nie powstrzyma Cię przed nadpisaniem pliku przy użyciu polecenia cp czy mv. Oba polecenia posiadają opcję -i (ang. interactive), która pomoże Ci uniknąć podobnych sytuacji, prosząc o potwierdzenie zamiaru wykonania takiej operacji przed nadpisaniem pliku. Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Polecenie cp może skasować plik” w rozdziale 3.

DOŁĄCZANIE DANYCH ZE STANDARDOWEGO WYJŚCIA DO ISTNIEJĄCEGO PLIKU Użycie symbolu dołączania danych (>>) informuje powłokę, że dane ze standardowego wyjścia polecenia powinny być dołączane na końcu istniejącego pliku, pozostawiając tym samym dotychczasową zawartość w nienaruszonym stanie. Wykorzystanie tego symbolu daje wygodny sposób na łączenie zawartości dwóch plików w jeden większy plik. Polecenia przedstawione poniżej ilustrują sposób użycia symbolu dołączania danych. Drugie polecenie wykonuje operację łączenia plików, o której mówiliśmy w poprzedniej ramce z ostrzeżeniem. $ cat To są $ cat $ cat To są To są

pomarańcze pomarańcze gruszki >> pomarańcze pomarańcze pomarańcze gruszki

174  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX Pierwsze polecenie wyświetla zawartość pliku pomarańcze. Drugie polecenie dołącza zawartość pliku gruszki do zawartości pliku pomarańcze, a ostatnie polecenie wyświetla rezultat tej operacji. Na rysunku 5.11 pokazano, w jaki sposób możesz utworzyć plik zawierający datę i czas (wyniki działania polecenia date), po którym następuje lista użytkowników zalogowanych do systemu (wyniki działania polecenia who). Pierwsze polecenie w tym przykładzie przekierowuje strumień danych ze standardowego wyjścia polecenia date do pliku o nazwie zalogowani_użytkownicy, a potem do wyświetlenia zawartości pliku zostaje użyte polecenie cat. Następne polecenie dołącza do pliku zalogowani_użytkownicy wyniki działania polecenia who i wreszcie ostatnie polecenie cat wyświetla finalną zawartość pliku składającą się z wyników działania dwóch poleceń. $ date > zalogowani_użytkownicy $ cat zalogowani_użytkownicy nie, 27 mar 2011, 14:31:18 CET $ who >> zalogowani_użytkownicy $ cat zalogowani_użytkownicy nie, 27 mar 2011, 14:31:18 CET mateusz tty1 2011-03-27 05:00(:0) kuba pts/4 2011-03-27 12:23(:0.0) kuba pts/5 2011-03-27 12:33(:0.0) dawid pts/7 2011-03-26 08:45 (172.16.192.1)

Rysunek 5.11. Przekierowanie i dołączanie strumienia danych z wyjścia polecenia

URZĄDZENIE /DEV/NULL — JAK SPOWODOWAĆ, ABY DANE ZNIKNĘŁY Urządzenie /dev/null jest odbiorcą danych (ang. data sink), znanym również pod nazwą kosza bitowego (ang. bit bucket) lub po prostu czarnej dziury. Jeżeli dane napływające ze standardowego wyjścia jakiegoś polecenia nie są Ci do niczego potrzebne lub nie chcesz, aby były wyświetlane, możesz przekierować je do urządzenia /dev/null, gdzie po prostu znikną bez śladu: $ echo "Cześć! Jak się masz?" > /dev/null $

Kiedy spróbujesz odczytać jakieś dane z urządzenia /dev/null, otrzymasz pusty ciąg znaków. Polecenia przedstawione poniżej obcinają zawartość pliku wiadomości do zera, przy zachowaniu właściciela pliku i wszystkich praw dostępu: $ ls -lh wiadomości -rw-rw-r--. 1 mateusz pubs 125K 03-16 14:30 wiadomości $ cat /dev/null > wiadomości $ ls -lh wiadomości -rw-rw-r--. 1 mateusz pubs 0 03-16 14:32 wiadomości

POTOKI DANYCH Powłoka systemu wykorzystuje potok danych do połączenia standardowego wyjścia jednego polecenia ze standardowym wejściem innego polecenia. Użycie potoku ma dokładnie taki sam efekt jak przekierowanie standardowego wyjścia jednego polecenia do pliku i następnie użycie tego pliku do przekazania danych na standardowe wejście innego polecenia. Wykorzystanie potoku znacznie upraszcza sprawę i pozwala na uniknięcie wydawania osobnych poleceń i tworzenia plików tymczasowych. Symbolem potoku jest pionowa belka (|). Składnia wiersza poleceń wykorzystującego potok jest następująca: polecenie_a [argumenty] | polecenie_b [argumenty]

Wykonanie polecenia o takiej składni (z użyciem potoku) ma dokładnie taki sam efekt jak wykonanie następującej sekwencji trzech poleceń: polecenie_a [argumenty] > temp polecenie_b [argumenty] < temp rm temp

Standardowe wejście i standardowe wyjście danych  175

W powyższej sekwencji poleceń pierwsze polecenie przekierowuje standardowe wyjście polecenia polecenie_a do tymczasowego pliku o nazwie temp. Drugie polecenie przekierowuje standardowe wejście polecenia polecenie_b tak, aby pobierało dane z pliku temp, i wreszcie trzecie, ostatnie polecenie, usuwa plik temp. Jak widać, polecenie wykorzystujące potok jest nie tylko łatwiejsze w użyciu, ale również bardziej wydajne, ponieważ nie wymaga tworzenia i następnie usuwania pliku tymczasowego.

INFORMACJE DODATKOWE Ujmując precyzyjniej, potok powłoki bash składa się z jednego lub więcej prostych poleceń rozdzielonych operatorami kontrolnymi | lub &. Składnia potoku została przedstawiona poniżej: [czas] [!] polecenie1 [| & polecenie2 ...]

W powyższym wierszu czas oznacza opcjonalne narzędzie podające informacje o zasobach systemowych używanych przez potok, ! to logiczna negacja stanu kończącego potok, natomiast polecenia to proste polecenia rozdzielone operatorami | lub |&. Operator kontrolny | przekazuje standardowe dane wyjściowe polecenia1 jak standardowe dane wejściowe polecenia2. Operator kontrolny |& to skrócona wersja zapisu 2>&1 | (patrz rozdział 8.); przekazuje on standardowe dane wyjściowe i strumień błędów polecenia1 do standardowego wejścia polecenia2. Kod wyjścia potoku to po prostu kod wyjścia ostatniego prostego polecenia, o ile nie jest ustawiona pipefail (patrz rozdział 8.) — wówczas kodem wyjścia będzie kod ostatniego polecenia, którego wykonanie zakończyło się niepowodzeniem (zwróciło niezerową wartość dla kodu wyjścia), lub zero, jeśli wykonanie wszystkich poleceń zakończyło się powodzeniem.

PRZYKŁADY UŻYCIA POTOKÓW DANYCH Potoków możesz używać ze wszystkimi poleceniami systemu Linux, które akceptują dane z pliku określonego w wierszu poleceń lub ze standardowego wejścia. Oprócz tego potoków możesz użyć również z poleceniami, które akceptują dane tylko ze standardowego wejścia. Na przykład polecenie tr (ang. translate) pobiera dane wyłącznie ze standardowego wejścia. W najprostszym przypadku składnia tego polecenia jest następująca:

Polecenie tr

tr ciągznaków1 ciągznaków2

Polecenie tr pobiera dane ze standardowego wejścia i wyszukuje znaki, które odpowiadają znakom w łańcuchu ciągznaków1. Jeżeli taki znak zostanie odnaleziony, polecenie zamienia znak z łańcucha ciągznaków1 na odpowiadający mu znak z łańcucha ciągznaków2 (pierwszy znak z łańcucha ciągznaków1 zostaje zamieniony na pierwszy znak z łańcucha ciągznaków2 i tak dalej). Polecenie tr wysyła wyniki swojego działania na standardowe wyjście. W obu przykładach przedstawionych poniżej polecenie tr wyświetla zawartość pliku abstrakcja, w którym litery a, b i c zostały zamienione odpowiednio na litery A, B lub C: $ cat abstrakcja abc abc $ cat abstrakcja | tr abc ABC ABC ABC $ tr abc ABC < abstrakcja ABC ABC

Polecenie tr w żaden sposób nie zmienia zawartości oryginalnego pliku — nie może zmienić oryginalnego pliku, ponieważ „nie wie”, skąd przesyłane są dane, które pojawiają się na jego wejściu. Polecenie lpr (ang. line printer) akceptuje dane zarówno z pliku, jak i standardowego wejścia. Jeżeli w wierszu poleceń po nazwie polecenia lpr wpiszesz nazwę pliku, to po uruchomieniu polecenia plik zostanie umieszczony w kolejce drukarki. Jeżeli w wierszu poleceń nie podasz nazwy pliku, polecenie lpr będzie pobierało dane ze standardowego wejścia. Dzięki takiemu rozwiązaniu możesz użyć potoku do przesyłania danych do tego polecenia. Pierwszy zestaw poleceń przedstawiony

Polecenie lpr

176  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX na rysunku 5.12 pokazuje, w jaki sposób możesz użyć polecenia ls, polecenia lpr oraz pliku tymczasowego (temp) do wysłania listy plików znajdujących się w bieżącym katalogu na drukarkę. Jeżeli plik o nazwie temp już istnieje, to uruchomienie pierwszego polecenia spowoduje nadpisanie jego zawartości. Drugi zestaw poleceń wykorzystuje potok do bezpośredniego przesłania listy plików (z pominięciem pliku tymczasowe) na wejście polecenia lpr. $ ls > temp $ lpr temp $ rm temp

lub $ ls | lpr

Rysunek 5.12. Potok

Polecenia przedstawione na rysunku 5.13 powodują przekierowanie standardowego wyjścia polecenia who do pliku o nazwie temp i następnie wyświetlają posortowaną zawartość tego pliku. Polecenie sort (patrz rozdział 3.) pobiera dane z pliku określonego w wierszu poleceń lub — kiedy taki plik nie zostanie podany — ze standardowego wejścia, a wyniki swojego działania przesyła na standardowe wyjście. Polecenie sort przedstawione na rysunku 5.13 pobiera dane ze standardowego wejścia, które jest przekierowane tak, aby pobierać dane z pliku temp. Wyjście polecenia sort, czyli posortowana alfabetycznie lista aktualnie zalogowanych użytkowników, jest przesyłane na ekran. Ponieważ polecenie sort pobiera dane albo ze standardowego wejścia, albo z pliku określonego w wierszu polecenia, usunięcie symbolu < z polecenia na rysunku 5.13 nie zmieni w niczym wyników działania polecenia

Polecenie sort

$ who > temp $ sort < temp kuba pts/4 kuba pts/5 mateusz tty1 dawid pts/7 $ rm temp

2011-03-24 2011-03-24 2011-03-24 2011-03-23

12:23 12:33 05:00 08:45

Rysunek 5.13. Użycie pliku tymczasowego do przechowywania wyników pośrednich

Na rysunku 5.14 przedstawiono sposób na uzyskanie takiego samego rezultatu, ale bez potrzeby tworzenia pliku tymczasowego, przechowującego wyniki pośrednie. Dzięki użyciu potoku powłoka bezpośrednio przekierowuje standardowe wyjście polecenia who na standardowe wejście polecenia sort. Polecenie sort pobiera dane ze standardowego wejścia, ponieważ w wierszu poleceń nie została podana nazwa pliku. $ who | sort kuba pts/4 kuba pts/5 mateusz tty1 dawid pts/7

2011-03-24 2011-03-24 2011-03-24 2011-03-23

12:23 12:33 05:00 08:45

Rysunek 5.14. Użycie potoku zastępuje tworzenie pliku tymczasowego

Jeżeli w systemie zalogowanych jest bardzo wielu użytkowników, a potrzebne Ci są informacje tylko na temat jednego z nich, możesz przy użyciu potoku przesłać dane z wyjścia polecenia who na wejście polecenia grep (patrz rozdział 3. i część VI książki). Polecenie grep wyświetla tylko wiersze zawierające podany przez Ciebie ciąg znaków — w tym przypadku jest to mateusz:

Polecenie grep

$ who | grep 'mateusz' mateusz tty1 2011-03-24 05:00

Standardowe wejście i standardowe wyjście danych  177

Innym sposobem radzenia sobie z dużą ilością danych, które nie mieszczą się jednocześnie na ekranie (na przykład takich jak lista plików zatłoczonego katalogu), jest zastosowanie potoku do przesłania wyników na wejście polecenia less lub more (patrz rozdział 3.).

Polecenia less i more

$ ls | less

Polecenie less wyświetla tekst po jednym ekranie na raz. Aby wyświetlić kolejny ekran danych, musisz nacisnąć klawisz Spacja. Aby wyświetlić kolejny wiersz danych, naciśnij klawisz Enter. Jeżeli chcesz wyświetlić tekst pomocy dla tego polecenia, naciśnij klawisz H, a jeżeli chcesz zakończyć wyświetlanie danych, naciśnij klawisz Q.

INFORMACJE DODATKOWE Symbol potoku (|) oznacza kontynuację. Dlatego też poniższe polecenie: $ who | grep 'dawid' dawid tty1 2013-03-24 05:00

odpowiada poniższym poleceniom: $ who | $ grep 'dawid' dawid tty1 2013-03-24 05:00

Kiedy powłoka przetwarza wiersz kończący się symbolem potoku, to wymaga otrzymania dalszych danych wejściowych, zanim przystąpi do wykonania polecenia. W środowisku interaktywnym następuje wyświetlenie kolejnego znaku zachęty (>, patrz rozdział 8.) widocznego w powyższym poleceniu. Natomiast w skrypcie powłoki kolejny wiersz jest przetwarzany jako kontynuacja wiersza zakończonego symbolem potoku. Więcej informacji na temat operatorów kontrolnych i wyraźnej kontynuacji wykonywania poleceń znajdziesz w rozdziale 10.

FILTRY Filtr jest poleceniem, które przetwarza zgodnie z określonymi regułami wejściowy strumień danych i tworzy w ten sposób nowy, wyjściowy strumień danych. Wiersz poleceń zawierający filtry wykorzystuje potoki do połączenia standardowego wyjścia jednego polecenia ze standardowym wejściem innego polecenia. Kolejny potok łączy standardowe wyjście pierwszego filtra ze standardowym wejściem kolejnego polecenia. Nie wszystkie polecenia mogą być używane jako filtry. W przykładzie przedstawionym poniżej polecenie sort spełnia rolę filtra, który pobiera na wejście dane ze standardowego wyjścia polecenia who i wykorzystuje potok do wysłania posortowanych wyników działania na drukarkę: $ who | sort | lpr

Powyższy przykład demonstruje niezwykłe możliwości powłoki połączone z wszechstronnością narzędzi systemu Linux. Trzy narzędzia, who, sort oraz lpr, które przecież nie zostały specjalnie zaprojektowane do współpracy ze sobą, w całkowicie konwencjonalny sposób korzystają ze standardowego wejścia i standardowego wyjścia. Jednak dzięki temu, że powłoka w odpowiedni sposób zarządza przepływem strumieni danych wejściowych i wyjściowych, możesz połączyć te narzędzia razem w wierszu poleceń i osiągnąć żądany rezultat. Polecenie tee kopiuje dane ze standardowego wejścia i przesyła je zarówno do pliku, jak i do standardowego wyjścia. Nazwa tego polecenia bardzo trafnie odzwierciedla jego rolę2 — pobiera ono pojedynczy strumień danych z wejścia i przesyła w dwóch różnych kierunkach. W przykładzie na rysunku 5.15 wyjście polecenia who zostaje za pośrednictwem potoku przesłane na standardowe wejście polecenia tee, które zapisuje jedną kopię strumienia danych przesyłanych na wejście w pliku

Polecenie tee

2

z ang. tee — trójnik — przyp. tłum.

178  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX who.wyniki, a drugą kopię wysyła na standardowe wyjście. Z kolei standardowe wyjście polecenia tee za pośrednictwem kolejnego potoku przesyłane jest na standardowe wejście polecenia grep, które wyświetla na ekranie tylko wiersze zawierające ciąg znaków mateusz. Jeżeli chcesz, aby polecenie tee dołączało dane do istniejącego pliku, zamiast go nadpisywać, powinieneś użyć opcji -a (ang. append). $ who | tee who.wyniki | grep mateusz mateusz tty1 2011-03-24 05:00 $ cat who.wyniki mateusz tty1 2011-03-24 05:00 kuba pts/4 2011-03-24 12:23 kuba pts/5 2011-03-24 12:33 dawid pts/7 2011-03-23 08:45

Rysunek 5.15. Polecenie tee przesyła dane do pliku i na standardowe wyjście

INFORMACJE DODATKOWE LISTY Lista to jeden lub więcej potoków (a także prostych poleceń) rozdzielonych następującymi operatorami kontrolnymi: &, && lub ||. Operatory kontrolne && i || mają takie samo pierwszeństwo. Za nimi są operatory ; i &, które również mają takie samo pierwszeństwo. Operatory kontrolne ; i & zostały omówione w rozdziale 8. Więcej informacji na temat operatorów kontrolnych i wyraźnej kontynuacji wykonywania poleceń znajdziesz w rozdziale 10. Składnia listy typu AND przedstawia się następująco: potok1 && potok2

Trzeba pamiętać, że potok2 będzie wykonany tylko i wyłącznie wtedy, gdy potok1 zwróci wartość true (zero) jako kod stanu zakończenia działania. W przedstawionym poniżej przykładzie wykonanie pierwszego polecenia listy kończy się niepowodzeniem (następuje wyświetlenie komunikatu błędu) i powłoka nie wykona drugiego polecenia (cd /nowykatalog — ponieważ nie zostało wykonane, to nie będzie wyświetlony komunikat błędu): $ mkdir /nowykatalog && cd /nowykatalog mkdir: nie można utworzyć katalogu `/nowykatalog': Brak dostępu

Kod wyjścia listy typu AND i OR odpowiada kodowi ostatniego polecenia wykonanego w liście. W przypadku powyższej listy kod ma wartość false, ponieważ jako ostatnie zostało uruchomione polecenie mkdir i jego wykonanie zakończyło się niepowodzeniem. Składnia listy typu OR przedstawia się następująco: potok1 || potok2

Trzeba pamiętać, że potok2 będzie wykonany tylko i wyłącznie wtedy, gdy potok1 zwróci wartość false (niezerowa) jako kod wyjścia. W przedstawionym poniżej przykładzie wykonanie pierwszego polecenia (ping, testowanie połączenia ze zdalnym komputerem i przekierowanie standardowych danych wyjściowych oraz komunikatów błędów do /dev/null) listy kończy się niepowodzeniem, więc powłoka wykonuje drugie polecenie (wyświetlające komunikat). Jeżeli wykonanie pierwszego polecenia zakończy się powodzeniem, powłoka nie wykona drugiego (a więc nie wyświetli zdefiniowanego w nim komunikatu). Wartością kodu wyjścia listy jest true. $ ping -c1 station &>/dev/null || echo "komputer jest niedostępny" komputer jest niedostępny

Więcej informacji znajdziesz w rozdziale 8.

Uruchamianie poleceń pracujących w tle  179

URUCHAMIANIE POLECEŃ PRACUJĄCYCH W TLE Wszystkie polecenia omawiane do tej pory pracowały na pierwszym planie. Kiedy uruchamiasz dane polecenie do pracy na pierwszym planie (ang. foreground), powłoka oczekuje, aż zakończy ono pracę, i dopiero wtedy wyświetla znak zachęty i pozwala Ci wpisać następne polecenie. Kiedy uruchamiasz polecenie do pracy w tle, przed wydaniem kolejnego polecenia nie musisz czekać, aż to pierwsze zakończy pracę.

Praca na pierwszym planie

Zadanie (ang. job) to seria jednego lub kilku poleceń, które mogą być ze sobą połączone za pomocą potoków. W danym oknie lub na ekranie może pracować tylko jedno zadanie pierwszoplanowe, ale możesz uruchamiać wiele zadań pracujących równolegle w tle. Uruchamiając kilka zadań działających w tym samym czasie, wykorzystujesz jedną z najważniejszych cech systemu Linux — wielozadaniowość. Uruchamianie poleceń w tle może być bardzo użyteczne w sytuacji, kiedy dane polecenie będzie działało przez długi czas i nie będzie wymagało w tym czasie nadzoru ani interwencji użytkownika. Po uruchomieniu takie zadanie pozostawia wolny ekran, dzięki czemu możesz użyć go do dalszej pracy.

Zadania

Aby uruchomić wybrane polecenie do pracy w tle, powinieneś zakończyć wiersz polecenia znakiem & i dopiero wtedy nacisnąć klawisz Enter. Powłoka przypisze do takiego zadania odpowiedni numer i wyświetli go na ekranie w nawiasach kwadratowych jako numer zadania (ang. job number). Zaraz po identyfikatorze zadania wyświetlany jest identyfikator procesu (PID — ang. Process Identification Number), przypisywany przez system operacyjny. Każdy z tych numerów w jednoznaczny sposób identyfikuje polecenie działające w tle. Po uruchomieniu zadania powłoka ponownie wyświetla znak zachęty i możesz wpisywać kolejne polecenie. Kiedy zadanie działające w tle zakończy działanie, powłoka wyświetla na ekranie odpowiedni komunikat, podając zarówno identyfikator zadania, jak i wiersz polecenia użyty do jego uruchomienia.

Identyfikator zadania oraz identyfikator procesu (PID)

Polecenie przedstawione na kolejnym przykładzie zostaje uruchomione w tle i za pośrednictwem potoku wysyła wyniki działania polecenia ls na wejście polecenia lpr, które z kolei przesyła je na drukarkę. $ ls -l | lpr & [1] 22092 $

Ciąg znaków [1] pojawiający się po uruchomieniu polecenia oznacza, że powłoka przypisała do tego zadania numer 1. Numer 22092 jest identyfikatorem procesu (PID) przypisanym do pierwszego polecenia tego zadania. Kiedy zadanie zakończy działanie, na ekranie pojawi się komunikat: [1]+ Done

ls -l | lpr

Warto zauważyć, że zamiast ls -l powłoka może wyświetlić nieco inne polecenie, podobne do ls -color=auto -l. Dzieje się tak ze względu na fakt, że polecenie ls jest aliasem (patrz rozdział 8.) polecenia ls --color=auto.

PRZENOSZENIE ZADANIA Z PIERWSZEGO PLANU DO PRACY W TLE W razie potrzeby możesz zawiesić działanie polecenia pracującego na pierwszym planie (zatrzymać jego działanie), naciskając klawisz zawieszenia (zazwyczaj jest to kombinacja klawiszy Ctrl+Z). W odpowiedzi powłoka zatrzyma realizację zadania i odłączy jego standardowe wejście od klawiatury. Teraz możesz przenieść wstrzymane zadanie do pracy w tle i wznowić jego działanie poleceniem bg, po którym następuje numer zadania. Jeżeli w danej chwili istnieje tylko jedno zawieszone zadanie, to wywołując polecenie bg, nie musisz podawać numeru zadania.

Kombinacja klawiszy Ctrl+Z oraz polecenie bg

Uruchamiając zadanie do pracy w tle, powinieneś odpowiednio przekierować jego wyjście, tak aby wyświetlane przez to polecenie informacje nie kolidowały z tym, co będziesz robił w międzyczasie na pierwszym planie. Więcej szczegółowych informacji na temat zadań pracujących w tle znajdziesz w sekcji „Separacja i grupowanie poleceń” w rozdziale 8.

180  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX Tylko zadania pracujące na pierwszym planie mogą pobierać dane wpisywane z klawiatury. Aby podłączyć klawiaturę do zadania pracującego w tle, musisz najpierw przenieść takie zadanie do pracy na pierwszym planie. Aby to zrobić, kiedy istnieje tylko jedno zadanie pracujące w tle, wpisz polecenie fg bez żadnych argumentów. Jeżeli jednak w tle pracuje więcej zadań, powinieneś wpisać polecenie fg (lub znak procentu %), po którym następuje numer zadania, które chcesz przenieść do pracy na pierwszym planie. Powłoka wyświetli polecenie, którego użyłeś do uruchomienia tego zadania (w naszym przykładzie poniżej jest to mojepolecenie), i będziesz mógł wpisać dowolne dane, których potrzebuje program:

Polecenie fg

bash $ fg 1 mojepolecenie

POLECENIE KILL — ZAKOŃCZENIE ZADANIA DZIAŁAJĄCEGO W TLE Klawisz przerwania działania (zazwyczaj jest to Ctrl+C) nie może przerwać realizacji procesu działającego w tle — do tego celu musisz użyć polecenia kill (patrz rozdział 18.). Aby to zrobić, wpisz w wierszu poleceń polecenie kill, a po nim albo identyfikator procesu (PID), który chcesz przerwać, albo znak % i odpowiedni numer zadania. Jeżeli nie pamiętasz, jaki identyfikator PID miał dany proces, możesz do sprawdzenia użyć polecenia ps (ang. process status, patrz rozdział 8.). W przykładzie przedstawionym poniżej polecenie find uruchomione zostaje do pracy w tle. Następnie przy użyciu polecenia ps sprawdzamy identyfikator PID tego procesu i wreszcie kończymy jego działanie poleceniem kill:

Określanie identyfikatora PID procesu przy użyciu polecenia ps

$ find / -name notatka55 > notatka.wyniki & [1] 18228 $ ps | grep find 18228 pts/10 00:00:01 find $ kill 18228 [1]+ Zakończony find / -name notatka55 > notatka.wyniki $

Jeżeli nie pamiętasz, jaki numer został przydzielony do danego zadania pracującego w tle, możesz użyć polecenia jobs do wyświetlenia listy numerów zadań. Kolejny przykład jest bardzo podobny do poprzedniego, z tym tylko, że do przerwania działania zadania zamiast identyfikatora procesu wykorzystuje numer zadania. Pamiętaj, że czasami informacja o zakończeniu działania zadania nie pojawia się aż do momentu ponownego naciśnięcia klawisza Enter (po naciśnięciu klawisza Enter, którym uruchomiłeś polecenie kill).

Określanie numeru zadania przy użyciu polecenia jobs

$ find / -name notatka55 > notatka.wyniki & [1] 18236 $ bigjob & [2] 18237 $ jobs [1]- Running [2]+ Running $ kill %1 $ [1]- Zakończony $

find / -name notatka55 > notatka.wyniki & bigjob & find / -name notatka55 > notatka.wyniki

GENEROWANIE I ROZWIJANIE NAZW PLIKÓW Kiedy przekażesz powłoce skróconą nazwę pliku, zawierającą znaki specjalne, nazywane również metaznakami (ang. metacharacters), powłoka może wygenerować nazwy plików, które pasują do nazw istniejących plików. Takie znaki są często nazywane również symbolami wieloznacznymi (ang. wildcard), ponieważ działają w sposób nieco przypominający funkcje jokera w talii kart. Jeżeli jeden z tych znaków pojawi się w argumencie w wierszu polecenia, powłoka

Symbole wieloznaczne i dopasowywanie

Generowanie i rozwijanie nazw plików  181

rozwinie ten argument do postaci posortowanej listy nazw plików i przekaże go do wywoływanego programu. Nazwy plików zawierające znaki specjalne nazywane są również wieloznacznymi odwołaniami do plików (ang. ambiguous file references), ponieważ w przeciwieństwie do prostych nazw plików nie odnoszą się tylko do jednego pliku. Sposób przetwarzania takich nazw przez powłokę nosi nazwę rozwijanie ścieżki do pliku (ang. pathname expansion) lub dopasowywanie nazw plików (ang. globbing). Wieloznaczne odwołania do plików pozwalają na szybkie wskazanie całej grupy plików o podobnych nazwach, oszczędzając konieczności wpisywania pojedynczo ich nazw. Zastosowanie odwołań wieloznacznych pozwala również na odnalezienie pliku, którego pełnej, dokładnej nazwy nie pamiętasz. Jeżeli żaden plik nie pasuje do danego odwołania wieloznacznego, powłoka zazwyczaj przekazuje całe, nierozwinięte odwołanie (łącznie ze wszystkimi znakami specjalnymi) do wywoływanego polecenia. Więcej informacji na temat techniki generowania ciągów tekstowych, które niekoniecznie dopasowują nazwy plików, znajdziesz w rozdziale 8.

ZNAK SPECJALNY — ? Znak zapytania (?) jest znakiem specjalnym, który powoduje, że powłoka generuje listę pasujących do wzorca nazw plików. Znak zapytania zastępuje dowolny znak nazwy istniejącego pliku. W przykładzie przedstawionym poniżej taki znak specjalny został użyty przy wywołaniu polecenia lpr: $ lpr memo?

Powłoka rozwija argument memo? i generuje listę plików znajdujących się w bieżącym katalogu roboczym, których nazwy składają się ze słowa memo, po którym następuje dodatkowy, pojedynczy znak. Po zakończeniu powłoka przekazuje wygenerowaną listę do polecenia lpr, które tak naprawdę „nie wie”, że lista plików, którą otrzymało, została wygenerowana przez powłokę. Jeżeli żadna nazwa pliku nie pasuje do podanego wzorca, powłoka przekazuje do polecenia lpr ciąg znaków memo? lub — jeżeli zostanie tak wcześniej skonfigurowana — pusty ciąg znaków (patrz opcja nullglob w rozdziale 8.). W przykładzie przedstawionym poniżej pierwsze polecenie ls wyświetla nazwy wszystkich plików znajdujących się w bieżącym katalogu roboczym, a kolejne wyświetla wszystkie pliki pasujące do wzorca memo?: $ ls mem memo12 memo9 memomax newmemo5 memo memo5 memoa memos $ ls memo? memo5 memo9 memoa memos

Wieloznaczne odwołanie memo? nie pasuje do plików o nazwach mem, memo, memo12, memomax ani newmemo5. Znaku zapytania możesz użyć również wewnątrz odwołania wieloznacznego: $ ls 7maj4raport maj4raport majqraport maj_raport maj14raport maj4raport.79 majraport maj.raport $ ls maj?raport maj4raport majqraport maj_raport maj.raport

Polecenie echo

Aby zdobyć trochę doświadczenia w rozwijaniu nazw plików, możesz skorzystać z poleceń

echo oraz ls. Polecenie echo wyświetla nazwy plików przekazywanych przez powłokę do polecenia: $ echo maj?raport maj4raport majqraport maj_raport maj.raport

Powłoka najpierw rozwija wieloznaczne odwołanie do pliku do postaci listy plików znajdujących się w bieżącym katalogu roboczym, których nazwy pasują do wzorca maj?raport. Następnie wygenerowana lista zostaje przekazana do polecenia echo dokładnie tak, jakby została podana jako argument wywołania i w efekcie polecenie echo wyświetla listę na ekranie.

182  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX Znak zapytania nie zastępuje znaku kropki znajdującej się na początku nazwy pliku (wskazującej, że plik jest ukryty, patrz rozdział 4.). Jeżeli chcesz w taki sposób wyszukiwać pliki, których nazwy rozpoczynają się od kropki, musisz wprost wpisać taką kropkę we wzorcu wieloznacznego odwołania do pliku.

ZNAK SPECJALNY — * Gwiazdka (*) spełnia podobną funkcję jak znak zapytania, z tym że w nazwie pliku zastępuje dowolną liczbę znaków, łącznie z ciągiem znaków o zerowej długości. W przykładzie przedstawionym poniżej najpierw wyświetlana jest lista wszystkich plików znajdujących się w katalogu roboczym, a następnie wykonywane są kolejno polecenia, które wyświetlają odpowiednio wszystkie pliki, których nazwa rozpoczyna się od ciągu znaków memo, kończy ciągiem znaków mo oraz zawiera ciąg znaków alx: $ ls amemo memalx memo.0612 memoalx.0620 memorandum sallymemo mem memo memoa memoalx.keep memosally user.memo $ echo memo* memo memo.0612 memoa memoalx.0620 memoalx.keep memorandum memosally $ echo *mo amemo memo sallymemo user.memo $ echo *alx* memalx memoalx.0620 memoalx.keep

Wieloznaczne odwołanie do pliku memo* nie pasuje do plików o nazwach amemo, mem, sallymemo czy user.memo. Podobnie jak jest w przypadku znaku zapytania, gwiazdka nie zastępuje kropki znajdującej się na początku nazwy pliku. Użycie opcji -a powoduje, że polecenie ls wyświetla pliki ukryte (patrz rozdział 4.). Polecenie echo * nie wyświetla plików . (bieżący katalog roboczy), .. (katalog nadrzędny), .aaa czy .profile. Dla porównania polecenie echo .* wyświetla tylko wymienione cztery nazwy plików: $ ls aaa memo.0612 memo.sally raport sally.0612 saturday thurs $ ls -a . aaa memo.0612 .profile sally.0612 thurs .. .aaa memo.sally raport saturday $ echo * aaa memo.0612 memo.sally raport sally.0612 saturday thurs $ echo .* . .. .aaa .profile

W następnym przykładzie odwołanie .p* nie pasuje do plików o nazwach memo.0612, private, reminder czy raport. Użycie komendy ls .* powoduje, że polecenie ls oprócz zawartości katalogu . (bieżący katalog roboczy) oraz .. (katalog nadrzędny) wyświetla również pliki o nazwach .private oraz .profile. Kiedy polecenie echo zostanie wywołane z takim samym argumentem, wyświetlone zostają tylko nazwy plików (łącznie z nazwami katalogów) znajdujących się w bieżącym katalogu roboczym, które rozpoczynają się od kropki, ale już zawartość katalogów nie zostanie wyświetlona. $ ls -a . .. memo.0612 private .private .profile reminder raport $ echo .p* .private .profile $ ls .* .private .profile

Generowanie i rozwijanie nazw plików  183

.: memo.0612 private reminder raport ..: ... $ echo .* . .. .private .profile

Z możliwości, jakie dają wieloznaczne odwołania do plików, możesz skorzystać podczas tworzenia konwencji nazewnictwa plików w Twoim systemie. Na przykład: jeżeli przyjmiesz, że wszystkie pliki tekstowe zapisywane na dysku będą miały rozszerzenie .txt, będziesz mógł się odwoływać do takich plików poprzez wzorzec *.txt. W kolejnym przykładzie użyjemy tej konwencji do wysłania wszystkich plików tekstowych znajdujących się w bieżącym katalogu roboczym na drukarkę. Dodanie znaku & na końcu polecenia powoduje, że zostanie ono uruchomione w tle. $ lpr *.txt &

WSKAZÓWKA Powłoka rozwija wieloznaczne odwołania do plików Wieloznaczne odwołania do plików są przetwarzane przez powłokę systemu, a nie przez wywoływany program. W przykładach zamieszczonych w tej sekcji użyte narzędzia (ls, cat, echo czy lpr) nigdy nie „widziały” wieloznacznych odwołań do plików. Powłoka rozwija napotkane wieloznaczne odwołania do plików i przekazuje poleceniom gotowe, wygenerowane listy nazw plików. Zjawisko to zostało zilustrowane w poprzednich przykładach, gdzie polecenie echo wyświetlało po prostu swoje argumenty, a nigdy wieloznaczne odwołania do plików.

ZNAKI SPECJALNE — [ ] Para nawiasów kwadratowych otaczających listę znaków powoduje, że powłoka dopasowuje nazwy plików zawierające pojedyncze znaki z listy. Na przykład wzorzec memo? pasuje do plików o nazwach składających się z ciągu znaków memo oraz dowolnego znaku, ale już wzorzec memo[17a] jest znacznie bardziej restrykcyjny — pasują do niego tylko i wyłącznie pliki o nazwach memo1, memo7 i memoa. Użycie nawiasów kwadratowych definiuje klasę znaków, składającą się ze wszystkich znaków znajdujących się wewnątrz nawiasów (uwaga — w terminologii GNU używamy określenia lista znaków, ponieważ klasa znaków w terminologii GNU oznacza coś zupełnie innego). Powłoka systemu rozwija argument zawierający definicję klasy znaków poprzez podstawianie kolejnych znaków z klasy po jednym do wzorca nazwy pliku. Po zakończeniu generowania listy pasujących plików powłoka systemu przekazuje ją do wywoływanego programu. Każda definicja klasy znaków może zastąpić tylko jeden znak w nazwie pliku. Nawiasy kwadratowe i ich zawartość spełniają taką rolę jak znak zapytania zastępujący tylko znaki z tej klasy. Pierwsze z poleceń przedstawionych poniżej wyświetla listę wszystkich plików znajdujących się w bieżącym katalogu roboczym, których nazwy rozpoczynają się od liter a, e, i, o lub u. Drugie polecenie wyświetla zawartości plików o nazwach strona2.txt, strona4.txt, strona6.txt oraz strona8.txt. $ echo [aeiou]* ... $ less strona[2468].txt ...

Myślnik umieszczony wewnątrz nawiasów kwadratowych reprezentuje zakres znaków w definicji klasy. Na przykład wzorzec [6-9] odpowiada klasie [6789], [a-z] reprezentuje wszystkie małe litery alfabetu łacińskiego, a wzorzec [a-zA-Z] reprezentuje wszystkie małe i wszystkie wielkie litery alfabetu łacińskiego.

184  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX Polecenia przedstawione poniżej ilustrują trzy sposoby wydrukowania plików o nazwach part0, part1, part2, part3 oraz part5. Każdy z przedstawionych poniżej wierszy poleceń powoduje, że powłoka wywołuje polecenie lpr z pięcioma nazwami plików: $ lpr part0 part1 part2 part3 part5 $ lpr part[01235] $ lpr part[0-35]

W pierwszym wierszu definiujemy wprost pięć nazw plików. W drugim i trzecim wierszu wykorzystujemy wieloznaczne odwołania do plików zawierające odpowiednie definicje klas znaków. W drugim wierszu powłoka rozwija argument polecenia tak, aby zawierał wszystkie pliki, których nazwa rozpoczyna się od ciągu znaków part i kończy dowolnym znakiem z klasy znaków. Poszczególne znaki klasy znaków zostały zdefiniowane wprost jako 0, 1, 2, 3 oraz 5. W trzecim wierszu również wykorzystujemy definicję klasy znaków, ale tym razem w skład klasy wchodzą wszystkie znaki z zakresu od 0 do 3 oraz dodatkowo znak 5. Polecenie przedstawione poniżej drukuje 39 plików, o kolejnych nazwach od part0 do part38: $ lpr part[0-9] part[12][0-9] part3[0-8]

Pierwsze z poleceń przedstawionych poniżej wyświetla listę plików znajdujących się w bieżącym katalogu roboczym, których nazwy rozpoczynają się od liter od a do m. Drugie polecenie wyświetla tylko pliki, których nazwy kończą się znakami x, y lub z. $ echo [a-m]* ... $ echo *[x-z] ...

INFORMACJE DODATKOWE Kiedy wykrzyknik (!) lub daszek (^) występują zaraz po kwadratowym nawiasie otwierającym definicję klasy ([), to taki wzorzec pasuje do wszystkich znaków, które nie zostały wymienione w definicji klasy. Na przykład wzorzec [^tsq]* pasuje do każdego pliku, którego nazwa nie rozpoczyna się od znaków t, s lub q. Przykłady przedstawione poniżej ilustrują, że wzorzec *[^ab] pasuje do nazw plików, które nie kończą się literami a lub b, a wzorzec [^b-d]* pasuje do wszystkich plików, których nazwy nie rozpoczynają się od liter b, c lub d. $ ls aa ab ac ad ba bb bc bd cc dd $ ls *[^ab] ac ad bc bd cc dd $ ls [^b-d]* aa ab ac ad

Jeżeli chcesz w definicji klasy umieścić znak myślnika (-) lub zamykający nawias kwadratowy (]), musisz umieścić takie znaki bezpośrednio przed nawiasem kwadratowym zamykającym definicję klasy.

Kolejny przykład pokazuje, że polecenie ls nie potrafi interpretować wieloznacznych odwołań do plików. Pierwsze polecenie ls jest wywoływane z argumentem ?old. Powłoka rozwija wzorzec ?old do pasującej nazwy pliku, hold, i przekazuje tę nazwę do polecenia ls. Drugie polecenie jest bardzo podobne do pierwszego, z tym że znak zapytania (?) jest tutaj cytowany (czyli poprzedzony znakiem lewego ukośnika; więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Znaki specjalne” w rozdziale 3.). Ponieważ znak zapytania jest cytowany, powłoka nie traktuje go jako znaku specjalnego i po prostu przekazuje do polecenia ls, które jednak generuje komunikat o błędzie informujący, że plik o nazwie ?old nie może zostać odnaleziony (ponieważ plik o takiej nazwie nie istnieje).

Wbudowane polecenia powłoki  185

$ ls ?old hold $ ls \?old ls: ?old: Nie ma takiego pliku ani katalogu

Podobnie jak większość narzędzi i programów systemu Linux, tak i polecenie ls nie potrafi samodzielnie interpretować wieloznacznych odwołań do plików — za taką operację odpowiedzialna jest powłoka systemu.

WBUDOWANE POLECENIA POWŁOKI Wbudowane polecenia powłoki (nazywane również komendami) to po prostu polecenia wbudowane w powłokę systemu Linux. Każda powłoka posiada swój własny zestaw wbudowanych poleceń. Kiedy uruchamiasz polecenie wbudowane, powłoka nie tworzy dla niego nowego procesu, stąd wbudowane polecenia powłoki działają szybciej i mogą mieć wpływ na środowisko danej powłoki. Ponieważ polecenia wbudowane są używane w taki sam sposób jak polecenia zewnętrzne, w większości przypadków nie będziesz nawet wiedział, czy aktualnie używane polecenie jest poleceniem wbudowanym, czy samodzielnym poleceniem zewnętrznym. Na przykład polecenie echo jest wbudowanym poleceniem powłoki. Powłoka systemu zawsze stara się wykonać polecenie wbudowane, zanim zacznie poszukiwać zewnętrznego polecenia czy narzędzia o tej samej nazwie. Więcej szczegółowych informacji na temat wbudowanych poleceń powłoki (łącznie z ich listą) znajdziesz w rozdziale 10. Aby wyświetlić listę wbudowanych poleceń powłoki bash, powinieneś wykonać polecenie info bash shell builtin. Aby wyświetlić strony podręcznika dla poszczególnych poleceń, przenieś kursor na wiersz (opcję menu) *Bash Builtins i naciśnij klawisz Enter. Alternatywnym rozwiązaniem jest przejrzenie podręcznika man dla wbudowanych poleceń powłoki.

Wyświetlanie wbudowanych poleceń powłoki

Możesz użyć opcji help powłoki bash w celu wyświetlenia pomocy dla wbudowanych poleceń powłoki. Więcej informacji na ten temat znajdziesz w rozdziale 2.

Wyświetlanie pomocy dla wbudowanych poleceń powłoki

Aby wyświetlić listę wbudowanych poleceń powłoki tcsh, powinieneś wykonać polecenie man tcsh i odszukać sekcję Builtin commands, używając do tego dwóch wymienionych poleceń: /Builtin commands (wyszukiwanie podanego ciągu tekstowego) i n (przejście do następnego wystąpienia podanego ciągu tekstowego).

Wyświetlanie wbudowanych poleceń powłoki tcsh

PODSUMOWANIE ROZDZIAŁU Powłoka jest interpreterem poleceń systemu Linux. Powłoka monitoruje tekst wpisywany w wierszu poleceń, starając się wyodrębnić nazwy poleceń oraz ich argumenty. Pierwszy argument ma numer 1, drugi numer 2 i tak dalej. Nazwa polecenia jest argumentem o numerze 0. Wiele programów wykorzystuje opcje do modyfikacji sposobu działania polecenia. Większość narzędzi systemu Linux identyfikuje opcje dzięki jednemu lub dwóm kolejnym znakom myślnika. Kiedy wydajesz wybrane polecenie, powłoka próbuje odszukać program wykonywalny o takiej samej nazwie jak wpisane polecenie. Kiedy taki program zostanie odnaleziony, powłoka próbuje go uruchomić. Jeżeli program nie zostanie odnaleziony, powłoka informuje, że nie może znaleźć ani uruchomić takiego polecenia. Jeżeli wywoływane polecenie ma postać prostej nazwy pliku, powłoka próbuje odnaleźć taki program w katalogach zdefiniowanych w zmiennej PATH.

186  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX Podczas wykonywania polecenia powłoka przypisuje wybrany plik lub urządzenie do standardowego wejścia polecenia oraz inny plik do standardowego wyjścia polecenia. Domyślnie powłoka na wejście polecenia kieruje dane napływające z klawiatury, a standardowe wyjście polecenia kieruje na ekran. W razie potrzeby możesz spowodować, że powłoka przekieruje standardowe wejście lub wyjście polecenia do dowolnego pliku lub urządzenia. Możesz również za pomocą potoku połączyć standardowe wyjście jednego polecenia ze standardowym wejściem innego polecenia. Filtr jest poleceniem, które na swoje standardowe wejście pobiera dane ze standardowego wyjścia jednego polecenia, a jego wyniki działania są przesyłane poprzez standardowe wyjście na standardowe wejście drugiego polecenia. Kiedy dane polecenie działa na pierwszym planie, powłoka oczekuje, aż polecenie zakończy działanie i dopiero wtedy wyświetla na ekranie kolejny znak zachęty i pozwala Ci na wpisanie kolejnego polecenia. Kiedy na końcu wiersza polecenia umieścisz znak &, powłoka uruchamia polecenie w tle i od razu wyświetla kolejny znak zachęty. W tle powinieneś uruchamiać polecenia, których realizacja zajmuje dużo czasu, a Ty chcesz wykonywać inne zadania. Wbudowane polecenie jobs wyświetla listę zawieszonych zadań oraz zadań działających w tle wraz z ich numerami. Powłoka używa niektórych znaków specjalnych wpisywanych w wierszu poleceń do rozwijania nazw plików. Znak zapytania zastępuje dowolny pojedynczy znak, a gwiazdka zastępuje dowolną liczbę znaków. Pojedynczy znak może być również reprezentowany przez klasę znaków — listę znaków ujętych w nawiasy kwadratowe. Odwołanie, które wykorzystuje znaki specjalne (symbole wieloznaczne) do skrócenia listy nazw plików w poleceniu, jest nazywane wieloznacznym odwołaniem do plików. Polecenia wbudowane to polecenia, które są wbudowanymi, wewnętrznymi poleceniami powłoki systemu Linux. Każda powłoka posiada własny zestaw poleceń wbudowanych. Kiedy uruchamiasz polecenie wbudowane, powłoka nie uruchamia nowego procesu, stąd polecenia wbudowane działają szybciej i mogą wpływać na środowisko danej powłoki.

POLECENIA I NARZĘDZIA OMAWIANE W TYM ROZDZIALE W tabeli 5.1 zamieszczamy listę narzędzi i poleceń, które były omawiane w tym rozdziale. Tabela 5.1. Nowe narzędzia Narzędzie

Funkcja

tr

Dokonuje transformacji jednego ciągu znaków w drugi.

tee

Przesyła dane ze standardowego wejścia do pliku i na standardowe wyjście.

bg

Przenosi proces do pracy w tle.

fg

Przenosi proces do pracy na pierwszym planie.

jobs

Wyświetla listę zawieszonych zadań oraz zadań działających w tle.

ĆWICZENIA 1. Jakie operacje realizuje powłoka systemu podczas wykonywania polecenia? Co powinieneś zrobić, jeżeli przed wydaniem kolejnego polecenia nie chcesz czekać, aż bieżące polecenie zakończy działanie? 2. Używając polecenia sort jako filtra, zoptymalizuj poniższą sekwencję poleceń: $ sort list > temp $ lpr temp $ rm temp

3. Co to jest identyfikator PID? Dlaczego identyfikatory PID przydają się podczas pracy z zadaniami pracującymi w tle? Jakie narzędzie wyświetla identyfikatory PID działających poleceń?

Ćwiczenia  187

4. Załóżmy, że w katalogu roboczym znajdują się następujące pliki: $ ls intro notesb ref2 notesa ref1 ref3

section1 section3 section4b section2 section4a sentrev

Korzystając z symboli wieloznacznych, napisz polecenia realizujące zadania opisane poniżej. Postaraj się, aby polecenia były jak najkrótsze: a) Wyświetl wszystkie pliki, których nazwy rozpoczynają się od ciągu znaków section. b) Wyświetl tylko pliki o nazwach section1, section2 oraz section3. c) Wyświetl tylko plik o nazwie intro. d) Wyświetl tylko pliki o nazwach section1, section3, ref1 oraz ref3. 5. Zajrzyj do części VI książki lub na strony podręczników info oraz man i spróbuj odszukać polecenie, które: a) Wyświetla numery wierszy napływających na standardowe wejście, które zawierają słowo a lub A. b) Wyświetla tylko takie pliki znajdujące się w bieżącym katalogu roboczym, których nazwy zawierają wzorzec $(. c) Wyświetla listę plików znajdujących się w bieżącym katalogu roboczym posortowaną w odwrotnej kolejności alfabetycznej. d) Wysyła na drukarkę posortowaną według rozmiaru listę plików znajdujących się w bieżącym katalogu roboczym. 6. Napisz polecenie, które: a) Przekieruje standardowe wyjście polecenia sort do pliku o nazwie lista_telefonów. Przyjmij, że plik danych wejściowych nosi nazwę numery. b) W pliku o nazwie permdemos.c zamień wszystkie wystąpienia znaków [ oraz { na znak ( oraz wszystkie wystąpienia znaków ] i } na znak ). Wskazówka: zajrzyj na strony podręcznika man polecenia tr. c) Utwórz plik o nazwie książka, składający się z zawartości dwóch innych plików, o nazwach część1 oraz część2. 7. Polecenia lpr oraz sort mogą pobierać dane z pliku podanego jako argument wywołania w wierszu poleceń lub ze standardowego wejścia. a) Wymień dwa inne polecenia, które działają w podobny sposób. b) Podaj nazwę polecenia, które może pobierać dane tylko i wyłącznie ze standardowego wejścia. 8. Podaj przykład komendy wykorzystującej polecenie grep, gdzie: a) Przekierowane będzie zarówno wejście, jak i wyjście polecenia. b) Przekierowane będzie tylko wejście. c) Przekierowane będzie tylko wyjście. d) Wykorzystywany będzie symbol potoku. W którym z powyższych przypadków polecenie grep będzie wykorzystywane jako filtr? 9. Wyjaśnij komunikat o błędzie przedstawiony poniżej. Jakie nazwy plików wyświetliłoby kolejne polecenie ls? $ ls abc abd abe abf abg abh $ rm abc ab* rm: nie można usunąć 'abc': Nie ma takiego pliku ani katalogu

188  ROZDZIAŁ 5. POWŁOKA SYSTEMU LINUX

ĆWICZENIA ZAAWANSOWANE 10. Kiedy używasz w wierszu polecenia symbolu przekierowania wyjścia (>), powłoka natychmiast tworzy plik wyjściowy, zanim jeszcze zostanie uruchomione samo polecenie. Udowodnij, że takie twierdzenie jest prawdziwe. 11. Eksperymentując ze zmiennymi powłoki, użytkownik kuba w niezamierzony sposób usunął zmienną PATH, ale stwierdził, że ta zmienna w zasadzie do niczego nie jest mu potrzebna. Przedyskutuj wybrane problemy, z którymi ten użytkownik może się zetknąć, i wyjaśnij ich przyczyny. W jaki sposób ten użytkownik może łatwo przywrócić zmienną PATH i nadać jej oryginalną wartość? 12. Załóżmy, że prawa dostępu do pliku pozwalają Ci do niego pisać, ale nie możesz go usunąć. a) Napisz polecenie, które pozwoli Ci usunąć całą zawartość pliku bez wywoływania edytora. b) Wyjaśnij, w jaki sposób możesz mieć uprawnienia do zapisywania pliku, którego nie możesz usunąć. 13. W jaki sposób możesz usunąć przypadkowo utworzony plik, zawierający w nazwie znaki niedrukowalne? 14. Dlaczego ustawienie zmiennej noclobber nie zabezpiecza Cię przed nadpisaniem pliku za pomocą polecenia cp lub mv? 15. Dlaczego nazwy poleceń i plików zazwyczaj nie zawierają spacji? W jaki sposób możesz utworzyć plik, w którego nazwie znajdują się spacje? W jaki sposób możesz usunąć taki plik? (To jest bardziej ćwiczenie teoretyczne niż praktyczne. Jeżeli chcesz spróbować swoich sił w praktyce, utwórz osobny katalog zawierający tylko plik, na którym będziesz eksperymentował). 16. Utwórz plik o nazwie odpowiedź i wykonaj następujące polecenie: $ > odpowiedź.0102 < odpowiedź cat

Wyjaśnij, co robi takie polecenie i dlaczego. Jaki jest bardziej konwencjonalny sposób zapisania takiego polecenia?

Część II Edytory

Rozdział 6. Edytor vim Rozdział 7. Edytor emacs

190  ROZDZIAŁ 6. EDYTOR VIM

Historia  191

6 Edytor vim

W TYM ROZDZIALE: Poradnik — użycie edytora vim w celu utworzenia i edycji pliku Wprowadzenie do funkcji vim Pomoc dostępna w edytorze Tryb komend — poruszanie kursorem Tryb wprowadzania Tryb komend — usuwanie i zmiana tekstu Wyszukiwanie i zastępowanie Kopiowanie, przenoszenie i usuwanie tekstu Bufor ogólnego przeznaczenia Odczyt i zapis plików Plik startowy .vimrc

CELE ROZDZIAŁU Po przeczytaniu tego rozdziału będziesz potrafił:  Używać edytora vim do tworzenia i edycji pliku.  Korzystać z dostępnej w samym edytorze pomocy dla vim.  Wyjaśnić różnicę pomiędzy trybami komend i wprowadzania.  Wyjaśnić przeznaczenie bufora roboczego.  Wymienić polecenia odpowiedzialne za utworzenie nowego wiersza powyżej kursora, dołączenie tekstu na końcu wiersza, przeniesienie kursora do pierwszego wiersza pliku i przeniesienie kursora do środkowego wiersza ekranu.  Opisać tryb ostatniego wiersza i wymienić pewne polecenia używające tego trybu.  Opisać, jak ustawić znacznik i przenieść do niego kursor.  Wymienić polecenie przenoszące kursor do przodu i do tyłu przez poszczególne znaki lub słowa.  Wyjaśnić, jak wczytać plik do bufora roboczego.  Wyjaśnić, jak przeszukiwać tekst do przodu i do tyłu oraz jak powtórzyć operację wyszukiwania.

192  ROZDZIAŁ 6. EDYTOR VIM Ten rozdział rozpoczyna się historią oraz opisem vi, czyli oryginalnego, potężnego, czasami tajemniczego, interaktywnego i wizualnego edytora tekstów. Następnie przedstawiony jest poradnik wyjaśniający, jak używać vim (vi improved — klon edytora vi dostępny dla większości dystrybucji systemu Linux lub dostarczany wraz z nim) w celu utworzenia i edycji pliku. Większa część poradnika i rozdziału dotyczy edytora vi, a także wielu jego klonów. Po przedstawieniu poradnika przejdziemy do szczegółowego opisu wielu poleceń vim i wyjaśnimy, jak używać parametrów w celu dostosowania edytora vim do własnych potrzeb. Rozdział kończy się podsumowaniem poleceń vim.

HISTORIA Przed opracowaniem vi standardowym edytorem w systemie UNIX był ed (dostępny w większości systemów Linux), czyli edytor wierszowy, w którym trudno było zobaczyć kontekst przeprowadzanej edycji. Następnie pojawił się program ex1, nadzbiór ed. O przewadze edytora ex nad ed stanowią możliwości w zakresie wyświetlania i edycji tekstu, pozwalające na wyświetlenie pełnego ekranu tekstu zamiast tylko jednego wiersza. Podczas używania ex wyświetlanie i edycja tekstu jest możliwa po wydaniu polecenia vi (ang. visual mode). Użytkownicy tak często korzystali z tej możliwości, że twórcy edytora ex umożliwili jego uruchamianie od razu w tym trybie, tym samym oszczędzając użytkownikom konieczności wydania polecenia vi tuż po uruchomieniu ex. Program otrzymał odpowiednią nazwę vi. W edytorze ex można wywołać tryb wizualny oraz powrócić z powrotem do ex. Uruchom edytor, wydając polecenie ex, następnie wydaj polecenie vi, co spowoduje przejście do trybu wizualnego. W trybie wizualnym wydanie polecenia Q powoduje powrót do używania ex. Wydanie polecenia quit kończy pracę z edytorem ex. Linux oferuje wiele wersji (inaczej klonów) edytora vi. Najpopularniejsze klony to elvis (http://elvis.the-little-red-haired-girl.org/), nvi (opracowana przez Keitha Bostica implementacja oryginalnego edytora vi), vile (http://invisible-island.net/vile/vile.html) i vim (http://www.vim.org/). Każdy klon oferuje funkcje dodatkowe ponad te dostarczane przez oryginalny edytor vi.

Klony vi

Przykłady przedstawione w tej książce są oparte na edytorze vim. Wiele dystrybucji systemu Linux zapewnia obsługę różnych wersji vim. Na przykład w systemie Fedora znajdują się dwie wersje edytora vim. Pierwsza jest w katalogu /bin/vi; to minimalna wersja vim, która jest mała i szybko się wczytuje, choć jednocześnie ma mniejszą liczbę funkcji. Druga wersja jest w katalogu /usr/bin/vim; to w pełni wyposażona wersja edytora vim. Jeżeli zamiast vim używasz jego klonu lub samego edytora vi, to możesz zauważyć pewne różnice w stosunku do przykładów przedstawionych w tym rozdziale. Edytor vim jest zgodny z większością poleceń vi i działa na wielu platformach, między innymi Windows, Macintosh, OS/2, UNIX i Linux. Więcej informacji na temat edytora oraz użyteczne podpowiedzi znajdziesz na stronie domowej vim pod adresem http://www.vim.org/. Edytor vim nie jest programem pozwalającym na formatowanie tekstu. Nie oferuje funkcji wyrównywania marginesów i nie dostarcza funkcji formatowania tekstu, jakie można znaleźć w zaawansowanych procesorach tekstu, takich jak OpenOffice.org Writer. Program vim to zaawansowany edytor tekstowy przeznaczony do tworzenia kodu (w językach C, HTML, Java itd.), krótkich notatek, danych wejściowych dla systemu formatowania tekstu (na przykład groff lub troff). Istnieje możliwość użycia polecenia fmt (patrz część VI książki) w celu minimalnego sformatowania pliku tekstowego utworzonego za pomocą vim.

Czym edytor vim nie jest?

Ponieważ edytor vim oferuje potężne możliwości, w rozdziale przedstawiono jedynie niewielki ich ułamek. Ale nawet jeśli nie masz doświadczenia w pracy z vim, to ten ograniczony zestaw poleceń może wydać Ci się przytłaczający. Edytor vim pozwala wykonywać większość zadań edycyjnych na wiele różnych sposobów. Rozsądną strategią podczas nauki stosowania edytora vim

Lektura tego rozdziału

1

Program ex to najczęściej dowiązanie do vi, w niektórych systemach jest to vim.

Poradnik: jak użyć edytora vim do utworzenia i edytowania pliku  193

jest poznanie na początku jedynie niewielkiego zestawu poleceń pozwalających na przeprowadzanie podstawowych operacji edycyjnych. Kiedy oswoisz się już z pracą z vim, możesz rozpocząć poznawanie kolejnych poleceń, dzięki którym będziesz szybciej i efektywniej mógł edytować pliki. Przedstawiony poniżej poradnik prezentuje podstawowy, użyteczny zestaw poleceń vim i funkcji pozwalających na utworzenie oraz edycję pliku.

PORADNIK: JAK UŻYĆ EDYTORA VIM DO UTWORZENIA I EDYTOWANIA PLIKU W tej sekcji dowiesz się, w jaki sposób możesz uruchomić edytor vim, wpisywać tekst, przesuwać kursor w inne miejsca dokumentu, zapisywać plik na dysku i zakończyć pracę z tym edytorem. W poradniku omówimy trzy podstawowe tryby pracy edytora vim i wyjaśnimy, w jaki sposób możesz je przełączać. Oprócz przeczytania naszego poradnika, możesz również skorzystać z programu vimtutor, który jest specjalną aplikacją uczącą pracy z edytorem vim. Aby uruchomić ten program, po prostu wpisz jego nazwę w wierszu poleceń i naciśnij klawisz Enter.

vimtutor

WSKAZÓWKA Pakiet vimtutor oraz pliki pomocy edytora vim nie są instalowane domyślnie Aby uruchomić program vimtutor oraz korzystać z systemu pomocy edytora vim (patrz sekcja „Uzyskiwanie pomocy” w dalszej części tego rozdziału), musisz najpierw zainstalować pakiet vim-enhanced lub vim-runtime. Więcej informacji na temat instalacji pakietów znajdziesz w dodatku C. Ponieważ vim korzysta z mechanizmów i funkcji charakterystycznych dla danego rodzaju terminala, musisz określić, z jakiego typu terminala czy emulatora terminala będziesz korzystał. W wielu systemach, a także w sytuacji, kiedy korzystasz z emulatora terminala, odpowiedni typ terminala jest ustawiany automatycznie. Jeżeli musisz ręcznie zdefiniować rodzaj używanego terminala, powinieneś zajrzeć do sekcji „Definiowanie typu terminala” w dodatku B.

Definiowanie typu terminala

URUCHAMIANIE EDYTORA VIM Uruchom edytor vim za pomocą polecenia przedstawionego poniżej. Wykonanie tego polecenia uruchomi edytor, utworzy nowy plik o nazwie praktyka i otworzy go do edycji (być może zamiast edytora vim będziesz musiał użyć edytora vi lub vim.tiny): $ vim praktyka

Kiedy naciśniesz klawisz Enter, wiersz poleceń zniknie, a ekran terminala będzie wyglądał mniej więcej tak, jak to zostało przedstawione na rysunku 6.1. Znaki tyldy po lewej stronie każdego wiersza oznaczają, że plik jest pusty i będą znikać, w miarę jak będziesz dodawał do pliku kolejne wiersze tekstu. Jeżeli Twój ekran wygląda jak „rozstrojona” wersja ekranu przedstawionego na rysunku 6.1, to prawdopodobnie typ Twojego terminala został ustawiony w nieprawidłowy sposób (patrz podpunkt „Problemy” poniżej).

WSKAZÓWKA Polecenie vi może uruchomić vim W niektórych systemach polecenie vi powoduje uruchomienie edytora vim w trybie zgodności z vi.

194  ROZDZIAŁ 6. EDYTOR VIM

Rysunek 6.1. Uruchamianie edytora vim

Plik praktyka jest zupełnie nowy i nie zawiera żadnego tekstu. Po uruchomieniu edytor vim w ostatnim wierszu na ekranie terminala wyświetli komunikat podobny to tego przedstawionego na rysunku 6.1, co jest dodatkowym potwierdzeniem faktu, że utworzyłeś i będziesz edytował nowy, zupełnie pusty plik. Jeżeli otworzysz do edycji istniejący plik, to vim wyświetli na ekranie pierwsze wiersze tego pliku i w wierszu statusu na dole wyświetli odpowiednie informacje o tym pliku. Jeżeli uruchomisz edytor vim z typem terminala, którego nie można odnaleźć w bazie na ekranie pojawi się komunikat o wystąpieniu błędu. W takim przypadku musisz nacisnąć klawisz Enter lub ustawić typ terminala na ansi, który jest dostępny w wielu terminalach.

Problemy

terminfo,

Aby zresetować typ terminala, naciśnij klawisz Esc i następnie wpisz następującą komendę, która spowoduje zakończenie pracy z edytorem vim i powrót do znaku zachęty powłoki:

Wyjście awaryjne :q!

Kiedy wpiszesz znak dwukropka (:), vim przeniesie kursor do ostatniego wiersza ekranu. Ciąg znaków q! informuje edytor, że powinien natychmiast zakończyć pracę bez zapisywania edytowanego pliku na dysku (w większości przypadków nie będziesz wychodził z edytora w taki sposób, ponieważ zazwyczaj przed wyjściem będziesz chciał wcześniej zapisać edytowany plik). Po wpisaniu polecenia powinieneś nacisnąć klawisz Enter. Kiedy na ekranie pojawi się znak zachęty wiersza poleceń powłoki, powinieneś postępować zgodnie z informacjami, które znajdziesz w sekcji „Definiowanie typu terminala” w dodatku B. Jeżeli uruchomisz edytor vim bez podanej nazwy pliku, to po uruchomieniu edytor wyświetli kilka informacji o sobie (patrz rysunek 6.2).

TRYB KOMEND I TRYB WPROWADZANIA Edytor vim może pracować w trybie komend (ang. command mode), nazywanym również trybem normalnym (ang. normal mode) lub w trybie wprowadzania (ang. input mode) — patrz rysunek 6.3. Kiedy vim pracuje w trybie komend, możesz wydawać mu polecenia. Na przykład możesz mu nakazać usunięcie fragmentu tekstu czy zakończenie pracy i powrót do powłoki. Możesz również nakazać edytorowi przejście do trybu wprowadzania, w którym vim traktuje wszystko, co wpisujesz, jako tekst i wyświetla to na ekranie. Aby powrócić z trybu wprowadzania do trybu komend, powinieneś nacisnąć klawisz Esc. Domyślnie vim informuje Cię o tym, w jakim trybie pracuje — kiedy jesteś w trybie wprowadzania, w lewym dolnym rogu ekranu wyświetlane jest słowo WPROWADZANIE.

Poradnik: jak użyć edytora vim do utworzenia i edytowania pliku  195

Rysunek 6.2. Uruchamianie edytora vim bez podawania nazwy pliku

Rysunek 6.3. Tryby pracy edytora vim

Polecenie przedstawione poniżej powoduje, że mery wierszy:

vim

obok wpisywanego tekstu będzie wyświetlał nu-

:set number Enter

Wpisanie znaku dwukropka (:) przed poleceniem, tak jak na powyższym przykładzie, przełącza edytor vim w kolejny tryb pracy, zwany trybem ostatniego wiersza (ang. last line mode). Kiedy edytor znajduje się w tym trybie pracy, kursor jest wyświetlany tylko w ostatnim wierszu ekranu. Kiedy zakończysz wpisywanie polecenia i naciśniesz klawisz Enter, vim przenosi kursor do miejsca w tekście, gdzie znajdował się przed wpisaniem polecenia. Aby wyłączyć numerowanie wierszy, powinieneś wpisać polecenie :set nonumber i nacisnąć klawisz Enter.

Tryb ostatniego wiersza

Kiedy wpisujesz polecenie edytora vim, powinieneś pamiętać, że vim rozróżnia polecenia wpisywane małymi i wielkimi literami. Innymi słowy, w zależności od tego, czy dana litera jest wpisywana jako mała, czy jako wielka, vim będzie interpretował ją jako dwa różne polecenia. Uważaj na klawisz Caps Lock (na niektórych klawiaturach występuje jako Shift Lock). Jeżeli użyjesz tego klawisza podczas wpisywania tekstu w trybie wprowadzania i następnie przejdziesz do trybu komend, vim będzie interpretował wpisywane komendy jako wielkie litery. Taka sytuacja może być nieco irytująca, ponieważ wygląda to tak, jakby vim nie wykonywał poleceń, które wpisujesz.

Edytor vim rozpoznaje pisownię małych i wielkich liter

196  ROZDZIAŁ 6. EDYTOR VIM

WPROWADZANIE TEKSTU Zanim zaczniesz wpisywać tekst po uruchomieniu edytora vim, musisz najpierw przełączyć go w tryb wprowadzania. Aby to zrobić, naciśnij klawisz I (ang. insert before cursor; wstawianie tekstu przed kursorem) lub klawisz A (ang. append after cursor; dołączanie tekstu za kursorem).

Tryb wprowadzania

Jeżeli nie jesteś pewny, czy pracujesz w trybie wprowadzania, naciśnij klawisz Esc. Jeżeli pracowałeś w trybie wprowadzania, to edytor powróci do trybu komend lub — jeżeli już jesteś w trybie komend — usłyszysz sygnał dźwiękowy, zobaczysz błyśnięcie ekranu albo po prostu nic się nie wydarzy. Aby powtórnie przełączyć edytor vim do trybu wprowadzania, ponownie naciśnij klawisz I lub A. Kiedy vim znajduje się w trybie wprowadzania, możesz wpisywać tekst z klawiatury. Jeżeli wpisywany tekst nie pojawia się na ekranie, oznacza to, że vim nie został przełączony do trybu wprowadzania. Aby kontynuować ćwiczenia z naszym poradnikiem, powinieneś teraz wprowadzić w edytorze vim przykładowy akapit tekstu, przedstawiony na rysunku 6.4. Pamiętaj, aby na zakończenie każdego wiersza nacisnąć klawisz Enter. Jeżeli nie naciśniesz klawisza Enter, zanim wpisywany tekst dojdzie do prawej krawędzi ekranu lub okna, vim po prostu zawinie tekst i będzie kontynuował wpisywanie w kolejnym wierszu. W takiej sytuacji wiersze fizyczne na ekranie nie będą się pokrywały z wierszami logicznymi, stąd późniejsze edytowanie tekstu może być utrudnione. Podczas pracy z edytorem vim możesz poprawiać błędnie wprowadzone znaki i fragmenty tekstu. Jeżeli zauważysz błąd w aktualnie edytowanym wierszu, możesz go poprawić przed przejściem do kolejnego wiersza (patrz sekcja „Poprawianie tekstu podczas wprowadzania” nieco dalej). Oczywiście zauważone błędy możesz również poprawić później. Kiedy zakończysz wprowadzanie całego akapitu, przełącz edytor w tryb komend, naciskając klawisz Escape.

Rysunek 6.4. Wprowadzanie tekstu w edytorze vim

UZYSKIWANIE POMOCY Aby skorzystać z systemu pomocy edytora vim, musisz zainstalować pakiet vim-runtime (patrz wskazówka „Pakiet vimtutor oraz pliki pomocy edytora vim nie są instalowane domyślnie” kilka stron wcześniej). Aby podczas pracy z edytorem vim uzyskać pomoc na wybrany temat, powinieneś użyć komendy :help [temat] i nacisnąć klawisz Enter. Aby można było użyć tego polecenia, edytor musi oczywiście pracować w trybie komend. Znak dwukropka przenosi kursor do ostatniego wiersza ekranu. Jeżeli wpiszesz samo polecenie :help, to vim wyświetli informacje wprowadzające do pracy z tym edytorem

Poradnik: jak użyć edytora vim do utworzenia i edytowania pliku  197

(patrz rysunek 6.5). W wierszach z ciemnym tłem, znajdujących się na dole ekranu, pojawiają się nazwy plików wyświetlanych powyżej (każdy obszar ekranu, w którym wyświetlana jest zawartość jakiegoś pliku, taki jak dwa obszary widoczne na rysunku 6.5, jest w edytorze vim swego rodzaju odpowiednikiem „okna”). Zawartość pliku help.txt zajmuje większą część ekranu (górne „okno” edytora), a edytowany plik o nazwie praktyka zajmuje kilka wierszy w dolnej części ekranu (dolne „okno” edytora).

Rysunek 6.5. Główne okno pomocy edytora vim

Przeczytaj wprowadzenie, przewijając w miarę czytania tekst pomocy w dół. Aby przesunąć kursor o jeden wiersz w dół, naciśnij klawisz J lub strzałka w dół (). Aby przesunąć kursor o pół ekranu w górę lub w dół, naciśnij odpowiednio kombinację klawiszy Ctrl+U lub Ctrl+D. Aby zamknąć okno pomocy, wykonaj polecenie :q. Aby wyświetlić informacje na temat wstawiania tekstu, przełącz edytor do trybu komend i wykonaj polecenie :help insert (patrz rysunek 6.6).

Rysunek 6.6. Okno pomocy z tematami dotyczącymi wstawiania tekstu

198  ROZDZIAŁ 6. EDYTOR VIM

POPRAWIANIE TEKSTU PODCZAS WPROWADZANIA Kiedy edytor vim pracuje w trybie wprowadzania, do poprawiania błędów możesz używać takich samych kombinacji klawiszy jak podczas pracy z wierszem poleceń powłoki. Do takich kombinacji klawiszy należą usuwanie znaków, usuwanie wiersza i usuwanie słowa (zazwyczaj są to odpowiednio kombinacje Ctrl+H, Ctrl+U oraz Ctrl+W). Choć vim może nie usuwać skasowanego tekstu z ekranu od razu po użyciu jednej z tych kombinacji klawiszy, to edytor dokona odpowiedniej korekty, kiedy zaczniesz nadpisywać taki tekst lub kiedy naciśniesz klawisz Enter.

PRZESUWANIE KURSORA Aby usuwać, wstawiać i poprawiać tekst, musisz mieć możliwość przesuwania kursora po ekranie. Kiedy vim pracuje w trybie komend, kursor przesuwa się po naciśnięciu klawisza Enter, klawisza Spacja i klawiszy strzałek kursora. Jeżeli wolisz trzymać dłonie bliżej centralnej części klawiatury, jeżeli klawiatura Twojego terminala nie posiada klawiszy strzałek kursora lub jeżeli Twój emulator terminala ich nie obsługuje, to zamiast nich do przesuwania kursora w lewo, w dół, w górę lub w prawo możesz użyć klawiszy odpowiednio H, J, K i L.

USUWANIE TEKSTU Pojedynczy znak możesz usunąć, przesuwając kursor nad wybrany znak i wykonując polecenie x. Jeżeli chcesz usunąć całe słowo, powinieneś ustawić kursor na pierwszym znaku tego słowa i następnie wykonać polecenie dw (ang. delete word). Aby usunąć cały wiersz tekstu, ustaw kursor w dowolnym miejscu tego wiersza i wykonaj polecenie dd.

x (usuń znak) / dw (usuń słowo) / dd (usuń wiersz)

WYCOFYWANIE DOKONANYCH ZMIAN Jeżeli przypadkowo usuniesz jakiś znak, słowo czy cały wiersz lub wykonasz jakieś polecenie, którego skutki chciałbyś odwrócić, powinieneś od razu po wykonaniu takiej operacji wykonać polecenie u (ang. undo). Edytor vim przywróci tekst do postaci, jaką miał przed wykonaniem ostatniego polecenia. Jeżeli teraz ponownie wykonasz polecenie u, to vim przywróci wygląd tekstu sprzed kolejnego, ostatnio wykonanego polecenia i tak dalej. Opisanej techniki możesz użyć do wycofania skutków działania wielu ostatnio wykonanych poleceń i modyfikacji. Pamiętaj jednak, że jeżeli opcja compatible zostanie wcześniej włączona (patrz sekcja „Opcja compatible” nieco dalej w tym rozdziale), to vim będzie w stanie wycofać tylko ostatnią zmianę.

u (cofnij)

Jeżeli przypadkiem wycofasz polecenie, którego nie miałeś zamiaru wycofywać, powinieneś wykonać polecenie wykonaj ponownie. Aby to zrobić, naciśnij kombinację klawiszy Ctrl+R lub wykonaj polecenie :redo (i oczywiście po jego wpisaniu naciśnij klawisz Enter). Edytor vim ponownie wykona polecenie, które zostało ostatnio wycofane. Podobnie jak w przypadku polecenia u poleceniem :redo możesz ponownie wykonać wiele ostatnio wycofanych operacji.

:redo (wykonaj ponownie)

WPROWADZANIE DODATKOWEGO TEKSTU Kiedy chcesz wstawić nowy tekst do istniejącego tekstu, przesuń kursor do miejsca, w którym chcesz rozpocząć wstawianie tekstu, następnie wykonaj polecenie i (ang. insert), aby przełączyć edytor vim w tryb wprowadzania, wpisz nowy tekst i naciśnij klawisz Escape, aby powrócić do trybu komend. Zamiast tego możesz również ustawić kursor na ostatnim znaku tekstu, który będzie poprzedzał wstawiany tekst, i wykonać polecenie a (ang. append).

i (wprowadzanie) / a (dołączanie)

Aby wprowadzić jeden lub więcej wierszy tekstu, ustaw kursor w wierszu, powyżej którego chcesz wstawić nowy tekst. Następnie wykonaj polecenie o (ang. open). Edytor vim otworzy nowy, pusty wiersz poniżej wiersza, w którym aktualnie znajduje się kursor, przeniesie do niego kursor i przełączy się w tryb wprowadzania tekstu. Wpisz nowy tekst, pamiętając o zakończeniu każdego wiersza naciśnięciem klawisza Enter. Po zakończeniu wprowadzania tekstu naciśnij klawisz Escape, aby powrócić do trybu komend. Polecenie O (wielka litera O) działa dokładnie w taki sam sposób jak polecenie o (mała litera o), z tym że otwiera nowy wiersz powyżej wiersza, w którym aktualnie znajduje się kursor.

o lub O (otwórz)

Poradnik: jak użyć edytora vim do utworzenia i edytowania pliku  199

POPRAWIANIE TEKSTU Aby dokonać poprawek tekstu, możesz używać poleceń dd, dw lub x do usuwania tekstu, a następnie poleceń i, a, o lub O do wstawiania nowego tekstu. Na przykład: aby zmienić słowo naciśnij na uderz (patrz rysunek 6.4), użyj strzałek kursora do ustawienia go na literze n słowa naciśnij. Następnie usuń całe słowo, wykonując polecenie dw. Teraz przełącz edytor vim do trybu wprowadzania, wykonując polecenie i, wpisz słowo uderz, dodaj znak spacji i naciśnij klawisz Escape. Słowo zostało zamienione, a edytor vim jest ponownie w trybie komend i oczekuje na kolejne polecenia. Wygodnym skrótem dla polecenia dw, po którym następuje polecenie i, jest polecenie cw (ang. change word; zmień słowo). Polecenie cw przełącza edytor vim do trybu wprowadzania.

WSKAZÓWKA Podziały stron dla drukarki Znak sterujący Ctrl+L informuje drukarkę, że powinna przeskoczyć na początek kolejnej strony. Taki znak możesz wprowadzić w dowolnym miejscu dokumentu, naciskając w czasie pracy w trybie wprowadzania kombinację klawiszy Ctrl+L. Jeżeli na ekranie w miejscu kursora nie pojawi się znak ^L, to przed naciśnięciem kombinacji klawiszy Ctrl+L powinieneś nacisnąć kombinację klawiszy Ctrl+V.

ZAKOŃCZENIE PRACY Z EDYTOREM Podczas edycji vim przechowuje edytowany tekst w obszarze o nazwie bufor roboczy (ang. work buffer). Po zakończeniu edycji powinieneś zapisać zawartość bufora roboczego w pliku na dysku i w ten sposób zachować utworzony dokument. Aby zakończyć pracę z edytorem i zapisać plik na dysku, upewnij się, że vim jest w trybie komend, i wykonaj polecenie ZZ (dwie wielkie litery Z). Po wykonaniu tego polecenia vim kończy pracę i przekazuje sterowanie do powłoki. Jeżeli nie chcesz zapisywać pliku na dysku, możesz skorzystać z polecenia :q!.

OSTRZEŻENIE Nie pomyl polecenia ZZ z kombinacją klawiszy Ctrl+Z Kiedy chcesz skończyć pracę z edytorem vim przy użyciu polecenia ZZ, upewnij się, że wpisałeś polecenie ZZ, a nie nacisnąłeś kombinacji klawiszy Ctrl+Z (zazwyczaj jest to kombinacja klawiszy, której naciśnięcie powoduje zawieszenie realizacji zadania). Jeżeli naciśniesz kombinację klawiszy Ctrl+Z, vim zniknie z ekranu w niemal taki sam sposób, jakbyś zakończył z nim pracę. W rzeczywistości jednak vim nadal będzie działał na drugim planie, a edytowany tekst nadal nie będzie zapisany. Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Sterowanie zadaniami” w rozdziale 8. Jeżeli w takiej sytuacji spróbujesz uruchomić kolejną sesję edytora z plikiem o tej samej nazwie, vim wyświetli na ekranie komunikat informujący, że plik wymiany o takiej nazwie już istnieje.

PARAMETR COMPATIBLE Włączenie parametru compatible powoduje, że vim przełącza się w tryb pełnej kompatybilności z edytorem vi. Domyślnie ten parametr nie jest włączony. W początkach pracy z edytorem vim możesz zupełnie zignorować ten parametr. Włączenie parametru compatible zmienia wiele aspektów pracy edytora vim. Na przykład: kiedy ten parametr zostanie włączony, polecenie u (wycofaj) może wycofać tylko jedną, ostatnio wykonaną zmianę. Dla porównania: jeżeli nie włączysz tego parametru, to poleceniem u będziesz mógł wycofywać wiele ostatnich zmian. Jeżeli parametr compatible ma wpływ na omawiane w rozdziale polecenie, umieszczono odpowiednią informację. Aby dowiedzieć się czegoś więcej na temat parametru compatible, powinieneś wykonać polecenie :help compatible. Aby wyświetlić pełną listę różnic pomiędzy edytorem vim a oryginalnym edytorem vi, powinieneś wykonać polecenie :help vi-diff. Więcej szczegółowych informacji na temat polecenia help znajdziesz w sekcji „Uzyskiwanie pomocy” we wcześniejszej części tego rozdziału.

200  ROZDZIAŁ 6. EDYTOR VIM Aby parametr compatible włączyć z poziomu wiersza poleceń, użyj opcji -C, natomiast w celu wyłączenia parametru użyj opcji -N. Informacje na temat zmiany parametru compatible podczas pracy w edytorze vim znajdziesz w dalszej części rozdziału.

WPROWADZENIE DO FUNKCJI EDYTORA VIM W tym podrozdziale zostaną omówione tematy uzyskiwania pomocy w internecie, tryby pracy edytora vim, bufor roboczy, procedury awaryjne oraz inne funkcje oferowane przez edytor vim. Aby przekonać się, jakie funkcje są dostępne w danej wersji, wydaj polecenie vim z opcją --version.

POMOC W INTERNECIE Jak już wcześniej wspomniano, vim oferuje pomoc w samym edytorze. Po wydaniu polecenia :help na ekranie zostaną wyświetlone informacje dotyczące podanej funkcji. Przewijając tekst pomocy, możesz zauważyć słowa wraz z pionowymi kreskami na początku i końcu, na przykład |tutor|. Wspomniane słowa są aktywnymi łączami — przeniesienie kursora na aktywne łącze i naciśnięcie klawiszy Ctrl+] spowoduje przejście do tekstu wskazywanego przez to łącze. Jeżeli w nowym tekście naciśniesz klawisze Ctrl+o (mała litera O), powrócisz do tekstu pomocy. Słowa aktywnych łączy możesz również podawać w miejscu funkcji. Na przykład: zobaczyłeś odniesienie |credits|, po wydaniu polecenia :help credits będziesz mógł więc zapoznać się z tekstem, do którego prowadzi wymienione łącze. Polecenie :q! zamyka okno pomocy. funkcja

Pewne najczęściej używane funkcje, o których będziesz mógł dowiedzieć się więcej w systemie pomocy, to insert, delete i opening-window. Funkcja opening-window nie jest intuicyjna, a nazwy różnych funkcji poznasz, gdy spędzisz nieco więcej czasu na pracy z edytorem vim. Istnieje również możliwość wydania polecenia :help doc-file-list w celu wyświetlenia pełnej listy plików pomocy. Wprawdzie vim jest programem bezpłatnym, ale autor prosi o składanie datków przeznaczonych na pomoc dla dzieci w Ugandzie (więcej informacji na ten temat otrzymasz po wydaniu polecenia :help iccf).

TERMINOLOGIA W rozdziale stosowana jest przedstawiona poniżej terminologia. Znak bieżący Bieżący wiersz

Znak, w którym znajduje się kursor. To jest wiersz, w którym znajduje się kursor.

Ostatni wiersz wyświetlany na ekranie. Ten wiersz jest zarezerwowany dla trybu ostatniego wiersza i służy do wyświetlania informacji o stanie. Edytowany tekst nie jest wyświetlany w tym wierszu.

Wiersz stanu

TRYBY DZIAŁANIA Edytor vim jest częścią edytora ex, który z kolei ma pięć trybów działania:  tryb komend ex;  tryb wprowadzania ex;  tryb komend vim;  tryb wprowadzania vim;  tryb ostatniego wiersza vim.

Podczas pracy w trybie komend vim interpretuje naciśnięcia klawiszy jako polecenia i odpowiada na każde wydane polecenie. W tym trybie naciśnięcie klawisza nie powoduje jego wyświetlenia na ekranie. Natomiast w trybie wprowadzania vim traktuje naciśnięcia klawiszy jako sposób wprowadzania

Wprowadzenie do funkcji edytora vim  201

tekstu i umieszcza kolejno pisane znaki w edytowanym pliku. Wszystkie polecenia rozpoczynające się od dwukropka (:) są wydawane w trybie ostatniego wiersza. Dwukropek powoduje przeniesienie kursora do wiersza stanu, gdzie możesz wprowadzić pozostałą część polecenia. Oprócz położenia kursora istnieje jeszcze jedna ważna różnica pomiędzy trybami komend i ostatniego wiersza. Kiedy wydajesz polecenie w trybie komend, polecenie nie musi być zakończone naciśnięciem klawisza Enter. Natomiast wszystkie polecenia wydawane w trybie ostatniego wiersza muszą być zakończone naciśnięciem klawisza Enter. W trakcie zwykłej pracy nie korzystasz z trybów ex. Kiedy w tym rozdziale odwołujemy się do trybu komend lub wprowadzania, oznacza to tryby vim, a nie ex. Po rozpoczęciu sesji edycji vim znajduje się w trybie komend. Wiele poleceń, między innymi wstawiania i dołączania tekstu, umieszcza vim w trybie wprowadzania. Po naciśnięciu klawisza Esc zawsze powracasz do trybu komend. Polecenia zmiany i zastępowania tekstu łączą tryby komend i wprowadzania. Polecenie zmiany powoduje usunięcie tekstu przeznaczonego do zmiany i przejście do trybu wprowadzania, aby można było wpisać nowy tekst. Polecenie zastępowania powoduje usunięcie wskazanych znaków i wstawienie nowych, podanych przez użytkownika. Na rysunku 6.3 we wcześniejszej części rozdziału pokazano tryby pracy vim i sposoby przechodzenia pomiędzy nimi.

WSKAZÓWKA Obserwuj tryb i klawisz CAPS LOCK Prawie wszystko, co wpisujesz w trybie komend, ma znaczenie dla edytora vim. Jeżeli sądzisz, że vim znajduje się w trybie wprowadzania, podczas gdy jest w trybie komend, naciskanie kolejnych klawiszy może doprowadzić od otrzymania zaskakujących efektów. Kiedy uczysz się używać edytora vim, upewnij się, że parametr showmode (patrz punkt „Parametry” nieco dalej) jest ustawiony tak jak domyślnie. Wymieniony parametr powoduje, że vim wyświetla aktualny tryb pracy edytora. Użyteczne może być również włączenie wiersza stanu poprzez wydanie polecenia :set laststatus=2 (patrz punkt „Parametry” nieco dalej w rozdziale). Warto również zwracać uwagę na klawisz Caps Lock. W trybie komend naciśnięcie wielkiej litery ma inny efekt niż małej. Wydawanie poleceń i otrzymywanie „niewłaściwej” odpowiedzi ze strony edytora vim może być naprawdę irytujące.

EKRAN Edytor vim używa wiersza stanu oraz różnych symboli w celu dostarczania informacji o tym, co się dzieje w trakcie sesji edycji.

WIERSZ STANU Edytor vim wyświetla informacje o stanie w ostatnim wierszu widocznym na ekranie. Wspomniane informacje to między innymi komunikaty błędów, informacje o usunięciu lub dodaniu bloku tekstu, informacje o stanie pliku itd. Ponadto w wierszu stanu vim wyświetla polecenia trybu ostatniego wiersza. ODŚWIEŻENIE EKRANU Czasami może się zdarzyć, że ekran zostanie zaśmiecony i zniekształcony. Kiedy vim umieszcza znaki na ekranie, czasem pozostawia @ w wierszu, zamiast usunąć ten wiersz. Gdy dane wyjściowe programu są mieszane z zawartością bufora roboczego, wynik może być jeszcze bardziej zagmatwany. Dane wyjściowe programu nie są częścią bufora roboczego, ale wpływają na zawartość ekranu. Jeżeli ekran będzie zaśmiecony, naciśnij klawisz Esc, aby upewnić się o pracy w trybie komend, a następnie naciśnij Ctrl+L, aby odświeżyć ekran.

202  ROZDZIAŁ 6. EDYTOR VIM

ZNAK TYLDY (~) Jeżeli koniec pliku jest wyświetlany na ekranie, vim oznacza koniec pliku znakiem tyldy (~) wyświetlanym po lewej stronie ekranu. Kiedy rozpoczynasz edycję nowego pliku, każdy wiersz na ekranie będzie oznaczony tyldą (poza pierwszym wierszem).

POPRAWIANIE TEKSTU PODCZAS JEGO WSTAWIANIA Kiedy vim działa w trybie wprowadzania, możesz użyć klawiszy usuwania wierszy w celu jego poprawiania. Naciśnięcie Ctrl+W pozwala na usuwanie słów.

BUFOR ROBOCZY Całą pracę edytor vim wykonuje w buforze roboczym. Na początku sesji edycji vim odczytuje plik z dysku i umieszcza jego zawartość w buforze roboczym. W trakcie sesji edycji wszystkie zmiany są wprowadzane w kopii pliku, sam plik na dysku nie jest modyfikowany aż do chwili zapisu zawartości bufora roboczego z powrotem na dysku. Gdy kończysz sesję edycji, to zwykle nakazujesz edytorowi zapisanie zawartości bufora roboczego, co powoduje, że wprowadzone zmiany stają się trwałe. Podczas edycji nowego pliku vim tworzy plik w chwili zapisu zawartości bufora roboczego na dysku, zwykle na końcu sesji edycji. Przechowywanie edytowanego tekstu w buforze roboczym ma zarówno wady, jak i zalety. Jeżeli przypadkowo zakończysz sesję edycji bez zapisu zawartości bufora roboczego, wszelkie wprowadzone zmiany będą utracone. Jeżeli przypadkowo wprowadzisz pewne ważne zmiany (na przykład usuniesz całą zawartość bufora roboczego), możesz zakończyć sesję edycji bez wprowadzania nowych zmian. Jeśli chcesz jedynie przejrzeć plik bez wprowadzania w nim zmian, to podczas pracy z edytorem vim możesz wykorzystać narzędzie view: $ view plik

Wywołanie narzędzia view ma taki sam efekt jak uruchomienie edytora vim z opcją -R (tylko do odczytu). Po uruchomieniu edytora w wymienionym trybie nie ma możliwości zapisu zawartości bufora roboczego z powrotem do pliku, którego nazwę podano w wierszu poleceń powłoki w chwili uruchamiania edytora. Oczywiście zawsze można zapisać zawartość bufora roboczego do pliku o innej nazwie. Jeżeli masz zainstalowany program Midnight Commander (polecenie mc, patrz część VI książki), to polecenie view wywołuje mcview, a nie vim.

DŁUGOŚĆ WIERSZA I WIELKOŚĆ PLIKU Edytor vim operuje na plikach dowolnego formatu, o ile długość pojedynczego wiersza (to znaczy znaki znajdujące się pomiędzy dwoma znakami nowego wiersza, tzn. NEWLINE) zmieszczą się w dostępnej pamięci. Całkowita wielkość pliku jest ograniczona jedynie przez dostępną przestrzeń na dysku oraz pamięć.

OKNA Edytor vim pozwala na otwieranie, zamykanie i ukrywanie wielu okien, a każde z nich może zezwalać na edycję zupełnie innego pliku. Większość poleceń dotyczących okien składa się z kombinacji klawiszy Ctrl+W plus kolejna litera. Na przykład polecenie Ctrl+W S powoduje otworzenie innego okna (podział ekranu) pozwalającego na edycję tego samego pliku. Z kolei Ctrl+W N otwiera drugie okno przeznaczone na edycję nowego pliku. Polecenie Ctrl+W w przenosi kursor pomiędzy oknami, natomiast Ctrl+W Q (lub :q) zamyka okno. Pełną listę poleceń dotyczących okien możesz wyświetlić za pomocą :help windows.

Wprowadzenie do funkcji edytora vim  203

BLOKADY PLIKÓW Podczas edycji istniejącego pliku vim wyświetla kilka pierwszych wierszy pliku, dostarczając w wierszu stanu informacje dotyczące danego pliku, oraz nakłada blokadę na ten plik. Kiedy spróbujesz otworzyć plik z nałożoną blokadą przez vim, otrzymasz komunikat podobny do pokazanego na rysunku 6.7. Tego rodzaju komunikat możesz zobaczyć w dwóch sytuacjach. Pierwsza to gdy próbujesz edytować plik, który jest już edytowany przez kogoś innego (prawdopodobnie dany plik masz już otwarty w innym oknie, w programie działającym w tle bądź w innym terminalu). Druga to gdy próbujesz edytować plik, nad którym pracowałeś w edytorze vim w chwili awarii systemu.

Rysunek 6.7. Próba otworzenia pliku z nałożoną blokadą

Wprawdzie zaleca się stosowanie do poleceń wyświetlanych przez edytor vim, ale drugi użytkownik zawsze może dokończyć edycję pliku i zapisać go pod zupełnie inną nazwą. Więcej informacji znajdziesz w kolejnych punktach.

NAGŁE ZAKOŃCZENIE SESJI EDYCJI Sesję edycji możesz zakończyć na dwa sposoby. Po zakończeniu pracy masz możliwość zapisania zmian wprowadzonych w trakcie sesji edycji bądź odrzucenia tych zmian. Wydanie polecenia ZZ lub :wq w trybie komend powoduje zapisanie zmian i zakończenie pracy z edytorem vim (patrz punkt „Zakończenie pracy z edytorem” we wcześniejszej części rozdziału). Aby zakończyć sesję edycji bez zapisywania zawartości bufora roboczego, należy wydać poniższe polecenie: :q!

Polecenia :q! używaj rozważnie. Po wydaniu tego polecenia w celu zakończenia sesji edycji vim nie zachowa zawartości bufora roboczego i tym samym utracisz wszystkie zmiany wprowadzone od chwili ostatniego zapisu bufora roboczego na dysku. Następnym razem, gdy przystąpisz do edycji bądź użycia pliku, jego zawartość będzie dokładnie taka sama jak w chwili ostatniego zapisu bufora roboczego na dysku. Czasami może okazać się, że utworzyłeś lub edytowałeś plik, ale vim nie pozwala na zakończenie pracy. Na przykład: jeśli zapomniałeś podać nazwę pliku w trakcie pierwszego wywołania vim, po wydaniu polecenia ZZ otrzymasz komunikat Brak nazwy pliku. Jeżeli vim nie pozwala na normalne zakończenie pracy, możesz wydać polecenie :w, aby podać nazwę pliku i zapisać zawartość bufora roboczego na dysku przed zakończeniem pracy z vim. Wydaj poniższe polecenie, zastępując słowo plik odpowiednią nazwą pliku, nie zapomnij o naciśnięciu klawisza Enter na końcu polecenia. :w plik

204  ROZDZIAŁ 6. EDYTOR VIM Po wykonaniu powyższego polecenia możesz użyć :q w celu zakończenia pracy z edytorem vim. Nie musisz dodawać wykrzyknika (jak w q!). Wykrzyknik jest niezbędny, jedynie jeśli wprowadziłeś zmiany od chwili ostatniego zapisu zawartości bufora roboczego na dysku. W dalszej części rozdziału znajdziesz więcej informacji na temat polecenia zapisu.

WSKAZÓWKA Kiedy nie można zapisać pliku Jeżeli nie masz uprawnień do zapisu edytowanego pliku, to będziesz musiał użyć polecenia :w plik, aby plik zapisać. Jeżeli wydasz polecenie ZZ i zobaczysz komunikat opcja "readonly" jest ustawiona, oznacza to, że nie masz uprawnień do zapisu danego pliku. Użyj więc polecenia zapisu wraz z nazwą tymczasową, aby zapisać plik na dysku pod inną nazwą. Jeśli nie masz uprawnień zapisu w katalogu roboczym, vim może nie być w stanie zapisać pliku na dysku. Wydaj polecenie ponownie i jako nazwę pliku podaj bezwzględną ścieżkę dostępu do nieistniejącego pliku w Twoim katalogu domowym. (Na przykład Kuba mógłby wydać polecenie :w /home/kuba/temp lub :w ~/temp). Jeżeli vim wyświetli komunikat Plik istnieje, to musisz wydać polecenie :w! plik, aby w ten sposób nadpisać istniejący plik (upewnij się, że chcesz nadpisać plik). Więcej informacji znajdziesz w dalszej części rozdziału.

ODZYSKANIE TEKSTU PO AWARII Edytor vim tymczasowo przechowuje edytowany plik w tak zwanym pliku wymiany. Jeżeli podczas edycji pliku w edytorze vim system ulegnie awarii, tekst bardzo często będzie można odzyskać ze wspomnianego pliku wymiany. Kiedy spróbujesz przeprowadzić edycję pliku posiadającego plik wymiany, zobaczysz komunikat podobny do pokazanego na rysunku 6.7. Jeżeli ktokolwiek inny edytuje plik, zakończ pracę lub otwórz plik w trybie tylko do odczytu. W poniższym przykładzie użytkownik uruchomił edytor wraz z opcją -r w celu sprawdzenia, czy dla pliku o nazwie notatka istnieje plik tymczasowy. Wymieniony plik notatka był edytowany w chwili awarii systemu. $ vim -r Znalezione pliki wymiany: W bieżącym katalogu: 1. .party.swp posiadany przez: kuba data: Thu Jan 26 11:36:44 2012 nazwa pliku: ~kuba/party zmieniono: TAK użytkownik: kuba nazwa hosta: coffee ID procesu: 18439 2. .notatka.swp posiadany przez: kuba data: Sat Mar 23 17:14:05 2013 nazwa pliku: ~kuba/notatka zmieniono: no użytkownik: kuba nazwa hosta: coffee ID procesu: 27733 (dalej działa) W katalogu ~/tmp: -- żaden -W katalogu /var/tmp: -- żaden -W katalogu /tmp: -- żaden --

Po użyciu opcji -r edytor vim wyświetla listę znalezionych plików wymiany (niektóre z nich mogą być stare). Jeżeli na liście znajdziesz plik wymiany dla pliku edytowanego w chwili awarii systemu, wydaj to samo polecenie, ale wraz ze spacją i nazwą pliku. W ten sposób będziesz edytował ostatnią kopię bufora roboczego. Natychmiast po rozpoczęciu pracy wykonaj polecenie :w plik, aby zapisać zawartość bufora roboczego na dysku w pliku pod inną nazwą niż oryginalna. Następnie sprawdź odzyskany plik i upewnij się, że jest dobry. Kontynuujemy przykład Kuby odzyskującego plik. Jego kolejnym krokiem jest usunięcie pliku wymiany:

Tryb komend — poruszanie kursorem  205

$ vim -r notatka Używam pliku wymiany ".notatka.swp" Oryginalny plik "~/notatka" Odtwarzanie zakończono. Powinieneś sprawdzić, czy wszystko jest w porządku. (Możesz chcieć zapisać ten plik pod inną nazwą i wykonać diff z oryginalnym plikiem, aby sprawdzić zmiany) Możesz teraz chcieć usunąć plik .swp. Naciśnij ENTER lub wprowadź komendę, aby kontynuować :w notatka2 :q $ rm .notatka.swp

WSKAZÓWKA Pliki musisz odzyskiwać w systemie, którego używasz Oferowana przez vim funkcja odzyskiwania jest powiązana z systemem, w którym nastąpiła awaria. Jeżeli pracujesz na klastrze, to będziesz musiał zalogować się wcześniej do systemu używanego w chwili awarii, aby działanie opcji -r zakończyło się powodzeniem.

TRYB KOMEND — PORUSZANIE KURSOREM Kiedy vim działa w trybie komend, kursor można umieścić na dowolnym znaku wyświetlanym na ekranie. Ponadto na ekranie może być wyświetlany dowolnie wybrany fragment bufora roboczego. Przez operowanie ekranem i położeniem kursora otrzymujesz możliwość umieszczenia kursora na dowolnym znaku znajdującym się w buforze roboczym. Kursorem można poruszać się do przodu i do tyłu tekstu. Jak pokazano na rysunku 6.8, do przodu oznacza w prawą stronę oraz w dół aż do końca pliku. Z kolei do tyłu oznacza w lewo oraz w górę aż do początku pliku. Kiedy używasz polecenia przenoszącego kursor do przodu i mijasz znak końca wiersza, kursor pojawia się na początku kolejnego wiersza i na odwrót. Jeżeli poruszasz się kursorem do początku wiersza, to po minięciu pierwszego znaku danego wiersza kursor pojawia się na końcu poprzedniego wiersza.

Rysunek 6.8. Poruszanie się do przodu i do tyłu

Czasami wiersz w buforze roboczym może być zbyt długi, aby mógł zostać wyświetlony w pojedynczym wierszu na ekranie. W takim przypadku vim zawija wiersz i wyświetla jego dalszą część w kolejnym (o ile nie ustawisz parametru nowrap; patrz nieco dalej w rozdziale).

Długie wiersze

Istnieje możliwość przesuwania kursora przez tekst przy użyciu jednostki miary (to znaczy znaku, słowa, wiersza, zdania, akapitu bądź ekranu). Jeżeli polecenie przenoszące kursor poprzedzisz liczbą nazywaną współczynnikiem powtórzeń, kursor zostanie przeniesiony w tekście o podaną liczbę jednostek. Dokładne definicje jednostek miary w edytorze vim przedstawiono w dalszej części rozdziału.

206  ROZDZIAŁ 6. EDYTOR VIM

PRZENIESIENIE KURSORA O ZNAK Spacja powoduje przesunięcie kursora do przodu o jeden znak w kierunku prawej strony ekranu. Tak samo działa naciśnięcie l (mała litera L) i prawego kursora (patrz rysunek 6.9). Na przykład wydanie polecenia 7spacja lub 7l powoduje przeniesienie kursora o siedem znaków w prawą stronę. Wymienione klawisze nie mogą przenieść kursor poza koniec bieżącego wiersza do kolejnego. Polecenie h oraz strzałka w lewo działają podobnie jak l oraz strzałki w prawo, ale w przeciwnym kierunku.

Polecenia l oraz h

Rysunek 6.9. Przeniesienie kursora i znak

PRZENIESIENIE KURSORA DO WSKAZANEGO ZNAKU Istnieje możliwość przeniesienia kursora do kolejnego wystąpienia wskazanego znaku w bieżącym wierszu dzięki użyciu polecenia wyszukiwania. Na przykład przedstawione poniżej polecenie przenosi kursor z jego bieżącego położenia do kolejnego wystąpienia litery a, o ile znajduje się w tym samym wierszu:

Polecenia f oraz F

fa

Poprzednie wystąpienie litery można odszukać za pomocą wielkiej litery F. Poniższe polecenie przenosi kursor z jego bieżącego położenia do poprzedniego wystąpienia litery a w tym samym wierszu: Fa

Średnik (;) powoduje powtórzenie ostatniego polecenia wyszukiwania.

PRZENOSZENIE KURSORA O SŁOWA Polecenie w (ang. word, słowo) powoduje przeniesienie kursora do przodu, do pierwszej litery następnego słowa (patrz rysunek 6.10). Grupy znaków przestankowych są uznawane za słowa. Polecenie przechodzi do następnego wiersza, jeżeli znajduje się w nim kolejne słowo. Polecenie 15w przenosi kursor do pierwszego znaku piętnastego słowa liczonego od bieżącego położenia kursora.

Polecenia w oraz W

Rysunek 6.10. Przenoszenie kursora o słowa

Polecenie W działa podobnie jak w, ale przenosi kursor do kolejnego słowa oddzielonego znakiem odstępu, uwzględniając także znaki przestankowe. Więcej informacji na ten temat znajdziesz w punkcie „Słowo ograniczone znakami odstępu” w dalszej części rozdziału. Polecenie b (ang. back, z powrotem) przenosi kursor do tyłu, do pierwszej litery poprzedniego słowa. Z kolei polecenie B przenosi kursor do tyłu o jedno słowo ograniczone znakami odstępu. Podobnie polecenie e przenosi kursor na koniec następnego słowa, natomiast E na koniec następnego słowa ograniczonego znakami odstępu.

Polecenia b oraz B Polecenia e oraz E

Tryb komend — poruszanie kursorem  207

PRZENOSZENIE KURSORA O WIERSZE Klawisz Enter przenosi kursor na początek kolejnego wiersza, polecenie j oraz strzałka w dół przenoszą kursor do dołu o jeden znak tuż pod bieżący znak (patrz rysunek 6.11). Jeżeli pod bieżącym znakiem nie znajduje się inny, kursor zostanie przeniesiony na koniec następnego wiersza. Kursor nie będzie przeniesiony poza ostatni wiersz tekstu bufora roboczego.

Polecenia j oraz k

Rysunek 6.11. Przeniesienie kursora o wiersz

Polecenie k oraz strzałka w górę działają podobnie do polecenia j oraz strzałki w dół, ale w przeciwnym kierunku. Znak minus (-) działa podobnie jak Enter, ale w przeciwnym kierunku.

PRZENIESIENIE KURSORA O ZDANIA I AKAPITY Polecenia ) i } powodują przeniesienie kursora na początek następnego (odpowiednio) zdania i akapitu (patrz rysunek 6.12). Natomiast polecenia ( i { przenoszą kursor wstecz na początek bieżącego (odpowiednio) zdania i akapitu. Więcej informacji na temat początku zdania i akapitu znajdziesz w dalszej części rozdziału.

Polecenia ) oraz ( Polecenia } oraz {

Rysunek 6.12. Przeniesienie kursora o zdania, akapity, H, M oraz L

PRZENIESIENIE KURSORA NA EKRANIE Polecenie H (ang. home) powoduje umieszczenie kursora na początku pierwszego wiersza wyświetlanego na ekranie. Polecenie M (ang. middle) umieszcza kursor w środkowym wierszu wyświetlanym na ekranie. Natomiast polecenie L (ang. lower) przenosi kursor na początek ostatniego wiersza wyświetlanego na ekranie.

Polecenia H, M oraz L

208  ROZDZIAŁ 6. EDYTOR VIM

WYŚWIETLANIE RÓŻNYCH FRAGMENTÓW BUFORA ROBOCZEGO Ekran wyświetla fragment tekstu znajdującego się w buforze roboczym. Tekst znajdujący się przed lub po wyświetlanym na ekranie możesz wyświetlić, przewijając tekst widoczny na ekranie. Fragment tekstu bufora roboczego możesz również wyświetlić na podstawie numeru wiersza. Naciśnięcie klawiszy Ctrl+D powoduje przewinięcie ekranu w dół (do przodu) zawartości pliku i vim wyświetla pół ekranu nowego tekstu. Z kolei naciśnięcie klawiszy Ctrl+U przewija ekran w górę (do tyłu) o tę samą ilość tekstu. Jeżeli wymienione wcześniej polecenia poprzedzisz liczbą, vim spowoduje przewinięcie wskazaną ilość razy po każdym naciśnięciu Ctrl+D lub Ctrl+U w pozostałej części sekcji (o ile ponownie nie zmienisz liczby przewijanych wierszy). Omówienie parametru scroll znajdziesz w dalszej części rozdziału.

Polecenia Ctrl+D i Ctrl+U

Kombinacje klawiszy Ctrl+F (do przodu) i Ctrl+B (do tyłu) wyświetlają niemal cały ekran nowego tekstu, pozostawiając jedynie kilka wierszy z poprzedniego ekranu. W wielu klawiaturach można używać klawiszy Page Down i Page Up zamiast kombinacji klawiszy (odpowiednio) Ctrl+F i Ctrl+B.

Polecenia Ctrl+F i Ctrl+B

Jeżeli podasz numer wiersza i po nim polecenie G (ang. goto, przejdź do), vim umieści kursor we wskazanym wierszu w buforze roboczym. Wydanie polecenia G bez numeru powoduje umieszczenie kursora w ostatnim wierszu w buforze roboczym. Numery wierszy są domniemane, plik nie musi mieć rzeczywistych numerów wierszy, aby wymienione polecenie działało. Jeżeli chcesz wyświetlać numery wierszy w edytorze vim, informacje, jak włączyć tę funkcję, znajdziesz w dalszej części rozdziału.

Numery wierszy (G)

TRYB WPROWADZANIA Polecenia wstawiania, dołączania, otwierania, zmiany i zastępowania tekstu powodują przejście edytora vim do trybu wprowadzania. Kiedy vim działa w tym trybie, w buforze roboczym możesz umieszczać nowy tekst. Aby powrócić do trybu komend po zakończeniu wprowadzania nowego tekstu, musisz nacisnąć klawisz Esc. Jeżeli chcesz, aby vim przypominał Ci, że działa w trybie wstawiania, to zapoznaj się z punktem „Wyświetlanie trybu” w dalszej części rozdziału.

WSTAWIANIE TEKSTU Polecenie i (ang. insert, wstawianie) powoduje przejście edytora vim do pracy w trybie wprowadzania i umieszczenie nowego tekstu przed bieżącym znakiem. Polecenie I umieszcza tekst na początku bieżącego wiersza (patrz rysunek 6.13). Wprawdzie polecenia i oraz I czasami powodują nadpisanie tekstu na ekranie, ale znaki w buforze roboczym nie będą zmodyfikowane, a zmiana ma wpływ jedynie na tekst wyświetlany na ekranie. Nadpisany tekst zostanie ponownie wyświetlony po naciśnięciu klawisza Esc, a vim powróci do trybu komend. Polecenia i oraz I możesz wykorzystać do wstawienia kilku znaków lub słów do istniejącego tekstu bądź też w celu wstawienia tekstu do nowego pliku.

Polecenie wstawiania (i oraz I)

Rysunek 6.13. Polecenia I, i, a oraz A

Tryb wprowadzania  209

DODAWANIE TEKSTU Polecenie a (ang. append, dołącz) działa podobnie do i, ale umieszcza tekst za bieżącym znakiem (patrz rysunek 6.13). Z kolei polecenie A umieszcza tekst po ostatnim znaku w bieżącym wierszu.

Polecenie dołączania (a oraz A)

TWORZENIE NOWEGO WIERSZA DLA TEKSTU Polecenia o oraz O (ang. open, otwórz) powodują utworzenie pustego wiersza w istniejącym tekście, umieszczenie kursora na początku nowego (pustego) wiersza oraz przejście edytora vim do trybu wprowadzania. Polecenie O tworzy nowy wiersz nad bieżącym, natomiast polecenie o pod bieżącym. Z wymienionych poleceń korzystasz, gdy w istniejącym tekście chcesz umieścić kilka nowych wierszy.

Polecenie otwierania (o oraz O)

ZASTĘPOWANIE TEKSTU Polecenia r oraz R (ang. replace, zastąp) powodują, że nowo wprowadzany tekst nadpisuje (zastępuje) istniejący. Pojedynczy znak wprowadzony po poleceniu r nadpisuje istniejący znak. Po wprowadzeniu tekstu vim powraca do trybu komend, nie ma więc konieczności naciskania klawisza Esc.

Polecenie zastępowania (r oraz R)

Polecenie R powoduje, że wszystkie kolejne znaki nadpisują istniejący tekst, dopóki nie naciśniesz klawisza Esc, powracając tym samym do trybu komend.

WSKAZÓWKA Zastępowanie tabulatorów Może się wydawać, że polecenia zastępowania działają dziwnie podczas zastępowania tabulatorów. Znak tabulatora może być wyświetlany w postaci wielu spacji, przynajmniej do chwili, gdy nie spróbujesz ich zastąpić. Tabulator to jeden znak i dlatego będzie zastąpiony pojedynczym znakiem. Więcej informacji na temat wyświetlania tabulatorów jako znaków widocznych znajdziesz w punkcie „Znaki niewidoczne” w dalszej części rozdziału.

CYTOWANIE ZNAKÓW SPECJALNYCH W TRYBIE WPROWADZANIA Podczas pracy w trybie wprowadzania można użyć funkcji cytowania (przez naciśnięcie klawiszy Ctrl+V) w celu wprowadzenia dowolnego znaku w tekście, w tym także znaku, który normalnie ma znaczenie specjalne w edytorze vim. Do wspomnianych znaków zaliczamy znaki otrzymywane po naciśnięciu klawiszy Ctrl+L (lub Ctrl+R, odświeżenie ekranu), Ctrl+W (przeniesienie kursora o jedno słowo wstecz po lewej stronie), Ctrl+M (wprowadzenie znaku nowego wiersza) czy Esc (opuszczenie trybu wprowadzania).

Polecenie Ctrl+V

Aby umieścić w tekście dowolny z wymienionych znaków, musisz nacisnąć klawisze Ctrl+V, a następnie wybrany znak. Kombinacja klawiszy Ctrl+V powoduje cytowanie pojedynczego znaku podanego po wymienionej kombinacji. Na przykład umieszczenie sekwencji Esc[2J w pliku utworzonym za pomocą edytora vim wymaga naciśnięcia klawiszy Ctrl+V Esc[[2J. Wymieniona sekwencja powoduje wyczyszczenie ekranu terminala DEC VT-100 oraz podobnych. Wprawdzie wymieniona sekwencja zwykle nie jest potrzebna w dokumencie, ale w tworzonych w edytorze vim skryptach powłoki może wystąpić potrzeba użycia tej lub innych sekwencji Esc. Informacje na temat tworzenia skryptów powłoki znajdziesz w rozdziale 10.

210  ROZDZIAŁ 6. EDYTOR VIM

TRYB KOMEND — USUWANIE I ZMIANA TEKSTU W tym podrozdziale zostaną przedstawione polecenia pozwalające na usuwanie, zastępowanie lub zmianę tekstu w edytowanym dokumencie. Ponadto będzie przedstawione polecenie cofnij (ang. undo), ponieważ pozwala ono na przywrócenie usuniętego lub zmienionego tekstu.

COFANIE ZMIAN Polecenie u przywraca tekst usunięty lub zmieniony przez pomyłkę. Pojedyncze polecenie cofnięcia zmian powoduje przywrócenie jedynie ostatnio usuniętego tekstu. Jeżeli usuniesz wiersz, a następnie zmienisz słowo, pierwsze polecenie u przywróci jedynie zmienione słowo. Aby przywrócić usunięty wiersz, konieczne będzie wydanie drugiego polecenia u. Po ustawieniu parametru compatible (omówiony wcześniej w rozdziale) edytor vim pozwala na cofnięcie jedynie ostatniej operacji. Polecenie U powoduje przywrócenie ostatnio zmodyfikowanego wiersza do postaci, w której się znajdował przed rozpoczęciem wprowadzania zmian (polecenie przywraca wiersz nawet po wprowadzeniu w nim wielu zmian).

Polecenia u oraz U

USUWANIE ZNAKÓW Polecenie x usuwa bieżący znak. Polecenie x można poprzedzić liczbą wskazującą współczynnik powtórzeń (patrz nieco dalej w rozdziale), aby w ten sposób usunąć wiele znaków w wierszu, począwszy od bieżącego. Polecenie X usuwa znak znajdujący się po lewej stronie kursora.

Usunięcie znaku (x oraz X)

USUWANIE TEKSTU Polecenie d usuwa tekst z bufora roboczego. Ilość tekstu usuwanego przez polecenie d zależy od ilości jego powtórzeń oraz jednostki miary. Po usunięciu tekstu vim nadal pozostaje w trybie komend.

Polecenia d oraz D

WSKAZÓWKA Użyj polecenia dd do usunięcia pojedynczego wiersza Polecenie d Enter powoduje usunięcie dwóch wierszy: bieżącego i kolejnego. W celu usunięcia jedynie bieżącego wiersza użyj polecenia dd. Natomiast usunięcie wielu wierszy jest możliwe przez poprzedzenie polecenia dd liczbą określającą ilość usuwanych wierszy. Istnieje możliwość usunięcia znaków od bieżącego do określonego znaku w tym samym wierszu. Aby usnąć znaki aż do kolejnego średnika, wydaj polecenie dt; (z dalszej części rozdziału dowiesz się więcej o poleceniu t). Usunięcie pozostałej części wiersza następuje po użyciu polecenia D lub d$. Wybrane polecenia zostały wymienione w tabeli 6.1. Poza ostatnią grupą rozpoczynającą się od dd wszystkie polecenia powodują usunięcie znaków od lub do bieżącego znaku.

WSKAZÓWKA Zamiana znaków i wierszy Jeżeli dwa znaki są umieszczone w odwrotnej kolejności, umieść kursor w pierwszym z nich, a następnie wydaj polecenie xp. Jeśli dwa wiersze są umieszczone w odwrotnej kolejności, umieść kursor w pierwszym z nich, a następnie wydaj polecenie ddp. Więcej informacji na ten temat znajdziesz w dalszej części rozdziału.

Tryb komend — usuwanie i zmiana tekstu  211

Tabela 6.1. Przykłady poleceń usuwania tekstu Polecenie

Opis

dl

Usunięcie bieżącego znaku (działa tak samo jak polecenie x).

d0

Usunięcie począwszy od początku wiersza.

d^

Usunięcie od pierwszego znaku wiersza (spacje lub tabulatory nie liczą się).

dw

Usunięcie słowa.

d3w

Usunięcie trzech słów.

db

Usunięcie od początku słowa.

dW

Usunięcie do końca słowa ograniczonego znakiem odstępu.

dB

Usunięcie od początku słowa ograniczonego znakiem odstępu.

d7B

Usunięcie od siódmego słowa przed początkiem słowa ograniczonego znakiem odstępu.

d)

Usunięcie do końca zdania.

d4)

Usunięcie do końca czwartego zdania.

d(

Usunięcie od początku zdania.

d}

Usunięcie do końca akapitu.

d{

Usunięcie od początku akapitu.

d7{

Usunięcie od począwszy siódmego akapitu przed początkiem akapitu.

d/tekst

Usunięcie do kolejnego wystąpienia tekstu.

dfc

Usunięcie w bieżącym wierszu do kolejnego wystąpienia znaku c (ten znak również będzie usunięty).

dtc

Usunięcie w bieżącym wierszu do kolejnego wystąpienia znaku c.

D

Usunięcie do końca wiersza.

d$

Usunięcie do końca wiersza.

dd

Usunięcie bieżącego wiersza.

5dd

Usunięcie pięciu wierszy, począwszy od bieżącego.

dL

Usunięcie wszystkiego aż do ostatniego wiersza na ekranie.

dH

Usunięcie wszystkiego od pierwszego wiersza na ekranie.

dG

Usunięcie wszystkiego aż do końca bufora roboczego.

d1G

Usunięcie wszystkiego od początku bufora roboczego.

ZMIANA TEKSTU Polecenie c (ang. change, zmień) powoduje zastąpienie istniejącego tekstu nowym. Nowy tekst nie musi zajmować takiej samej ilości miejsca jak istniejący. Dlatego też możesz zastąpić na przykład słowo wieloma słowami, wiersz wieloma wierszami, a akapit pojedynczym znakiem. Polecenie C powoduje zastąpienie tekstu od bieżącego położenia kursora aż do końca wiersza.

Polecenie zmiany (c oraz C)

Polecenie c powoduje usunięcie ilości tekstu wskazanego przez współczynnik powtórzeń oraz jednostkę miary, po jego wykonaniu edytor vim znajduje się w trybie wprowadzania. Kiedy zakończysz wpisywanie nowego tekstu i naciśniesz klawisz Esc, stare słowo, wiersz, zdanie lub akapit zostanie zastąpione nowym tekstem. Naciśnięcie klawisza Esc bez wprowadzenia nowego tekstu powoduje usunięcie wskazanego tekstu (nie jest niczym zastępowany). W tabeli 6.2 wymieniono wybrane polecenia zmiany tekstu. Poza dwoma ostatnimi wszystkie polecenia powodują usunięcie znaków od lub do bieżącego znaku.

212  ROZDZIAŁ 6. EDYTOR VIM WSKAZÓWKA Polecenia dw i cw działają odmiennie Polecenie dw powoduje usunięcie wszystkich znaków (łącznie ze spacją) aż do końca słowa. Z kolei polecenie cw zmienia jedynie znaki słowa, pozostawiając spację na końcu nietkniętą. Tabela 6.2. Przykłady poleceń zmiany tekstu Polecenie

Opis

cl

Zmiana bieżącego znaku.

cw

Zmiana do końca słowa.

c3w

Zmiana do końca trzeciego słowa.

cb

Zmiana od początku słowa.

cW

Zmiana do końca słowa ograniczonego znakiem odstępu.

cB

Zmiana od początku słowa ograniczonego znakiem odstępu.

c7B

Zmiana od początku ograniczonego znakiem odstępu siódmego słowa znajdującego się przed kursorem.

c$

Zmiana do końca wiersza.

c0

Zmiana od początku wiersza.

c)

Zmiana do końca zdania.

c4)

Zmiana do końca czwartego zdania.

c(

Zmiana od początku zdania.

c}

Zmiana do końca akapitu.

c{

Zmiana od początku akapitu.

c7{

Zmiana od początku siódmego akapitu poprzedzającego bieżący.

ctc

Zmiana w bieżącym wierszu do kolejnego wystąpienia c.

C

Zmiana do końca wiersza.

cc

Zmiana bieżącego wiersza.

5cc

Zmiana pięciu wierszy począwszy od bieżącego.

ZASTĘPOWANIE TEKSTU Polecenia s oraz S (ang. substitute, zastępowanie) również zastępują istniejący tekst nowym (patrz tabela 6.3). Polecenie s usuwa bieżący znak i powoduje przejście edytora vim do trybu wprowadzania. Bieżący znak zostaje zastąpiony tekstem wpisywanym aż do naciśnięcia klawisza Esc. Natomiast polecenie S działa tak samo jak polecenie cc, czyli zmienia bieżący wiersz. Polecenie s zastępuje znaki jedynie w bieżącym wierszu. Jeżeli przed poleceniem s podasz liczbę i akcja obejmowałaby więcej znaków, niż znajduje się w bieżącym wierszu, polecenie s zastąpi jedynie znaki do końca wiersza (tak samo jak C).

Polecenie zastępowania (s oraz S)

Tabela 6.3. Przykłady poleceń zastępowania tekstu Polecenie

Opis

s

Zastąpienie bieżącego znaku jednym lub większą liczbą znaków.

S

Zastąpienie bieżącego wiersza jednym lub większą liczbą znaków.

5s

Zastąpienie pięciu kolejnych znaków począwszy od bieżącego znaku jednym lub większą liczbą znaków.

Wyszukiwanie i zastępowanie  213

ZMIANA WIELKOŚCI ZNAKÓW Tylda (~) zmienia wielkość bieżącego znaku — z małego na wielki i na odwrót. Tyldę możesz poprzedzić liczbą określającą ilość powtórzeń operacji. Na przykład polecenie 5~ powoduje zmianę wielkości pięciu kolejnych znaków, począwszy od bieżącego. Zmieniane są jedynie znaki w bieżącym wierszu, operacja nie przechodzi do następnego wiersza.

WYSZUKIWANIE I ZASTĘPOWANIE Wyszukiwanie w celu zastąpienia znaku, ciągu tekstowego lub ciągu tekstowego dopasowanego przez wyrażenie regularne to podstawowa funkcja każdego edytora. Edytor vim oferuje proste polecenia pozwalające na wyszukiwanie znaku w bieżącym wierszu. Ponadto oferuje znacznie bardziej zaawansowane polecenia przeznaczone do wyszukiwania — i opcjonalnie zastępowania — jednego lub wielu wystąpień ciągu tekstowego bądź wyrażeń regularnych w buforze roboczym.

WYSZUKIWANIE ZNAKU Za pomocą polecenia f (ang. find, znajdź) można wyszukać kolejne wystąpienie określonego znaku i przenieść do niego kursor. Więcej informacji na ten temat przedstawiono w punkcie „Przenoszenie kursora do wskazanego znaku” we wcześniejszej części rozdziału.

Polecenia f oraz F

Kolejne dwa polecenia są używane w taki sam sposób jak pozostałe polecenia wyszukiwania. Polecenie t umieszcza kursor w znaku poprzedzającym wystąpienie wskazanego znaku. Natomiast T umieszcza kursor w znaku znajdującym się po poprzednim wystąpieniu określonego znaku.

Polecenia t oraz T

Średnik (;) powtarza ostatnio wykonane polecenie f, F, t lub T. Wymienione powyżej polecenia można połączyć z innymi. Na przykład polecenie d2fq powoduje usunięcie tekstu, począwszy od bieżącego znaku aż do drugiego wystąpienia litery q w bieżącym wierszu.

WYSZUKIWANIE CIĄGU TEKSTOWEGO Edytor vim oferuje funkcję wyszukiwania do przodu oraz do tyłu w buforze roboczym, aby znaleźć ciąg tekstowy lub dopasowanie do wyrażenia regularnego (patrz dodatek A). W celu znalezienia kolejnego wystąpienia ciągu tekstowego (wyszukiwanie do przodu) wydaj polecenie /, podaj szukany tekst (nazywany szukanym ciągiem tekstowym) i naciśnij klawisz Enter. Po wydaniu polecenia / edytor vim wyświetli wiersz stanu. Po wprowadzeniu ciągu tekstowego on także zostanie wyświetlony w wierszu stanu. Naciśnięcie klawisza Enter rozpoczyna operację wyszukiwania. Jeżeli wyszukiwanie zakończy się powodzeniem, vim umieści kursor w pierwszym znaku znalezionego ciągu tekstowego. Jeżeli zamiast / wydasz polecenie ?, edytor vim będzie szukał poprzedniego wystąpienia wskazanego ciągu tekstowego. Jeśli chcesz umieścić ukośnik w szukanym ciągu, musisz go poprzedzić ukośnikiem (\).

Polecenia / oraz ?

WSKAZÓWKA Dwa różne sposoby cytowania znaków Kombinacji klawiszy Ctrl+V możesz użyć do cytowania znaków specjalnych wprowadzanych w tekście (patrz wcześniej w rozdziale). W tym punkcie wspomniano o użyciu ukośnika (\) jako sposobu cytowania znaków w szukanym ciągu tekstowym. Te dwie wspomniane techniki cytowania znaków nie są wymienne.

214  ROZDZIAŁ 6. EDYTOR VIM Polecenia n oraz N powodują powtórzenie ostatniego wyszukiwania, ale nie wymagają ponownego wprowadzenia szukanego ciągu tekstowego. Polecenie n dokładnie powtarza poprzednie wyszukiwanie, natomiast N również przeprowadza poprzednie wyszukiwanie, ale w przeciwnym kierunku.

Polecenie n oraz N

Jeżeli przeprowadzane jest wyszukiwanie do przodu i vim nie znajdzie szukanego ciągu tekstowego przed dotarciem do końca bufora roboczego, edytor najczęściej powoduje zawinięcie skanowania przez przejście na początek bufora roboczego i kontynuację operacji. W trakcie wyszukiwania do tyłu po dotarciu do początku bufora roboczego edytor vim przechodzi na koniec bufora roboczego i kontynuuje operację. Warto również pamiętać, że podczas wyszukiwania vim rozróżnia wielkość liter. W punktach „Zawijanie skanowania” i „Ignorowanie wielkości znaków w trakcie skanowania” znajdziesz więcej informacji na temat zmiany przedstawionego powyżej sposobu działania operacji wyszukiwania.

WYSZUKIWANIE ZWYKŁE KONTRA PRZYROSTOWE Kiedy vim przeprowadza zwykłe skanowanie (to jest zachowanie domyślne), wtedy po prostu wydajesz polecenie / lub ?, a następnie podajesz szukany ciąg tekstowy i naciskasz klawisz Enter. Edytor vim przenosi kursor do kolejnego lub poprzedniego wystąpienia szukanego ciągu tekstowego. Natomiast w trakcie wyszukiwania przyrostowego wydajesz po prostu polecenie / lub ?. Po wprowadzeniu każdego znaku szukanego ciągu tekstowego vim podświetla kolejne lub poprzednie wystąpienie podanego dotąd ciągu tekstowego. Kiedy zostanie podświetlony szukany przez Ciebie ciąg tekstowy, musisz nacisnąć klawisz Enter, aby przejść do podświetlonego ciągu tekstowego. Jeżeli wprowadzony dotąd ciąg tekstowy nie zostanie dopasowany do żadnego tekstu, vim niczego nie podświetli. Rodzaj wyszukiwania stosowanego przez vim zależy od parametru incsearch (omówiony w dalszej części rozdziału). Wydanie polecenia :set incsearch powoduje włączenie wyszukiwania przyrostowego, natomiast noincsearch przywraca zwykłe wyszukiwanie. Po ustawieniu parametru compatible edytor vim wyłącza wyszukiwanie przyrostowe.

ZNAKI SPECJALNE W SZUKANYM CIĄGU TEKSTOWYM Ponieważ szukany ciąg tekstowy jest wyrażeniem regularnym, pewne znaki mają w nim znaczenie specjalne. W poniższych akapitach wymieniono niektóre ze znaków specjalnych. Zapoznaj się także z dodatkiem A. Pierwsze dwa elementy na poniższej liście (^ i $) zawsze mają znaczenie specjalne niezależnie od tego, czy zostaną poprzedzone ukośnikiem (\). Natomiast pozostałym znakom można wyłączyć ich znaczenie specjalne w szukanych ciągach tekstowych, ustawiając parametr nomagic. Więcej informacji na ten temat znajdziesz w punkcie „Zezwolenie na użycie znaków specjalnych w wyszukiwaniu” w dalszej części rozdziału. ^ — dopasowanie początku wiersza Kiedy pierwszym znakiem w szukanym ciągu tekstowym jest ^, powoduje on dopasowanie początku wiersza. Na przykład polecenie /^Teraz spowoduje wyszukanie kolejnego wiersza rozpoczynającego się ciągiem tekstowym Teraz. $ — dopasowanie końca wiersza Znak dolara powoduje dopasowanie końca wiersza. Na przykład polecenie /!$ wyszukuje kolejny wiersz kończący się wykrzyknikiem, natomiast / $ dopasowuje kolejny wiersz kończący się spacją. . — dopasowanie dowolnego znaku Kropka powoduje dopasowanie dowolnego znaku w dowolnym miejscu ciągu tekstowego. Na przykład polecenie /l..e powoduje dopasowanie line, followed, like, included, all memory oraz każdego innego słowa bądź ciągu tekstowego zawierającego literę l, po niej dwa dowolne znaki i dalej literę e. Aby dopasować kropkę, konieczne jest poprzedzenie jej ukośnikiem (\.).

Wyszukiwanie i zastępowanie  215

\> — dopasowanie końca słowa Ta para znaków powoduje dopasowanie końca słowa. Na przykład polecenie /s\> wyszukuje kolejne słowo kończące się na literę s. Wprawdzie ukośnik (\) jest zwykle używany w celu wyłączenia znaczenia specjalnego znaku, ale sekwencja \> ma znaczenie specjalne, podczas gdy sam znak > już nie. \< — dopasowanie początku słowa Ta para znaków powoduje dopasowanie początku słowa. Na przykład polecenie /\ R 2 R 12 -> R 22

:1,$s/trzy/3/g

Zastępuje każde wystąpienie ciągu tekstowego trzy ciągiem 3. Na przykład: trzy -> 3 trzymaj -> 3maj utrzyj -> u3j

:g/rozdział/s/trzy/3/

Zastępuje pierwsze wystąpienie ciągu tekstowego trzy ciągiem 3 we wszystkich wierszach zawierających słowo rozdział. Na przykład: rozdział trzy -> rozdział 3 rozdział utrzymany jest... -> rozdział u3many jest...

:%s/\/3/g

Zastępuje wszystkie wystąpienia słowa trzy ciągiem tekstowym 3. Na przykład: trzy -> 3

:.,.+10s/pięć/sześć/g

Zastępuje każde wystąpienie ciągu tekstowego pięć ciągiem sześć w dziesięciu kolejnych wierszach, począwszy od bieżącego. Na przykład: pięć -> sześć pięćdziesiąt -> sześćdziesiąt

:s/\/"&"/

Zastępuje słowo krótki w bieżącym wierszu słowem "krótki" (ujętym w cudzysłów). Na przykład: krótszy niż krótki -> krótszy niż "krótki"

218  ROZDZIAŁ 6. EDYTOR VIM Normalnie polecenie zastępowania powoduje zastąpienie tylko pierwszego wystąpienia tekstu w wierszu dopasowanego do szukanego ciągu tekstowego. Jeżeli chcesz przeprowadzić zastępowanie globalne, to znaczy zastąpić wszystkie dopasowania tekstu w wierszu, wtedy po nowym ciągu tekstowym umieść ogranicznik oraz opcję g. Inna użyteczna opcja to c (ang. check, sprawdź), jej użycie powoduje, że vim prosi o potwierdzenie wprowadzenia zmiany po każdym znalezieniu dopasowania szukanego ciągu tekstowego. Naciśnięcie y powoduje zastąpienie szukanego ciągu tekstowego, q przerywa działanie polecenia, l powoduje zastąpienie i zakończenie działania, a zastępuje wszystkie kolejne wystąpienia, natomiast n kontynuuje wyszukiwanie bez zastąpienia. Ciąg tekstowy adresu nie musi być taki sam jak szukany

ciąg tekstowy. Na przykład:

:/świeca/s/knot/płomień/

zastępuje ciągiem tekstowym płomień pierwsze wystąpienie ciągu tekstowego knot w kolejnym wierszu zawierającym ciąg tekstowy świeca. Podobnie polecenie: :g/świeca/s/knot/płomień/

wykonuje tę samą operację zastąpienia pierwszego wystąpienia ciągu tekstowego knot, ale w każdym wierszu pliku zawierającym ciąg tekstowy świeca. Z kolei polecenie: :g/świeca/s/knot/płomień/g

wykonuje tę samą operację zastąpienia, ale dla wszystkich wystąpień ciągu tekstowego knot w każdym wierszu zawierającym ciąg tekstowy świeca. Jeżeli szukany ciąg tekstowy jest taki sam jak adres, to można go opuścić. Na przykład :/świeca/s//lampa/ jest odpowiednikiem polecenia :/świeca/s/świeca/lampa/.

polecenie

RÓŻNE POLECENIA W tym podrozdziale zostaną przedstawione trzy polecenia, które trudno zakwalifikować do innych grup.

ZŁĄCZENIE Polecenie J (ang. join) powoduje dołączenie na końcu wiersza bieżącego wiersza znajdującego się poniżej, umieszczenie spacji pomiędzy nimi, a kursora na wspomnianej spacji. Jeżeli wiersz bieżący kończy się kropką, vim wstawia dwie spacje.

Polecenie J

Tak złączone wiersze zawsze możesz podzielić na dwa przez zastąpienie spacji znakiem nowego wiersza.

STAN Naciśnięcie klawiszy Ctrl+G powoduje wyświetlenie pewnych informacji o stanie: nazwę edytowanego pliku, informację, czy plik został zmodyfikowany lub jest plikiem tylko do odczytu, numer bieżącego wiersza, całkowitą liczbę wierszy w buforze roboczym oraz procentową ilość wyświetlonego bufora roboczego przed wierszem bieżącym. Do wyświetlenia informacji o stanie można również użyć polecenia :f. Poniżej przedstawiono przykładowy wiersz stanu:

Polecenie Ctrl+G

"/usr/share/dict/words" [tylko odczyt] wiersz 28501 z 98569 --28%-- kol 1

KROPKA Polecenie . (kropka) powoduje powtórzenie ostatnio wykonanego polecenia, które wprowadziło zmianę. Jeżeli ostatnio wykonałeś polecenie d2w (usunięcie dwóch kolejnych słów), wydanie polecenia . spowoduje usunięcie dwóch następnych słów. Jeżeli ostatnio wstawiłeś tekst, polecenie . powtórzy operację wstawienia tego samego tekstu. To polecenie jest użyteczne, jeśli

Powtórzenie ostatniego polecenia (.)

Kopiowanie, przenoszenie i usuwanie tekstu  219

chcesz zmienić pewne wystąpienia słowa bądź wyrażenia w buforze roboczym. Wyszukaj pierwsze wystąpienie słowa (użyj polecenia /), a następnie wprowadź żądaną zmianę (użyj polecenia cw). Następnie wydanie polecenia n spowoduje wyszukanie kolejnego wystąpienia słowa, natomiast . spowoduje wprowadzenie takiej samej zmiany. Jeżeli nie chcesz wprowadzić zmiany, po prostu wydaj kolejne polecenie n, aby znaleźć następne wystąpienie danego słowa.

KOPIOWANIE, PRZENOSZENIE I USUWANIE TEKSTU Edytor vim ma bufor ogólnego przeznaczenia oraz 26 nazwanych buforów, które mogą przechowywać tekst w trakcie sesji edycji. Wspomniane bufory są użyteczne, jeśli chcesz przenosić lub kopiować fragmenty tekstu do innego miejsca w buforze roboczym. Połączenie poleceń usunięcia i wklejenia powoduje usunięcie tekstu z jednego miejsca w buforze roboczym i jego umieszczenie w innym miejscu bufora roboczego. Z kolei polecenia kopiowania i wklejania powodują skopiowanie tekstu do innego miejsca bufora roboczego bez zmiany oryginalnego tekstu.

BUFOR OGÓLNEGO PRZEZNACZENIA Ostatnio zmieniony, usunięty lub skopiowany tekst edytor vim przechowuje w buforze ogólnego przeznaczenia. Gdy polecenie cofnięcia operacji musi przywrócić tekst, to pobiera go właśnie z tego bufora.

KOPIOWANIE TEKSTU DO BUFORA Polecenie y jest identyczne jak d, ale nie powoduje usunięcia tekstu z bufora roboczego. Edytor vim umieszcza w buforze ogólnego przeznaczenia kopię pobranego tekstu. Następnie za pomocą polecenia wklejenia możesz umieścić tę kopię tekstu w innym miejscu bufora roboczego. Poleceń y oraz d używasz w dokładnie taki sam sposób. Polecenie Y powoduje skopiowanie całego wiersza do bufora ogólnego przeznaczenia.

Polecenia y oraz Y

WSKAZÓWKA Użyj polecenia yy do skopiowania jednego wiersza Polecenie d Enter powoduje usunięcie dwóch wierszy, natomiast y Enter skopiowanie dwóch wierszy. Za pomocą polecenia yy możesz skopiować bieżący wiersz, a poleceniem dd usunąć go.

WSKAZÓWKA Polecenia D oraz Y działają odmiennie Omówione wcześniej w rozdziale polecenie D nie działa w taki sam sposób jak polecenie Y. Podczas gdy polecenie D powoduje usunięcie tekstu do końca wiersza, polecenie Y kopiuje cały wiersz niezależnie od miejsca położenia kursora.

KOPIOWANIE TEKSTU Z BUFORA Polecenia p oraz P powodują skopiowanie tekstu z bufora ogólnego przeznaczenia do bufora roboczego. Jeżeli usuniesz lub skopiujesz znaki bądź słowa do bufora ogólnego przeznaczenia, polecenie p powoduje ich wstawienie po bieżącym znaku, natomiast polecenie P przed tym znakiem. W przypadku usunięcia lub skopiowania wierszy, zdań bądź akapitów polecenie P wstawia zawartość bufora ogólnego przeznaczenia przed bieżącym wierszem, natomiast polecenie p po bieżącym wierszu.

Polecenia p oraz P

220  ROZDZIAŁ 6. EDYTOR VIM Polecenia wklejające tekst nie powodują usunięcia zawartości bufora ogólnego przeznaczenia. Dlatego też ten sam tekst można umieścić w wielu miejscach pliku, wydając tylko jedno polecenie jego skopiowania lub usunięcia oraz wiele poleceń wklejenia.

USUNIĘCIE TEKSTU KOPIOWANEGO DO BUFORA Każde z omówionych wcześniej w rozdziale poleceń usunięcia powoduje umieszczenie usuniętego tekstu w buforze ogólnego przeznaczenia. Podobnie jak możesz użyć polecenia cofnięcia operacji do umieszczenia usuniętego tekstu z powrotem w jego pierwotnym miejscu, tak samo możesz użyć polecenia wklejenia do umieszczenia usuniętego tekstu w innym miejscu bufora roboczego. Przyjmujemy założenie, że ze środka zdania zostało usunięte słowo przez wydanie polecenia dw, a następnie kursor został przeniesiony do spacji pomiędzy dwoma słowami i wydałeś polecenie p. Usunięte słowo vim umieści we wskazanym położeniu. Jeżeli usuniesz wiersz, używając polecenia dd, a następnie przeniesiesz kursor do wiersza poniżej tego, w którym ma zostać umieszczony usunięty wiersz, to po wydaniu polecenia P edytor vim umieści usunięty wiersz we wskazanym miejscu.

INFORMACJE DODATKOWE NAZWANE BUFORY W dowolnej operacji usunięcia, skopiowania lub wklejenia tekstu możesz używać nazwanych buforów. Każdy z 26 nazwanych buforów ma nazwę w postaci litery alfabetu i może przechowywać różne bloki tekstu, które następnie możesz wykorzystywać, gdy zajdzie potrzeba. W przeciwieństwie do bufora ogólnego przeznaczenia vim nie zmienia zawartości nazwanego bufora, dopóki nie wydasz polecenia nadpisującego jego zawartość. Edytor vim zachowuje zawartość nazwanych buforów w trakcie całej sesji edycji. Edytor vim umieści tekst w nazwanym buforze, jeśli operację usunięcia lub skopiowania poprzedzisz znakiem cudzysłowu i nazwą bufora, na przykład polecenie "kyy powoduje skopiowanie bieżącego wiersza do bufora o nazwie k. Umieszczenie w nazwanym buforze tekstu przechowywanego w buforze roboczym może odbywać się na dwa sposoby. Pierwszy: jeśli podasz nazwę bufora małą literą, vim nadpisze zawartość bufora podczas operacji usuwania lub kopiowania tekstu. Drugi: jeśli podasz nazwę bufora wielką literą, nowo usunięty lub skopiowany tekst zostanie dołączony na końcu nazwanego bufora. Dzięki tej funkcji możesz zbierać bloki tekstu z różnych miejsc pliku, a następnie umieścić je w pliku po wydaniu pojedynczego polecenia. Nazwane bufory są również użyteczne podczas przenoszenia fragmentu pliku, gdy polecenia wklejenia nie chcesz wydać natychmiast po poleceniu wycięcia tekstu lub jeśli ten sam akapit, zdanie lub wyrażenie chcesz nieustannie wstawiać w dokumencie. Jeżeli pewnego zdania używasz nieustannie w dokumencie, to możesz je skopiować do nazwanego bufora, a następnie wklejać do dokumentu, gdy tylko będzie potrzebne. Procedura przedstawia się następująco: po wprowadzeniu pierwszego wystąpienia zdania i naciśnięciu klawisza Esc, aby powrócić do trybu komend, pozostawiasz kursor w wierszu zawierającym zdanie. (Aby przedstawiona procedura zadziałała, wiersz lub wiersze muszą zawierać jedynie powtarzane zdanie). Następnie kopiujesz powtarzane zdanie do nazwanego bufora a przez wydanie polecenia "ayy (lub "a2yy, jeśli zdanie znajduje się w dwóch wierszach). Teraz gdy zajdzie potrzeba wklejenia zdania, wystarczy, że powrócisz do trybu komend, a następnie wydasz polecenie "ap, które umieści wspomniane zdanie na końcu bieżącego wiersza. Dzięki przedstawionej technice można bardzo łatwo i szybko wstawiać w dokumencie często używany tekst. Na przykład: jeśli edytujesz dokument prawny, to wyrażenie Powód twierdzi, że Pozwany możesz umieścić w nazwanym buforze i zaoszczędzić sobie pracy, unikając jego wpisywania za każdym razem. Podobnie jeśli tworzysz dokument, w którym często używa się długiej nazwy firmy, na przykład Przedsiębiorstwo Wielobranżowe Perfekcja, to warto je umieścić w nazwanym buforze.

Odczyt i zapis plików  221

NUMEROWANE BUFORY Oprócz bufora ogólnego przeznaczenia i 26 nazwanych buforów dostępnych jest jeszcze 9 ponumerowanych buforów. W pewnym sensie to są bufory tylko do odczytu. Edytor vim wypełnia je dziewięcioma ostatnio usuniętymi fragmentami tekstu o długości przynajmniej jednego wiersza. Ostatnio usunięty tekst jest przechowywany w buforze "1, wcześniejszy w "2 itd. Jeżeli usuniesz blok tekstu, a następnie wydasz inne polecenie vim, uniemożliwiając sobie tym samym użycie polecenia „cofnij” do przywrócenia wcześniej usuniętego tekstu, zawsze możesz użyć polecenia "1p do wstawienia w położeniu kursora ostatnio usuniętego bloku tekstu. Jeżeli usunąłeś kilka bloków tekstu i chcesz przywrócić określony, postępuj zgodnie z następującą procedurą: wstaw zawartość pierwszego bufora, wydając polecenie "1p. Jeżeli nie zawiera on interesującego Cię tekstu, cofnij operację, wydając polecenie u, a następnie naciśnij kropkę w celu powtórzenia poprzedniego polecenia. W połączeniu z poleceniem . (kropka) bufory numerowane działają w unikatowy sposób: zamiast wstawić zawartość bufora "1, kropka wstawi zawartość kolejnego bufora ("2). Ponowne wydanie poleceń u i kropka spowoduje zastąpienie bufora "2 buforem "3. Procedurę możesz powtarzać aż do dziewiątego bufora.

ODCZYT I ZAPIS PLIKÓW Edytor vim wczytuje do bufora roboczego zawartość pliku, którego nazwa będzie podana w poleceniu użytym do wywołania vim. Polecenie ZZ powoduje zakończenie sesji edycji i zapis bufora roboczego z powrotem w pliku. W tym podrozdziale będą przedstawione inne sposoby wczytania tekstu do bufora roboczego oraz zapisu jego zawartości w pliku.

Zakończenie pracy (ZZ)

ODCZYT PLIKU Polecenie :r powoduje wczytanie zawartości pliku do bufora roboczego. Nowy plik nie powoduje nadpisania żadnego tekstu w buforze roboczym, ale jest umieszczany we wskazanym miejscu (lub w bieżącym wierszu, jeśli nie zostanie podane konkretne miejsce). Miejsce o adresie 0 oznacza umieszczenie zawartości pliku na początku bufora roboczego. Polecenie odczytu ma poniższą składnię:

Polecenie odczytu (:r)

:[adres]r [plik]

Podobnie jak dzieje się w przypadku innych poleceń rozpoczynających się od dwukropka, po jego wpisaniu następuje wyświetlenie wiersza stanu. Plik oznacza po prostu plik, którego zawartość ma zostać wczytana. Polecenie trzeba zakończyć naciśnięciem klawisza Enter. Jeżeli pominiesz plik, wtedy vim wczyta z dysku plik, który właśnie jest edytowany.

ZAPIS PLIKU Polecenie :w zapisuje część lub całą zawartość bufora roboczego do pliku. Możesz wskazać część bufora, która ma zostać zapisana, oraz nazwę pliku. Jeżeli nie podasz fragmentu lub nazwy pliku, wtedy vim zapisze całą zawartość bufora roboczego w edytowanym pliku, uaktualniając tym samym plik znajdujący się na dysku.

Polecenie zapisu (:w)

W trakcie długiej sesji edycyjnej dobrym rozwiązaniem jest okresowe zapisywanie tekstu w pliku. Po wystąpieniu jakiegokolwiek problemu ostatnia kopia bufora roboczego jest bezpiecznie zapisana w pliku. Jeżeli użyjesz polecenia :q! w celu zakończenia pracy edytora vim, plik na dysku będzie zawierał tę wersję bufora roboczego, która była aktualna w chwili wydania polecenia zapisu.

222  ROZDZIAŁ 6. EDYTOR VIM Polecenie zapisu ma dwie składnie: :[adres]w[!] [plik] :[adres]w>> plik

Druga składnia powoduje dołączenie tekstu do istniejącego pliku. Z kolei adres wskazuje fragment bufora roboczego, który ma zostać zapisany w pliku. Wspomniany adres stosuje format adresu używany przez omówione wcześniej w rozdziale polecenie zastępowania. Jeżeli adres nie zostanie podany, vim zapisze całą zawartość bufora roboczego. Opcjonalny plik oznacza ścieżkę dostępu do zapisywanego pliku. Jeżeli plik nie będzie podany, vim zapisze tekst w edytowanym pliku. Ponieważ polecenie zapisu może bardzo łatwo zniszczyć ogromną ilość pracy, vim domaga się umieszczenia wykrzyknika po poleceniu w jako zabezpieczenia przed przypadkowym nadpisaniem pliku. Jedyny wyjątek, kiedy wykrzyknik nie jest potrzebny, to zapis całej zawartości bufora roboczego w edytowanym pliku (czyli polecenie zapisu bez podanego adresu i pliku) oraz zapis części lub całego bufora roboczego w nowym pliku. Podczas zapisywania fragmentu edytowanego pliku lub nadpisywania innego pliku konieczne jest użycie wykrzyknika.

Polecenie w!

IDENTYFIKACJA BIEŻĄCEGO WIERSZA Polecenie :f dostarcza takich samych informacji jak omówione wcześniej Ctrl+G. Nazwa pliku wyświetlana przez polecenie :f wskazuje plik, który będzie użyty po wydaniu polecenia :w bez nazwy pliku.

USTAWIANIE PARAMETRÓW Edytor vim można dostosować do własnych potrzeb i przyzwyczajeń poprzez ustawienie parametrów. Wspomniane parametry są odpowiedzialne za takie funkcje jak wyświetlanie numerów wierszy, automatyczne wstawianie znaków nowego wiersza, włączanie wyszukiwania przyrostowego i niestandardowego itd. Parametry można ustawić na kilka sposobów. Mogą być na przykład ustawiane w środowisku bieżącej sesji edycyjnej podczas używania edytora vim. Inne rozwiązanie to ustawienie parametrów w pliku startowym powłoki ~/.bash_profile (bash) lub ~/.tcshrc (tcsh) bądź też pliku startowym edytora vim: ~/.vimrc. Po ustawieniu parametrów w którymkolwiek z wymienionych plików to samo środowisko będzie używane po każdym uruchomieniu edytora vim.

USTAWIANIE PARAMETRÓW W EDYTORZE VIM Aby ustawić parametr w trakcie używania edytora vim, wprowadź dwukropek, następnie wpisz słowo set, spację oraz parametr (omówienie parametrów znajdziesz w jednym z kolejnych punktów). Wprowadzane polecenie pojawi się w wierszu stanu i zostanie wykonane po naciśnięciu klawisza Enter. Poniższe polecenie włącza wyszukiwanie przyrostowe w bieżącej sesji edycyjnej: :set incsearch

USTAWIANIE PARAMETRÓW W PLIKU STARTOWYM Zmienna VIMINIT Jeżeli używasz powłoki bash, wiersz o przedstawionej poniżej składni możesz umieścić

w pliku startowym ~/.bash_profile: export VIMINIT='set parametr1 parametr2 ...'

Ustawianie parametrów  223

Człony parametr1 i parametr2 zastąp parametrami wybranymi z tabeli 6.7. VIMINIT to zmienna powłoki odczytywana przez edytor vim. Przedstawione poniżej polecenie powoduje, że vim będzie ignorował wielkość znaków w operacji wyszukiwania, wyświetlał numery wierszy, używał powłoki TC Shell do wykonywania poleceń systemu Linux oraz zawijał tekst w odległości 15 znaków od prawej krawędzi ekranu: export VIMINIT='set ignorecase number shell=/bin/tcsh wrapmargin=15'

Jeżeli stosujesz skróty parametrów, powyższe polecenie możesz zapisać w postaci: export VIMINIT='set ic nu sh=/bin/tcsh wm=15'

Natomiast jeśli używasz powłoki rozdział 9.):

tcsh,

w pliku startowym ~/.tcsh umieść poniższy wiersz (patrz

setenv VIMINIT 'set param1 param2 ...'

Ponownie człony parametr1 i parametr2 zastąp parametrami wybranymi z tabeli 6.7. Wartości ujęte w apostrofy są takie same jak w poprzednich przykładach.

PLIK STARTOWY .VIMRC Zamiast umieszczać parametry edytora vim w pliku startowym powłoki, możesz w katalogu domowym utworzyć plik ~/.vimrc i umieścić w nim parametry. Utworzenie pliku .vimrc powoduje, że vim jest uruchamiany z nieustawionym parametrem compatible (patrz opis we wcześniejszej części rozdziału). Wiersze w pliku .vimrc mają poniższą składnię: set parametr1 parametr2 ...

Przedstawiony poniżej przykład pliku .vimrc pełni taką samą funkcję jak zmienna zentowana w poprzednim punkcie.

VIMINIT

zapre-

$ cat ~/.vimrc set ignorecase set number set shell=/bin/tcsh set wrapmargin=15 $ cat ~/.vimrc set ic nu sh=/bin/tcsh wm=15

Parametry ustawione przez zmienną nymi w pliku .vimrc.

VIMINIT

mają pierwszeństwo przed parametrami zdefiniowa-

PARAMETRY W tabeli 6.7 wymieniono najbardziej użyteczne parametry edytora vim. Pełną listę parametrów (oraz informacje o ich bieżącym ustawieniu) możesz wyświetlić po wydaniu polecenia :set all i naciśnięciu Enter. Polecenie :set zakończone naciśnięciem klawisza Enter powoduje wyświetlenie listy opcji, które mają ustawione wartości inne niż domyślne. Istnieją dwie klasy parametrów. Pierwsza klasa to parametry zawierające znak równości, czyli pobierające wartość. Druga to parametry, które opcjonalnie mogą być poprzedzone ciągiem no, czyli są przełącznikami. Znaczenie parametru można wówczas zmienić, wydając polecenie :set [no]parametr. Na przykład wydanie polecenia :set number (lub :set nonumber) powoduje włączenie (wyłączenie) numerowania wierszy. Aby zmienić wartości parametru używającego znaku równości, należy wydać polecenie takie jak :set shiftwidth=15. Większość parametrów posiada skróty, na przykład nu dla number, nonu dla nonumber, sw shiftwidth. Skróty wymieniono w lewej kolumnie tabeli 6.7, tuż po nazwie parametru.

dla

224  ROZDZIAŁ 6. EDYTOR VIM Tabela 6.7. Parametry edytora vim Parametr

Opis

magic

Zapoznaj się z sekcją „Znaki specjalne w szukanych ciągach tekstowych” we wcześniejszej części rozdziału. Domyślnie wymienione poniżej znaki mają znaczenie specjalne, gdy są używane w szukanym ciągu tekstowym: .[]* Po ustawieniu parametru nomagic wymienione powyżej znaki nie będą dłużej miały znaczenia specjalnego. Natomiast parametr magic przywraca ich specjalne znaczenie. Znaki ^ i $ zawsze mają specjalne znaczenie w szukanych ciągach tekstowych niezależnie od ustawienia omawianego parametru.

(zezwala na użycie znaków specjalnych w wyszukiwaniu)

autoindent, ai

(automatyczne wcięcie)

autowrite, aw

(automatyczny zapis)

flash, fl

(mignięcie)

ignorecase, ic

(w trakcie wyszukiwania wielkość liter jest ignorowana) incsearch, is

(wyszukiwanie przyrostowe)

list

(znaki niewidoczne)

laststatus=n, ls=n

(wiersz stanu)

Funkcja automatycznego wcięcia działa wraz z parametrem shiftwidth i oferuje możliwość stosowania wcięć w tekście. Ta funkcja jest domyślnie wyłączona. Można ją włączyć poprzez ustawienie parametru autoindent, natomiast wyłączana jest przez noautoindent. Po włączeniu automatycznych wcięć, gdy edytor vim działa w trybie wprowadzania, naciśnięcie klawiszy Ctrl+T powoduje przesunięcie kursora z lewego marginesu (lub wcięcia) do kolejnej pozycji wcięcia. Natomiast naciśnięcie klawisza Enter przenosi kursor na lewą stronę następnego wiersza, pod pierwszy znak w poprzednim wierszu. Z kolei naciśnięcie Ctrl+D tworzy kopię pozycji wcięcia. Klawisze Ctrl+T i Ctrl+D działają jedynie przed umieszczeniem tekstu w wierszu. Domyślnie edytor vim prosi o potwierdzenie zapisu bufora roboczego na dysku, o ile tego wyraźnie nie zrobisz (prośba o potwierdzenie pojawia się na przykład po wydaniu polecenia :n w celu edycji kolejnego pliku). Parametr autowrite powoduje, że vim automatycznie zapisuje bufor roboczy, gdy używasz poleceń takich jak :n w celu edycji innego pliku. Wspomnianą opcję możesz wyłączyć przez użycie parametru noautowrite lub noaw. Domyślnie edytor vim generuje dźwięk po wydaniu nieprawidłowego polecenia lub naciśnięciu klawisza Esc w trybie komend. Ustawienie parametru flash powoduje, że zamiast dźwięku ekran mignie. Natomiast parametr noflash przywraca sygnał dźwiękowy. Nie wszystkie terminale i emulatory obsługują ten parametr. Domyślnie edytor vim standardowo rozróżnia wielkość liter w trakcie operacji wyszukiwania. Ustawienie parametru ignorecase powoduje, że wielkość liter nie będzie miała znaczenia. Przywrócenie rozróżniania wielkości liter podczas wyszukiwania następuje po ustawieniu parametru noignorecase. Zapoznaj się z sekcją „Wyszukiwanie zwykłe kontra przyrostowe” we wcześniejszej części rozdziału. Domyślnie edytor vim nie przeprowadza wyszukiwania przyrostowego. Aby to zmienić, należy ustawić parametr incsearch. Wyłączenie wyszukiwania przyrostowego następuje po ustawieniu parametru noincsearch. Aby edytor vim wyświetlał znaki niewidoczne, na przykład tabulator jako ^| i oznaczał koniec każdego wiersza znakiem $, konieczne jest ustawienie parametru list. Włączenie wyświetlania tabulatorów jako spacji i nieoznaczanie końca wiersza następuje po ustawieniu parametru nolist. Ustawienie tego parametru powoduje wyświetlenie wiersza stanu pokazującego nazwę edytowanego pliku, znaki [+], gdy plik został zmieniony od chwili jego ostatniego zapisu, oraz położenie kursora. Po ustawieniu parametru laststatus=n, gdzie n wynosi 0 (zero), wiersz stanu nie będzie wyświetlany. Wartość 1 oznacza wyświetlanie wiersza stanu, gdy na ekranie są co najmniej dwa okna vim, natomiast wartość 2 oznacza zawsze wyświetlany wiersz stanu.

Ustawianie parametrów  225

Tabela 6.7. Parametry edytora vim — ciąg dalszy Parametr

Opis

number, nu

Domyślnie edytor vim nie wyświetla numerów poszczególnych wierszy. Aby wyświetlić numery wierszy, należy ustawić parametr number. Z kolei ustawienie parametru nonumber powoduje wyłączenie wyświetlania numerów wierszy. Numery wierszy nie są częścią pliku, nie są przechowywane w pliku i nie są drukowane podczas wydruku zawartości pliku. Pojawiają się na ekranie tylko w trakcie edycji pliku w edytorze vim.

(numery wierszy)

wrap

(zawijanie wierszy)

wrapmargin=nn, wm=nn

(margines zawijania wierszy)

report=nn

(raport)

scroll=nn, scr=nn

(przewijanie)

shell=ścieżka, sh=ścieżka

(powłoka)

shiftwidth=nn, sw=nn

(wielkość wcięcia)

Parametr wrap określa, w jaki sposób vim wyświetla wiersze, które są zbyt długie, aby zmieściły się na ekranie. Aby edytor vim zawijał długie wiersze i wyświetlał kontynuację wiersza w kolejnym, należy skorzystać z parametru wrap (jest ustawiony domyślnie). Ustawienie parametru nowrap powoduje, że vim nie będzie zawijał wierszy na ekranie, a po prostu je skracał. Margines zawijania wiersza powoduje złamanie tekstu wstawianego o określoną liczbę znaków od prawego marginesu. Edytor vim łamie tekst poprzez wstawienie znaku nowego wiersza w miejscu najbliższej granicy słowa w postaci znaku odstępu. Ustawienie marginesu zawijania wierszy jest użyteczne, jeśli chcesz, aby wszystkie wiersze tekstu miały w przybliżeniu tę samą długość. Dzięki tej funkcji nie musisz pamiętać o naciśnięciu klawisza Enter na końcu każdego wiersza danych wejściowych. Po ustawieniu parametru wrapmargin=nn nn oznacza liczbę znaków od prawej strony ekranu, w których vim ma złamać tekst. Ta liczba nie jest długością kolumny tekstu, ale raczej wskazuje odległość od końca tekstu do prawej krawędzi ekranu. Wartość 0 (zero) oznacza wyłączenie funkcji. Domyślnie funkcja marginesu zawijania wierszy jest wyłączona (parametr ma ustawioną wartość 0). Ten parametr powoduje, że vim wyświetli raport w wierszu stanu po wprowadzeniu każdej zmiany, która będzie dotyczyła co najmniej nn wierszy. Na przykład wartość 7 przypisana parametrowi report oznacza, że po usunięciu siedmiu wierszy vim wyświetli komunikat 7 lines deleted. Po usunięciu sześciu lub mniej wierszy komunikat nie będzie wyświetlony. Wartością domyślną parametru report jest 5. Parametr określa liczbę wierszy, o które nastąpi przewinięcie po naciśnięciu klawiszy Ctrl+D lub Ctrl+U. Domyślnie parametr scroll ma przypisaną wartość wynoszącą połowę wysokości okna. Istnieją dwa sposoby zmiany wartości scroll. Pierwszy: odpowiednią wartość możesz wprowadzić przed naciśnięciem klawiszy Ctrl+D lub Ctrl+U, a vim ustawi parametrowi scroll podaną wartość. Drugi: wyraźne podanie parametru scroll=nn, gdzie nn oznacza liczbę wierszy przewijanego tekstu po naciśnięciu klawiszy Ctrl+D lub Ctrl+U. Uruchomienie edytora vim powoduje utworzenie nowego procesu powłoki. Masz możliwość utworzenia powłoki interaktywnej (jeżeli chcesz uruchamiać wiele poleceń) lub możesz wykonać pojedyncze polecenie. Parametr shell określa rodzaj powłoki wywoływanej przez vim. Domyślnie vim przypisuje parametrowi shell używaną przez Ciebie powłokę logowania. Aby to zmienić, ustaw parametr shell=ścieżka, gdzie ścieżka to bezwzględna ścieżka dostępu do powłoki, której chcesz używać w edytorze vim. Ten parametr kontroluje funkcjonowanie klawiszy Ctrl+T i Ctrl+D w trybie wprowadzania, gdy włączone jest automatyczne stosowanie wcięć (patrz opis opcji wcięć automatycznych na początku tej tabeli). Po ustawieniu parametru shiftwidth=nn nn oznacza liczbę spacji umieszczanych przez funkcję automatycznego wcięcia (domyślnie 8). Parametr ustawia się podobnie jak pozycje tabulatora w maszynie do pisania. Jednak w przypadku parametru shiftwidth odległość pomiędzy tabulatorami pozostaje stała.

226  ROZDZIAŁ 6. EDYTOR VIM Tabela 6.7. Parametry edytora vim — ciąg dalszy Parametr

Opis

showmatch, sm

Ten parametr jest użyteczny dla programistów pracujących z kodem źródłowym w językach programowania, które używają nawiasów klamrowych bądź zwykłych jako ograniczników wyrażeń (Lisp, C, Tcl itd.). Jeżeli masz ustawioną opcję showmatch i wpisujesz kod w trybie wprowadzania, po wpisaniu nawiasu zamykającego kursor szybko przeskakuje do nawiasu otwierającego (to znaczy poprzedzającego odpowiedni element na tym samym poziomie zagnieżdżenia). Po podświetleniu dopasowanego elementu kursor powraca do poprzedniego położenia. Kiedy wprowadzisz prawy nawias nieposiadający dopasowania, edytor vim wyda sygnał dźwiękowy. Wyłączenie funkcji automatycznego dopasowania następuje po ustawieniu parametru noshowmatch.

(pokazuj dopasowanie)

showmode, smd

(pokazuj tryb pracy)

compatible, cp

(zgodność z vi)

wrapscan, ws

(zawijanie skanowania)

Ustawienie parametru showmode powoduje wyświetlanie w prawym dolnym rogu ekranu informacji, gdy vim działa w trybie wprowadzania. Ten parametr jest domyślnie ustawiony. Użycie parametru noshowmode powoduje, że vim nie wyświetla informacji o trybie pracy. Zapoznaj się z sekcją „Parametr compatible” we wcześniejszej części rozdziału. Domyślnie edytor vim nie próbuje zachować pełnej zgodności z vi. Aby vim był zgodny z vi, musisz ustawić parametr compatible. Wyłączenie zgodności następuje po użyciu parametru nocompatible. Domyślnie podczas wyszukiwania kolejnego wystąpienia ciągu tekstowego, gdy osiągnięty zostanie koniec bufora roboczego, vim kontynuuje operację wyszukiwania od początku bufora roboczego. Parametr nowrapscan powoduje zatrzymanie wyszukiwania po dotarciu do początku lub końca bufora roboczego. Ponowne włączenie omawianej funkcji następuje po użyciu parametru wrapscan.

ZAAWANSOWANE TECHNIKI EDYCJI W tym podrozdziale zostanie przedstawionych kilka poleceń, które możesz uznać za przydatne, gdy zyskasz nieco doświadczenia w pracy z edytorem vim.

INFORMACJE DODATKOWE UŻYWANIE ZNACZNIKÓW Podczas pracy z edytorem vim możesz ustawić znaczniki, które ułatwiają adresowanie, a następnie ich używać. Ustawienie znacznika następuje po wydaniu polecenia mc, gdzie c jest dowolnym znakiem (preferowane są litery, ponieważ pewne znaki, takie jak apostrof, mają znaczenie specjalne podczas stosowania ich jako znaczników). Edytor vim nie zachowuje znaczników po zakończeniu pracy. Po ustawieniu znacznika możesz go używać w sposób podobny do numeru wiersza. Jeżeli chcesz przenieść kursor na początek wiersza zawierającego znacznik, nazwę znacznika musisz poprzedzić apostrofem. Na przykład w celu ustawienia znacznika t umieść kursor w wybranym wierszu i wydaj polecenie mt. W trakcie pozostałej sesji edycyjnej, dopóki nie wyzerujesz znacznika lub nie usuniesz zawierającego go wiersza, wydanie polecenia 't będzie powodowało przejście na początek wiersza, w którym jest zdefiniowany znacznik t. Cały tekst, począwszy od bieżącego wiersza aż do wiersza zawierającego znacznik r, możesz usunąć przy użyciu następującego polecenia: d'r

Zaawansowane techniki edycji  227

Istnieje również możliwość użycia znaku akcentu (`, nazywany także odwrotnym apostrofem) w celu przejścia do dokładnie wskazanego przez znacznik położenia w wierszu. Po ustawieniu znacznika t możesz przenieść kursor do położenia znacznika (a nie na początek wiersza zawierającego znacznik) przez wydanie polecenia `t. Przedstawione poniżej polecenie powoduje usunięcie całego tekstu, począwszy od wiersza bieżącego do znaku zawierającego znacznik r; pozostała część wiersza znacznika pozostanie nietknięta: d`r

Znaczniki mogą być wykorzystane w charakterze adresów w poleceniach zamiast numerów wierszy. Przedstawione poniżej polecenie powoduje zastąpienie wszystkich wystąpień Teraz przez TERAZ we wszystkich wierszach, począwszy od znacznika m do wiersza bieżącego (znacznik m musi znajdować się przed wierszem bieżącym): :'m,.s/Teraz/TERAZ/g

EDYCJA INNYCH PLIKÓW Poniższe polecenie powoduje, że vim rozpocznie edycję wskazanego pliku: :e[!] [plik]

Jeżeli chcesz zapisać zawartość bufora roboczego, wówczas musisz to zrobić (na przykład za pomocą :w) przed wydaniem powyższego polecenia. Jeżeli nie zapiszesz zawartości bufora roboczego, vim nakazuje użycie wykrzyknika jako potwierdzenia Twojej zgody na utratę zmian wprowadzonych w buforze roboczym od chwili jego ostatniego zapisu w pliku. Jeśli nie podasz nazwy pliku, vim rozpocznie edycję pliku, nad którym obecnie pracujesz. Polecenie :e! ponownie rozpoczyna sesję edycji. Wymienione polecenie powoduje przywrócenie bufora roboczego do stanu, w jakim znajdował się w chwili ostatniego zapisu w pliku. Jeśli bufor roboczy nie był jeszcze zapisany w pliku, polecenie przywraca go do stanu z chwili rozpoczęcia edycji pliku. To jest bardzo użyteczne polecenie w przypadku popełnienia błędów podczas edycji pliku, gdy uznasz, że znacznie łatwiej rozpocząć pracę od początku, niż poprawiać wprowadzone błędy.

Polecenie :e!

Ponieważ polecenie :e nie powoduje uszkodzenia zawartości bufora ogólnego przeznaczenia ani buforów numerowanych, w buforze możesz przechowywać tekst wczytany z jednego pliku, użyć polecenia :e do edycji drugiego pliku, a następnie tekst z bufora umieścić w drugim pliku. Polecenie :e# zamyka bieżący plik i otwiera ostatnio edytowany, umieszczając kursor w wierszu, w którym się znajdował w chwili zamykania pliku. Jeżeli przed wydaniem polecenia nie zapisałeś pliku, nad którym wcześniej pracowałeś, vim zaproponuje Ci jego zapis. Ustawienie parametru autowrite (omówiony wcześniej w rozdziale) nie ma wpływu na wyświetlaną przez vim propozycję zapisu pliku.

Polecenie :e#

Polecenie :e# może pomóc w skopiowaniu bloków tekstu pomiędzy plikami. Kiedy uruchomisz edytor vim, podając jako argumenty kilka nazw plików, polecenia :n możesz użyć do edycji kolejnego pliku, :e# do edycji poprzedniego, natomiast :rew do przewinięcia sekwencji plików i powrotu do edycji pierwszego. W trakcie poruszania się pomiędzy plikami możesz kopiować do bufora tekst z jednego pliku, a następnie wklejać go w innym. Polecenie :n! powoduje wymuszenie zamknięcia pliku bez zapisywania zmian, a następnie otworzenie do edycji kolejnego pliku.

Polecenia :n i :rew

MAKRA I SKRÓTY Edytor vim pozwala na tworzenie makr i skrótów. Polecenie :map powoduje zdefiniowanie klawisza lub sekwencji klawiszy wykonujących pewne działanie w trybie wprowadzania. Przedstawione poniżej polecenie mapuje Ctrl+X na polecenie, które: wyszukuje w bieżącym wierszu kolejny lewy nawias (f[), usuwa wszystkie znaki od tego nawiasu do następnego prawego nawiasu (df]) w tym samym wierszu, usuwa kolejny znak (x), przenosi kursor w dół o dwa wiersze (2j) i wreszcie umieszcza kursor na początku wiersza (0):

Polecenie :map

:map ^X f[df]x2j0

228  ROZDZIAŁ 6. EDYTOR VIM

Wprawdzie można używać sekwencji Esc i Ctrl, ale dobrym rozwiązaniem jest unikanie mapowania znaków lub sekwencji, które są poleceniami edytora vim. Wydanie polecenia :map bez argumentów powoduje wyświetlenie aktualnych mapowań. Być może trzeba będzie użyć Ctrl+V (patrz wcześniejsza część rozdziału) do cytowania pewnych znaków umieszczanych w ciągu tekstowym polecenia :map. Polecenie :abbrev jest podobne do :map, ale tworzy skrót, którego można używać podczas pracy w trybie wprowadzania. Kiedy jesteś w trybie wprowadzania, wpiszesz ciąg tekstowy zdefiniowany za pomocą :abbrev i naciśniesz spację, wprowadzony ciąg tekstowy i spację vim zastąpi znakami wskazanymi w definicji danego ciągu tekstowego. Aby ułatwić sobie pracę, w trakcie definiowania skrótów unikaj często spotykanych sekwencji znaków. Przedstawione poniżej polecenie definiuje ZZ jako skrót dla Król Maciuś Pierwszy:

Polecenie :abbrev

:abbrev ZZ Król Maciuś Pierwszy

Wprawdzie ZZ jest poleceniem edytora vim, ale używanym jedynie w trybie komend. Nie ma więc specjalnego znaczenia w trybie wprowadzania, w którym są stosowane skróty.

WYKONYWANIE POLECEŃ POWŁOKI W EDYTORZE VIM Podczas używania edytora vim masz kilka sposobów na wykonywanie poleceń powłoki. Na przykład wydając poniższe polecenie i naciskając klawisz Enter, powodujesz uruchomienie nowej interaktywnej powłoki:

Polecenie :sh

:sh

Parametr shell edytora vim (patrz wcześniej w rozdziale) określa powłokę, która będzie uruchomiona, najczęściej to bash lub tcsh. Wartością domyślną parametru shell jest powłoka logowania. Po zakończeniu pracy w powłoce powrót do edytora lub wydaniu polecenia exit.

vim

następuje po naciśnięciu klawiszy Ctrl+D

WSKAZÓWKA Jeżeli polecenie :sh nie działa prawidłowo Polecenie :sh może działać dziwnie, w zależności od sposobu konfiguracji powłoki. Po wydaniu polecenia :sh istnieje niebezpieczeństwo otrzymania komunikatów ostrzeżeń lub nawet zawieszenia edytora. Musisz poeksperymentować z poleceniem :sh i upewnić się o jego prawidłowym działaniu. Jeżeli polecenie nie działa prawidłowo, wówczas przed jego wydaniem zmień wartość parametru shell edytora vim, tak aby wskazywał na inną powłokę. Na przykład poniższe polecenie powoduje, że wydanie polecenia :sh w edytorze vim spowoduje uruchomienie powłoki tcsh: :set shell=/bin/tcsh Być może konieczna okaże się zmiana zmiennej środowiskowej SHELL po wydaniu polecenia :sh, aby wskazana została odpowiednia powłoka.

OSTRZEŻENIE Edytuj tylko jedną kopię pliku Po uruchomieniu nowej powłoki przez wykonanie polecenia :sh nie zapominaj, że nadal używasz edytora vim. Często popełnianym błędem jest próba przeprowadzenia edycji tego samego pliku z poziomu nowej powłoki i zapominanie przy tym, że vim aktualnie jest używany do edycji danego pliku w innej powłoce. Ponieważ edycja tego samego pliku przez dwa egzemplarze edytora może doprowadzić do utraty pewnych danych, vim ostrzega przed popełnieniem takiego błędu. Zapoznaj się z punktem „Blokady plików” we wcześniejszej części rozdziału, aby zobaczyć przykład komunikatu wyświetlanego przez vim.

Zaawansowane techniki edycji  229

Z poziomu edytora vim polecenie powłoki można wykonać przez wydanie poniższego polecenia edytora, podając odpowiednią nazwę i naciskając klawisz Enter:

Polecenie :!

:!polecenie

Edytor vim uruchomi nową powłokę i wykona w niej podane polecenie. Po zakończeniu wykonywania polecenia nowo uruchomiona powłoka oddaje kontrolę z powrotem edytorowi vim. Istnieje możliwość wykonania polecenia powłoki z poziomu edytora vim i zastąpienia bieżącego wiersza danymi wyjściowymi wygenerowanymi przez polecenie. Jeżeli nie chcesz zastąpić żadnego tekstu, przed wydaniem poniższego polecenia po prostu umieść kursor w nowym pustym wierszu:

Polecenie :!!

!!polecenie

Po wpisaniu pierwszego wykrzyknika nic się nie stanie. Natomiast po wpisaniu drugiego vim przeniesie kursor do wiersza stanu i pozwoli na podanie polecenia przeznaczonego do wykonania. Ponieważ to polecenie przełącza edytor do trybu ostatniego wiersza, polecenie musi być zakończone naciśnięciem klawisza Enter (podobnie jak większość poleceń powłoki). Z poziomu edytora vim polecenia powłoki można wykonywać z użyciem standardowych danych wejściowych w postaci całego lub fragmentu edytowanego pliku, a standardowe dane wyjściowe polecenia mogą zastąpić zawartość edytowanego pliku. Taki rodzaj polecenia jest użyteczny podczas sortowania listy zapisanej w pliku. Aby wskazać fragment pliku będący danymi wejściowymi dla polecenia, przenieś kursor na koniec bloku tekstu. Następnie wpisz wykrzyknik, a po nim polecenie, które normalnie przenosi kursor na koniec innego bloku tekstu. Na przykład: jeżeli kursor znajduje się na początku pliku, a chcesz wskazać cały plik, wtedy wydaj polecenie !G. Jeżeli chcesz wskazać fragment pliku pomiędzy kursorem i znacznikiem b, wtedy wydaj polecenie !'b. Po wydaniu polecenia przeniesienia kursora vim wyświetli wykrzyknik w wierszu stanu i będzie oczekiwał na wprowadzenie polecenia powłoki. Operację posortowania listy imion w pliku możesz przeprowadzić następująco: przenieś kursor na początek listy i ustaw znacznik q, wydając polecenie mq. Następnie przenieś kursor na koniec listy i wydaj poniższe polecenie: !'qsort

Naciśnij klawisz Enter i poczekaj. Po kilku sekundach posortowana lista powinna na ekranie zastąpić początkową. Jeżeli polecenie nie zadziałało zgodnie z oczekiwaniami, zawsze możesz je cofnąć, wydając polecenie u. Więcej informacji na temat polecenia sort znajdziesz w części VI książki.

OSTRZEŻENIE Polecenie ! może zniszczyć plik Jeżeli wydasz niewłaściwe polecenie lub pomylisz się, możesz doprowadzić do uszkodzenia pliku (jeśli polecenie spowoduje na przykład zawieszenie lub zatrzymanie działania edytora vim). Z tego powodu dobrym rozwiązaniem jest zapis pliku przed wydaniem polecenia !. Polecenie u cofające ostatnią operację może okazać się zbawienne. Omówione wcześniej polecenie :e! spowoduje odrzucenie zmian i przywrócenie bufora roboczego do stanu, w którym się znajdował w trakcie ostatniej operacji zapisu. Podobnie jak w przypadku polecenia :sh domyślna powłoka może nie działać prawidłowo wraz z poleceniem !. Przed wykonaniem żądanego polecenia dobrym rozwiązaniem jest przetestowanie powłoki na przykładowym pliku. Jeżeli powłoka nie działa prawidłowo, zmień wartość parametru shell.

230  ROZDZIAŁ 6. EDYTOR VIM

JEDNOSTKI MIARY Wiele poleceń vim działa na blokach tekstu o wielkości od jednego znaku do wielu akapitów. Wielkość tekstu można określić za pomocą jednostki miary. Oczywiście zastosowanie wielu jednostek miary jest możliwe poprzez jej poprzedzenie współczynnikiem powtórzeń (omówiony w dalszej części rozdziału). W tym podrozdziale przedstawiono różne jednostki miary.

ZNAK Znak oznacza jeden znak, zarówno widoczny, jak i niewidoczny, łącznie ze spacją i tabulatorem. Poniżej przedstawiono przykłady znaków: a q A . 5 R - > tabulator spacja

SŁOWO Słowo jest podobne do słowa używanego w języku polskim, to ciąg tekstowy składający się z jednego lub większej liczby znaków ograniczonych po obu stronach dowolną kombinacją jednego lub więcej wymienionych elementów: znak przestankowy, spacja, tabulator, cyfra lub znak nowego wiersza. Oprócz tego każda grupa znaków przestankowych jest przez edytor vim uznawana za słowo (patrz tabela 6.8). Tabela 6.8. Słowa Liczba słów

Tekst

1

gruszka

2

gruszka!

2

gruszka!)

3

gruszka!) To

4

gruszka!) "To

11

A to jest krótki, zwięzły wiersz (bez wodotrysków).

SŁOWA OGRANICZONE ZNAKAMI ODSTĘPU Słowo ograniczone znakami odstępu jest takie samo jak przedstawione w poprzednim punkcie, ale obejmuje przylegające do niego znaki przestankowe. Pomiędzy słowami ograniczonymi znakami odstępu znajduje się jeden lub więcej następujących znaków: spacja, tabulator lub znak nowego wiersza (patrz tabela 6.9). Tabela 6.9. Słowa ograniczone znakami odstępu Liczba słów

Tekst

1

gruszka

1

gruszka!

1

gruszka!)

2

gruszka!) To

2

gruszka!) "To

8

A to jest krótki, zwięzły wiersz (bez wodotrysków).

Jednostki miary  231

WIERSZ Wiersz jest ciągiem tekstowym znaków ograniczonym znakami nowego wiersza i niekoniecznie musi być wyświetlony na ekranie w postaci pojedynczego fizycznego wiersza. Możesz wprowadzić bardzo długi pojedynczy wiersz (logiczny), który zostanie kilkukrotnie zawinięty (to znaczy będzie kontynuowany w kolejnym fizycznym wierszu) lub po prostu zniknie za prawą krawędzią ekranu. Dobrym rozwiązaniem jest unikanie tworzenia długich logicznych wierszy, idealne będzie ich kończenie znakiem nowego wiersza przed osiągnięciem prawej krawędzi ekranu. Przerwanie wierszy w taki sposób gwarantuje, że każdy wiersz fizyczny zawiera jeden wiersz logiczny i pozwala uniknąć zamieszania podczas edycji i formatowania tekstu. Wydaje się, że niektóre polecenia nie działają prawidłowo, gdy wiersz fizyczny jest dłuższy niż szerokość ekranu. Na przykład: gdy kursor znajduje się w długim wierszu logicznym zawiniętym w kilku wierszach fizycznych, naciśnięcie klawisza Enter powoduje przeniesienie kursora w dół o więcej niż tylko jeden wiersz. Do podzielenia długich wierszy logicznych na krótsze możesz użyć narzędzia fmt (patrz część VI książki).

ZDANIE Zdanie to po prostu zdanie, jakie znamy z języka polskiego, lub jego odpowiednik. Zdanie rozpoczyna się na końcu poprzedniego zdania i kończy się kropką, wykrzyknikiem lub znakiem zapytania oraz dwiema spacjami bądź znakiem nowego wiersza (patrz tabela 6.10). Tabela 6.10. Zdania Liczba zdań

Tekst

Jedno: tylko jedna spacja po pierwszej kropce i znak nowego wiersza po drugiej kropce.

I to tyle. To jest jedno zdanie.

Dwa: dwie spacje po pierwszej kropce i znak nowego wiersza po drugiej kropce.

I to tyle.

Trzy: dwie spacje po pierwszych dwóch znakach zapytania i znak nowego wiersza po wykrzykniku.

Co?

Jedno: znak nowego wiersza po kropce.

To zdanie

To są dwa zdania.

Trzy zdania?

Jeden wiersz!

zabiera łącznie trzy wiersze.

AKAPIT Akapit jest poprzedzony i kończy się jednym lub większą liczbą pustych wierszy. Pusty wiersz składa się z dwóch znaków nowego wiersza (patrz tabela 6.11).

EKRAN (OKNO) W edytorze vim ekran lub okno terminala może wyświetlać jedno lub więcej logicznych okien informacji. Okno wyświetla cały bufor roboczy bądź jego część. Na rysunku 6.5 we wcześniejszej części rozdziału pokazano ekran zawierający dwa okna.

WSPÓŁCZYNNIK POWTÓRZENIA Liczba poprzedzająca jednostkę miary jest współczynnikiem powtórzenia. Podobnie jak w wyrażeniu 5 cm całość (w tym liczba 5) jest uznawana za pojedynczą jednostkę miary, tak samo współczynnik powtórzenia w edytorze vim pozwala na połączenie wielu jednostek miary i uznanie ich za jedną. Na przykład polecenie w przenosi kursor o jedno słowo do przodu, natomiast 5w przenosi kursor o pięć słów do przodu, z kolei 250w — o 250 słów do przodu. Jeżeli współczynnik powtórzenia nie zostanie podany, vim uzna, że jego wartość wynosi 1. Jeżeli współczynnik powtórzenia spowoduje, że kursor ma wykroczyć poza koniec pliku, to zostanie pozostawiony na końcu tego pliku.

232  ROZDZIAŁ 6. EDYTOR VIM Tabela 6.11. Akapity Liczba akapitów

Tekst

Jeden: pusty wiersz przed i po tekście Jeden akapit

Jeden: pusty wiersz przed i po tekście Może się wydawać, że ten fragment jest więcej niż jednym akapitem. Jednak dwa wcięcia nie oznaczają, że kwalifikuje się jako dwa akapity.

Trzy: trzy bloki tekstu rozdzielone pustymi wierszami Nawet choć w języku polskim to tylko jedno zdanie, edytor vim uznaje je za trzy akapity.

PODSUMOWANIE ROZDZIAŁU W poniższym podsumowaniu znajdziesz wszystkie polecenia edytora vim przedstawione w rozdziale, a także kilka nowych. W tabeli 6.12 wymieniono niektóre sposoby wywołania edytora vim z poziomu wiersza poleceń. Tabela 6.12. Wywoływanie edytora vim Polecenie

Opis

vim plik

Rozpoczęcie edycji pliku od wiersza 1.

vim +n plik

Rozpoczęcie edycji pliku od wiersza n.

vim + plik

Rozpoczęcie edycji pliku od ostatniego wiersza.

vim +/wzorzec plik

Rozpoczęcie edycji pliku od pierwszego wiersza zawierającego wzorzec.

vim -r plik

Przywrócenie wskazanego pliku po awarii systemu.

vim -R plik

Rozpoczęcie edycji pliku tylko w trybie odczytu (działa tak samo jak otworzenie pliku za pomocą view).

Aby móc używać poleceń pozwalających na poruszanie kursorem (zobacz tabela 6.13) o pewne jednostki miary, musisz pracować w trybie komend. Wspomniane jednostki miary można stosować z poleceniami zmiany, usuwania i kopiowania tekstu. Każde z poleceń wymienionych w tabeli może być poprzedzone liczbą określającą ilość powtórzeń danego polecenia.

Podsumowanie rozdziału  233

Tabela 6.13. Przesunięcie kursora o pewną jednostkę miary Polecenie

Przesunięcie kursora

spacja, l (litera L) lub strzałka w prawo

Do spacji po prawej stronie.

h lub strzałka w lewo

Do spacji po lewej stronie.

w

Do słowa po prawej stronie.

W

Do ograniczonego znakiem odstępu słowa po prawej stronie.

b

Do słowa po lewej stronie.

B

Do ograniczonego znakiem odstępu słowa po lewej stronie.

$

Na koniec wiersza.

e

Na koniec słowa po prawej stronie.

E

Na koniec ograniczonego znakiem odstępu słowa po prawej stronie.

0 (zero)

Na początek wiersza (w tym poleceniu nie można podać liczby określającej ilość powtórzeń polecenia).

Enter

Na początek kolejnego wiersza.

j lub strzałka w dół

O jeden wiersz do dołu.

-

Na początek poprzedniego wiersza.

k lub strzałka w górę

O jeden wiersz w górę.

)

Na koniec zdania.

(

Na początek zdania.

}

Na koniec akapitu.

{

Na początek akapitu.

%

Do dopasowanego nawiasu tego samego typu na tym samym poziomie zagnieżdżenia.

W tabeli 6.14 wymieniono polecenia pozwalające na wyświetlanie różnych fragmentów bufora roboczego. Tabela 6.14. Wyświetlanie bufora roboczego Polecenie

Przesunięcie kursora

Ctrl+D

Do przodu o połowę okna.

Ctrl+U

Do tyłu o połowę okna.

Ctrl+F lub Page Down

Do przodu o całe okno.

Ctrl+B lub Page Up

Do tyłu o całe okno.

nG

Do wiersza n (bez podania n przejście do ostatniego wiersza).

H

Na początek okna.

M

Na środek okna.

L

Na dół okna.

Polecenia wymienione w tabeli 6.15 pozwalają na dodawanie tekstu do bufora. Z wyjątkiem r wszystkie wymienione polecenia pozostawiają edytor vim w trybie wprowadzania. Aby powrócić do trybu komend, konieczne jest naciśnięcie klawisza Esc.

234  ROZDZIAŁ 6. EDYTOR VIM Tabela 6.15. Dodawanie tekstu Polecenie

Dodaje tekst

i

Przed kursorem

I

Przed pierwszym w wierszu znakiem innym niż znak odstępu.

a

Za kursorem.

A

Na końcu wiersza.

o

Tworzy nowy wiersz poniżej bieżącego.

O

Tworzy nowy wiersz powyżej bieżącego.

r

Zastępuje bieżący znak (brak konieczności naciśnięcia klawisza Esc).

R

Zastępuje znaki, począwszy od znaku bieżącego (nadpisanie aż do Esc).

W tabeli 6.16 wymieniono polecenia pozwalające na usuwanie i zmianę tekstu. W tej tabeli M oznacza jednostkę miary, którą można poprzedzić liczbą określającą ilość powtórzeń (n to opcjonalna wartość), natomiast c oznacza dowolny znak. Tabela 6.16. Usuwanie i zmiana tekstu Polecenie

Opis

nx

Usunięcie liczby znaków określonej przez wartość n, począwszy od znaku bieżącego.

nX

Usunięcie n znaków przed bieżącym, począwszy od znaku poprzedzającego bieżący.

dM

Usunięcie tekstu określonego przez M.

ndd

Usunięcie n wierszy.

dtc

Usunięcie znaków do kolejnego znaku c w bieżącym wierszu.

D

Usunięcie do końca wiersza.

n~

Zmiana wielkości kolejnych n znaków.

Poniższe polecenia powodują pozostawienie edytora vim w trybie wprowadzania. Aby powrócić do trybu komend, konieczne jest naciśnięcie klawisza Esc. ns

Zastąpienie n znaków.

S

Zastąpienie całego wiersza.

cM

Zmiana tekstu określonego przez M.

ncc

Zmiana n wierszy.

ctc

Zmiana kolejnego znaku c w bieżącym wierszu.

C

Zmiana do końca wiersza.

W tabeli 6.17 wymieniono polecenia wyszukiwania. W tej tabeli które może być prostym ciągiem tekstowym.

rexp

oznacza wyrażenie regularne,

Składnia polecenia zastępowania jest następująca: :[adres]s/szukany-ciąg-tekstowy/nowy-ciąg-tekstowy[/g]

gdzie adres oznacza numer wiersza lub dwa numery rozdzielone przecinkiem. Kropka (.) oznacza bieżący wiersz, znak dolara ($) oznacza ostatni wiersz, natomiast znak procentu (%) oznacza cały plik. Zamiast numeru wiersza można użyć znacznika lub szukanego ciągu tekstowego. Wspomniany szukany-ciąg-tekstowy to wyrażenie regularne, które może być prostym ciągiem tekstowym znaków. Natomiast nowy-ciąg-tekstowy wskazuje ciąg, którym będzie zastąpiony szukany ciąg. Opcja g wskazuje na przeprowadzenie zastępowania globalnego (czyli zastępowanie w więcej niż tylko jednym wierszu).

Podsumowanie rozdziału  235

Tabela 6.17. Wyszukiwanie Polecenie

Opis

/rexpEnter

Wyszukiwanie wyrażenia rexp do przodu.

?rexpEnter

Wyszukiwanie wyrażenia rexp do tyłu.

n

Dokładne powtórzenie początkowego wyszukiwania.

N

Powtórzenie początkowego wyszukiwania, ale w przeciwnym kierunku.

/Enter

Powtórzenie do przodu początkowego wyszukiwania.

?Enter

Powtórzenie do tyłu początkowego wyszukiwania.

fc

Umieszcza kursor w kolejnym znaku c w bieżącym wierszu.

Fc

Umieszcza kursor w poprzednim znaku c w bieżącym wierszu.

tc

Umieszcza kursor w znaku poprzedzającym (po lewej stronie) kolejnego znaku c w bieżącym wierszu.

Tc

Umieszcza kursor w znaku znajdującym się po poprzednim znaku c w bieżącym wierszu.

;

Powtarza ostatnie polecenie f, F, t lub T.

W tabeli 6.18 wymieniono różne polecenia edytora vim. Tabela 6.18. Różne polecenia edytora vim Polecenie

Opis

J

Łączy bieżący wiersz z kolejnym.

.

Powtarza ostatnie polecenie, które wprowadziło zmianę.

:w plik

Zapisuje zawartość bufora roboczego w pliku (lub w pliku bieżącym, jeśli nie podano nazwy pliku).

:q

Zakończenie działania edytora vim.

ZZ

Zapis zawartości bufora roboczego do bieżącego pliku i zakończenie działania edytora vim.

:f lub Ctrl+G

Wyświetla nazwę pliku, stan, numer bieżącego wiersza, liczbę wierszy w buforze roboczym oraz procentową wielkość części bufora roboczego poprzedzającej bieżący wiersz.

Ctrl+V

Wstawia kolejny znak dosłownie, nawet jeśli to jest polecenie vim (kombinacji używaj w trybie wprowadzania).

W tabeli 6.19 wymieniono polecenia pozwalające na skopiowanie i wstawienie tekstu. W tej tabeli M oznacza jednostkę miary, którą można poprzedzić liczbą określającą ilość powtórzeń (n). Dowolne z poniższych poleceń można poprzedzić nazwą bufora, używając w tym celu postaci ''x, gdzie x to nazwa bufora (a – z). Tabela 6.19. Polecenie służące do kopiowania i wklejania tekstu Polecenie

Opis

yM

Skopiowanie tekstu wskazanego przez M.

nyy

Skopiowanie n wierszy.

Y

Skopiowanie tekstu aż do końca wiersza.

P

Wklejenie tekstu przed kursorem lub powyżej.

p

Wklejenie tekstu po kursorze lub poniżej kursora.

236  ROZDZIAŁ 6. EDYTOR VIM W tabeli 6.20 wymieniono zaawansowane polecenia edytora vim. Tabela 6.20. Polecenia zaawansowane Polecenie

Opis

mx

Ustawia znacznik x, gdzie x oznacza literę od a do z.

'' (dwa apostrofy)

Przenosi kursor do jego poprzedniego położenia.

' x

Przenosi kursor do znacznika x.

` x

Przenosi kursor do znaku ze znacznikiem x.

:e plik

Przeprowadza edycję pliku, wymagając zapisania zmian w bieżącym pliku (za pomocą polecenia :w lub autowrite) przed rozpoczęciem edycji nowego pliku. Użycie polecenia :e! plik spowoduje odrzucenie zmian w bieżącym pliku. Z kolei użycie :e! bez nazwy pliku powoduje odrzucenie zmian w bieżącym pliku oraz rozpoczęcie edycji zapisanej wersji bieżącego pliku.

:n

Pozwala na edycję kolejnego pliku, gdy vim został uruchomiony z podaniem więcej niż tylko jednej nazwy pliku. Wymaga zapisania zmian w bieżącym pliku (za pomocą polecenia :w lub autowrite) przed rozpoczęciem edycji nowego pliku. Użycie polecenia :n! spowoduje odrzucenie zmian w bieżącym pliku i przejście do edycji kolejnego.

:rew

Pozwala na przejrzenie listy nazw plików, gdy vim został uruchomiony z podaniem więcej niż tylko jednej nazwy pliku. Wymaga zapisania zmian w bieżącym pliku (za pomocą polecenia :w lub autowrite) przed rozpoczęciem edycji pierwszego pliku. Użycie polecenia :rew! spowoduje odrzucenie zmian w bieżącym pliku i przejście do edycji pierwszego.

:sh

Uruchamia powłokę. Wyjście z powłoki powoduje powrót do edytora vim.

:!polecenie

Uruchamia powłokę i wykonuje polecenie.

:!!polecenie

Uruchamia powłokę, wykonuje polecenie i umieszcza jego dane wyjściowe w buforze roboczym, zastępując zawartość bieżącego wiersza.

ĆWICZENIA 1. W jaki sposób można przejść do trybu wprowadzania w edytorze vim? Jak można cofnąć polecenie vim wydane w trybie komend? 2. Co to jest bufor roboczy? Podaj dwa sposoby zapisu zawartości bufora roboczego do pliku na dysku. 3. Przyjmujemy założenie, że edytowany jest plik zawierający poniższy akapit, a kursor znajduje się na drugiej tyldzie (~): Edytor vim posiada polecenie tylda (~), które powoduje zmianę małych liter na wielkie i na odwrót. Polecenie ~ działa wraz z jednostkami miary i tym samym pozwala na jednorazową zmianę wielkości więcej niż tylko jednego znaku.

W jaki sposób można: a) Przenieść kursor na koniec akapitu? b) Przenieść kursor na początek słowa jednostkami? c) Zmienić słowo znaku na litery?

Ćwiczenia zaawansowane  237

4. Podczas pracy w edytorze vim, gdy kursor jest umieszczony na pierwszej literze słowa, wydajesz polecenie x, a następnie p. Wyjaśnij otrzymany wynik. 5. Jaka jest różnica pomiędzy wymienionymi poniżej poleceniami? a) i oraz I b) a oraz A c) o oraz O d) r oraz R e) u oraz U 6. Jakiego polecenia użyjesz w celu przeszukania bufora roboczego do tyłu, począwszy od wiersza zawierającego słowo tym? 7. Jakie polecenie pozwala na zastąpienie wszystkich wystąpień wyrażenia ten tydzień wyrażeniem następny tydzień? 8. Załóżmy następującą sytuację: uruchamiasz edytor vim w celu edycji istniejącego pliku. Wprowadzasz zmiany w pliku, a następnie orientujesz się, że na początku procesu edycji usunąłeś ważną sekcję pliku. Chcesz odzyskać wspomnianą sekcję, ale jednocześnie nie chcesz utracić wprowadzonych dotąd zmian. Co zrobisz? 9. Jak możesz przenieść bieżący wiersz na początek pliku? 10. Użyj edytor vim do utworzenia pliku lista_e zawierającego litery e. Wspomnianego pliku używaliśmy w rozdziale 3. Użyj jak najmniejszej liczby poleceń edytora vim. Których poleceń użyłeś?

ĆWICZENIA ZAAWANSOWANE 11. Jakich poleceń użyjesz, aby skopiować akapit w jednym pliku, a następnie wstawić go w innym? 12. Utwórz plik zawierający poniższą listę, a następnie w edytorze vim wykonaj polecenia prowadzące do posortowania listy i wyświetlenia jej w dwóch kolumnach. (Podpowiedź: informacje na temat polecenia pr znajdziesz w części VI książki). Tryb komend Tryb wstawiania Tryb ostatniego wiersza Bufor roboczy Bufor ogólnego przeznaczenia Nazwany bufor Wyrażenie regularne Szukany ciąg tekstowy Nowy ciąg tekstowy Plik startowy Ilość powtórzeń

13. Czym różni się bufor nazwany od bufora ogólnego przeznaczenia? 14. Przyjmujemy założenie, że używana wersja vim nie pozwala na cofnięcie więcej niż tylko jednego ostatniego polecenia. Jeżeli usuniesz wiersz tekstu, następnie usuniesz drugi wiersz, a później kolejny wiersz tekstu, to w jaki sposób możesz odzyskać dwa wiersze tekstu usunięte wcześniej? 15. Jakiego polecenia użyjesz do zamiany zawierającego dowolną liczbę zbioru słów w dowolnym wierszu? (Nie musisz przejmować się znakami przestankowymi, a jedynie małymi i wielkimi literami oraz spacjami).

238  ROZDZIAŁ 6. EDYTOR VIM

7 Edytor emacs

W TYM ROZDZIALE: Historia emacs kontra vim

Poradnik — rozpoczęcie pracy z edytorem emacs Podstawowe polecenia edycyjne Pomoc dostępna w edytorze Zaawansowana edycja Najważniejsze tryby — edycja w zależności od języka Dostosowanie edytora emacs do własnych potrzeb

CELE ROZDZIAŁU Po przeczytaniu tego rozdziału będziesz potrafił:  Używać edytora emacs do tworzenia i edycji pliku.  Zapisywać i pobierać bufor.  Korzystać z pomocy dla emacs.  Wyjaśnić, jak przenosić kursor o znaki, słowa, wiersze i akapity.  Wymienić polecenia pozwalające na przenoszenie kursora do przodu i do tyłu o znaki lub słowa.  Wyjaśnić, jak przeprowadzać wyszukiwanie tekstu do przodu i do tyłu oraz czym jest wyszukiwanie przyrostowe.  Opisać klawisze stosowane przez emacs.  Podzielić okno.  Opisać proces cofania wprowadzonych zmian.

240  ROZDZIAŁ 7. EDYTOR EMACS

HISTORIA W roku 1958 John McCarthy (MIT) opracował język Lisp (ang. List processing). Wedle początkowej koncepcji Lisp posiadał jedynie kilka skalarnych (niepodzielnych) typów danych oraz tylko jedną strukturę danych: listę. Listy mogły zawierać niepodzielne dane lub inne listy. Język Lisp oferował obsługę rekurencji oraz danych nieliczbowych (ekscytujące koncepcje w czasie popularności języków Fortran i COBOL), a w kulturze Cambridge stał się ulubionym językiem implementacji. Richard Stallman i Guy Steele byli częścią wspomnianej kultury MIT Lisp. W roku 1975 współpracowali nad edytorem emacs, który przez dłuższy czas był tworzony jedynie przez Stallmana. W tym rozdziale omawiam edytor emacs w implementacji Free Software Foundation (GNU) w wersji 23. Strona domowa edytora emacs to http://www.gnu.org/software/emacs/. Edytor emacs powstał jako seria rozszerzeń poleceń i makr dla opracowanego w późnych latach sześćdziesiątych edytora TECO (ang. Text Editor and COrrector). Jego nazwa (Editor MACroS) odzwierciedla korzenie, choć istnieje również wiele humorystycznych reinterpretacji nazwy emacs, na przykład Esc Meta Alt Ctrl Shift, Emacs Makes All Computing Simple, a nawet pewnych nieprzyjaznych rozwinięć skrótu, takich jak Eight Megabytes And Constantly Swapping.

EWOLUCJA Na przestrzeni lat edytor emacs był rozbudowywany i doczekał się ponad dwudziestu wydań głównych dla wersji GNU. Utworzony w języku C składa się z kompletnego interpretera Lisp, a także w pełni obsługuje system X Window i interakcję za pomocą myszy. Oryginalne makra TECO już dawno odeszły, ale emacs nadal jest intensywnie rozwijany. Wersja 22. przyniosła poważne zmiany w zakresie internacjonalizacji: rozszerzony wewnętrzny zestaw znaków UTF-8 cztery razy większy niż Unicode, a także czcionki i klawiatury dla ponad 30 języków. Ponadto interfejs użytkownika jest rozwijany w kierunku procesora tekstu WYSIWYG (ang. What You See Is What You Get, czyli dostaniesz to, co widzisz), co początkującym osobom powinno ułatwić używanie edytora. Edytor emacs od zawsze był więcej niż tylko edytorem tekstów. Ponieważ nie został opracowany w początkowym środowisku UNIX, nie stosuje jego filozofii. Podczas gdy narzędzia UNIX/Linux są zwykle zaprojektowane do wykonywania pojedynczych zadań oraz używania w połączeniu z innymi narzędziami, emacs jest przeznaczony do „robienia wszystkiego”. Wykorzystanie zalet języka programowania Lisp umożliwia użytkownikom emacs dostosowanie edytora do własnych potrzeb i rozszerzanie go zamiast używania istniejących narzędzi bądź tworzenia nowych ogólnego przeznaczenia. Użytkownicy najczęściej dzielą się swoimi plikami ~/.emacs (plik startowy). Przed pojawieniem się systemu X Window Stallman włożył dużo wysiłku w przygotowanie i zaprojektowanie doskonale przemyślnego środowiska pracy opartego na oknach. Edytora emacs używał jako swojego narzędzia rozwoju. Na przestrzeni lat dodał do emacs kolejne funkcje pozwalające na obsługę poczty e-mail, grup dyskusyjnych, wykonywanie poleceń powłoki, kompilację programów i analizę komunikatów błędów, uruchamianie i debugowanie programów, a także granie w gry. Ostatecznie stało się możliwe uruchomienie środowiska emacs i pozostawanie w nim przez cały dzień, przełączając się jedynie pomiędzy oknami i plikami. Jeżeli dysponujesz jedynie podstawowym, szeregowym terminalem znakowym, edytor emacs daje Ci potężne możliwości. W środowisku systemu X Window emacs nie musi kontrolować całego ekranu. Zamiast tego zwykle działa tylko w jednym lub dwóch oknach. Początkowe środowisko tekstowe jest nadal dostępne i będzie omówione w tym rozdziale. Jako edytor dostosowany do języka emacs posiada funkcje specjalne, które można włączyć i tym samym ułatwić sobie edycję tekstu plików w formacie nroff, TeX, Lisp, C, Fortran itd. Wspomniane zestawy funkcji są nazywane trybami, ale nie są powiązane z trybami komend i wprowadzania stosowanymi w vi, vim oraz innych edytorach.

Historia  241

EMACS KONTRA VIM Na stronie http://pl.wikipedia.org/wiki/Wojna_edytorowa znajdziesz informacje o nieustannym sporze pomiędzy użytkownikami edytorów vi i emacs. Możesz też w ulubionej wyszukiwarce internetowej wpisać wyrażenie emacs vs vi, a otrzymasz mnóstwo wyników. Podobnie jak vim, emacs jest edytorem ekranowym — na ekranie jest wyświetlany edytowany tekst, a wprowadzany tekst i wszelkie zmiany są widoczne natychmiast. W przeciwieństwie do edytora vim emacs nie wymaga śledzenia trybu pracy edytora (komend lub wstawiania), ponieważ polecenia są wydawane poprzez użycie klawisza Ctrl lub innych klawiszy specjalnych. Edytor emacs wstawia w edytowanym tekście zwykłe znaki — to przeciwieństwo używania zwykłych znaków jako poleceń i kolejna cecha edytora pozbawionego trybów pracy. Dla wielu osób tego rodzaju podejście jest wygodne i naturalne. Podobnie jak w przypadku vim edytora emacs używasz do edycji pliku w obszarze roboczym nazywanym buforem, a po zakończeniu pracy masz możliwość zapisu wspomnianego bufora z powrotem na dysk. Jednak emacs oferuje wiele buforów, pomiędzy którymi możesz się przełączać bez konieczności ich wcześniejszego zapisu, a następnie ponownego odczytu. Co więcej, na ekranie można jednocześnie wyświetlić wiele buforów, każdy w oddzielnym oknie w edytorze emacs. Ten sposób wyświetlania plików jest wygodny podczas wycinania i wklejania tekstu, a także wtedy, gdy deklaracje w języku C chcesz pozostawić widoczne podczas edycji powiązanego z nimi kodu w innej części pliku. Podobnie jak w przypadku vim, edytor emacs oferuje rozbudowany zestaw poleceń pozwalających na poruszanie się po buforze oraz zmianę tekstu. Wspomniany zestaw poleceń nie został ustalony na stałe — w dowolnej chwili możesz go zmieniać i dostosowywać do własnych potrzeb. Dowolny klawisz może zostać przypisany do dowolnego polecenia, aby zapewnić lepsze dopasowanie do używanej klawiatury bądź własnych upodobań. Przypisania klawiszy najczęściej są definiowane w pliku startowym ~/.emacs, ale mogą być zmienione także interaktywnie w trakcie sesji pracy z emacs. Wszystkie przypisania klawiszy przedstawione w rozdziale są standardowo stosowane w wersji GNU edytora emacs.

OSTRZEŻENIE Zbyt wiele przypisań klawiszy Jeżeli zmienisz zbyt wiele przypisań klawiszy, to możesz otrzymać zestaw poleceń, którego nie będziesz pamiętać, a powrót do standardowych przypisań klawiszy w danej sesji może okazać się niemożliwy. Wreszcie w przeciwieństwie do edytora vim emacs pozwala na używanie języka Lisp do tworzenia nowych poleceń lub nadpisywania istniejących. Stallman nazwał tę funkcję rozszerzalnością online, ale tworzenie i debugowanie nowych poleceń podczas edycji tekstu wymaga dobrej znajomości języka Lisp. Znacznie częściej stosowane rozwiązanie polega na dodawaniu dopracowanych poleceń do pliku .emacs; zostaną one wczytane podczas uruchamiania edytora. Doświadczeni użytkownicy bardzo często tworzą tryby (środowiska), które są warunkowo wczytywane przez emacs w celu wykonania określonego zadania. Więcej informacji na temat pliku .emacs znajdziesz w dalszej części rozdziału.

WSKAZÓWKA Ekran i okna emacs W tym rozdziale pojęcie ekran oznacza ekran terminala znakowego lub okno emulatora terminala w środowisku graficznym. Pojęcie okno odnosi się do okna emacs wyświetlanego na wspomnianym ekranie.

242  ROZDZIAŁ 7. EDYTOR EMACS WSKAZÓWKA emacs i system X Window Począwszy od wersji 19. GNU, emacs w pełni wykorzystuje środowisko systemu X Window. Jeżeli uruchomisz emacs z poziomu okna emulatora terminala działającego w środowisku graficznym, będziesz miał do dyspozycji interfejs graficzny dla edytora emacs. W tej książce nie zostanie omówiony interfejs graficzny, opcja -nw podczas uruchamiania emacs powoduje użycie interfejsu tekstowego w dowolnym środowisku. Zapoznaj się z przedstawionym nieco dalej punktem „Uruchomienie edytora emacs”.

PORADNIK — ROZPOCZĘCIE PRACY Z EDYTOREM EMACS Edytor emacs ma naprawdę ogromną liczbę funkcji, których można używać na wiele różnych sposobów. Pełny podręcznik użytkownika zawiera ponad 35 rozdziałów. Jednak sporą ilość pracy można wykonać za pomocą względnie niewielkiego zestawu poleceń. W tym podrozdziale będzie przedstawiona prosta sesja edycji, dowiesz się, jak uruchomić i zamknąć edytor emacs oraz jak poruszać kursorem i usuwać tekst. Omówienie pewnych kwestii zostało odłożone na później lub uproszczone w celu zachowania czytelności tego materiału.

WSKAZÓWKA Poradnik emacs dostępny w samym edytorze Edytor emacs posiada wbudowany poradnik. Po uruchomieniu programu naciśnięcie klawiszy Ctrl+H t powoduje rozpoczęcie sesji pracy w poradniku. Naciśnięcie klawiszy Ctrl+X Ctrl+C powoduje zamknięcie edytora emacs. Jeżeli masz otwarte więcej niż tylko jedno okno emacs, zapoznaj się ze wskazówką „Zamykanie okna pomocy” przedstawioną w dalszej części rozdziału.

URUCHOMIENIE EDYTORA EMACS Aby przeprowadzić edycję pliku o nazwie sample w edytorze emacs uruchomionym w trybie tekstowym, wydaj poniższe polecenie: $ emacs -nw -q sample

Opcja -nw musi być pierwszą w wierszu poleceń i zakazuje emacs użycia interfejsu graficznego. Natomiast opcja -q powoduje, że emacs nie odczyta pliku startowego ~/.emacs. Pominięcie odczytu wymienionego pliku gwarantuje, że emacs będzie zachowywał się w standardowy sposób, co będzie użyteczne dla początkujących, a także użytkowników, którzy po prostu chcą pominąć ten plik. Powyższe polecenie spowodowało uruchomienie edytora emacs, wczytanie pliku o nazwie sample do bufora i wyświetlenie jego zawartości na ekranie lub w oknie. Jeżeli nie istnieje plik o podanej nazwie, emacs wyświetli pusty ekran wraz z komunikatem (New file) na dole (patrz rysunek 7.1). Jeśli plik o podanej nazwie istnieje, emacs wyświetli jego zawartość oraz zupełnie inny komunikat na dole (patrz rysunek 7.3 nieco dalej w rozdziale). Uruchomienie emacs bez podania nazwy pliku w wierszu poleceń powoduje wyświetlenie ekranu powitalnego zawierającego informacje na temat używania edytora oraz listę jego podstawowych poleceń (patrz rysunek 7.2). Na początku emacs wyświetla pojedyncze okno. Na górze znajduje się wyświetlany w odwróconych kolorach pasek menu, do którego dostęp masz za pomocą myszy lub klawiatury. Naciśnięcie na klawiaturze F10, Meta+` (odwrotny apostrof) lub wydanie polecenia Meta+x tmm-menubar Enter powoduje wyświetlenie okna Menubar Completion List. Więcej informacji na ten temat znajdziesz w punkcie „Używanie paska menu za pomocą klawiatury” w dalszej części rozdziału.

Poradnik — rozpoczęcie pracy z edytorem emacs  243

Rysunek 7.1. Ekran edytora emacs po utworzeniu nowego pliku

Rysunek 7.2. Ekran powitalny w edytorze emacs

Na dole okna emacs znajduje się wyświetlany w odwróconych kolorach pasek tytułu nazywany wierszem trybu (ang. Mode Line). Jako minimum wiersz trybu dostarcza informacji o buforze wyświetlanym przez okno, wskazuje, czy bufor został zmodyfikowany, informuje o używanym trybie głównym i pomniejszym, a także o położeniu bufora w oknie. Gdy na ekranie wyświetlanych jest kilka okien, każde z nich posiada własny wiersz trybu. Na dole ekranu emacs pozostawia pojedynczy wiersz. To jest obszar Echo Area i minibufora (współistnieją w pojedynczym wierszu), które służą do wyświetlania komunikatów oraz poleceń specjalnych.

WSKAZÓWKA Podręcznik użytkownika edytora emacs Podręcznik użytkownika edytora emacs jest dostępny w samym edytorze. Po uruchomieniu emacs wykonaj polecenie Ctrl+H r. Następnie za pomocą klawiszy strzałek przejdź do sekcji, którą chcesz wyświetlić, i naciśnij Enter. Ewentualnie naciśnij M (kursor zostanie przeniesiony do minibufora) i wpisz nazwę sekcji (menu), którą chcesz wyświetlić. Naciśnięcie klawisza Tab spowoduje uzupełnienie nazwy menu, mechanizm uzupełniania nazw menu działa podobnie do uzupełniania nazw ścieżek (patrz nieco dalej w rozdziale). Zapoznaj się z przedstawioną w dalszej części rozdziału wskazówką dotyczącą zamykania okna pomocy. Dalej w rozdziale znajdziesz także podrozdział poświęcony pomocy w edytorze emacs. Na przykład: aby wyświetlić sekcję podręcznika użytkownika poświęconą minibuforowi, wydaj polecenie Ctrl+H r m minibuffer Enter. Możesz również wydać polecenie Ctrl+H r m min Tab Enter.

244  ROZDZIAŁ 7. EDYTOR EMACS Jeżeli popełnisz błąd podczas pisania w minibuforze, emacs wyświetli komunikat błędu w obszarze Echo Area. Wspomniany komunikat błędu nadpisze Twoje polecenie, ale emacs przywróci je po upływie kilku sekund. Krótki opis pozwala Ci na zapoznanie się z błędem, zanim będziesz mógł kontynuować pisanie w miejscu, w którym je zakończyłeś. Więcej informacji szczegółowych jest dostępnych w menu minibufora oraz podręczniku użytkownika emacs (zapoznaj się z wcześniej przedstawioną wskazówką). Kursor znajduje się w oknie lub w minibuforze. Wszystkie dane wejściowe oraz niemal cała edycja jest przeprowadzana w miejscu kursora. Kiedy wpisujesz zwykłe znaki, emacs umieszcza je w położeniu kursora. Jeżeli znak znajduje się pod kursorem lub po jego prawej stronie, w trakcie wprowadzania nowych będzie przesunięty w prawą stroną i tym samym nie stracisz żadnego znaku.

ZAKOŃCZENIE PRACY Polecenie, które powoduje zakończenie pracy z edytorem emacs, to Ctrl+X Ctrl+C. Wymienione polecenie możesz wydać w dowolnej chwili (w niektórych trybach może wystąpić konieczność wcześniejszego naciśnięcia klawiszy Ctrl+G). W ten sposób nastąpi eleganckie zakończenie pracy edytora emacs, który zapyta o zachowanie zmian wprowadzonych w trakcie sesji edycji. Jeżeli chcesz przerwać częściowo wprowadzone polecenie lub zatrzymać działające przed jego zakończeniem, naciśnij klawisze Ctrl+G. Edytor emacs wyświetli komunikat Quit w obszarze Echo Area i będzie oczekiwał na inne polecenia.

WSTAWIANIE TEKSTU Wpisanie zwykłego (widocznego na wydruku) znaku powoduje przesunięcie kursora i innych znaków po jego prawej stronie o jedną pozycję w prawo oraz wstawienie nowego znaku w miejsce powstałe na skutek przesunięcia istniejących znaków.

USUWANIE ZNAKÓW W zależności od używanej klawiatury i pliku startowego emacs różne klawisze mogą być przypisane różnym sposobom usuwania znaków. Kombinacja Ctrl+D najczęściej powoduje usunięcie znaku pod kursorem, podobnie jak klawisze Delete i Del. Klawisz Backspace zwykle powoduje usunięcie znaku znajdującego się po lewej stronie kursora. Wypróbuj wymienione klawisze i przekonaj się, jaki jest efekt ich działania.

WSKAZÓWKA Więcej informacji na temat usuwania znaków Jeżeli informacje podane w tym podrozdziale nie sprawdzają się, zajrzyj do sekcji zatytułowanej Deletion w podręczniku użytkownika emacs. W wierszu poleceń powłoki wydaj następujące polecenie: $ info emacs

Następnie wydaj polecenie m deletion, co spowoduje wyświetlenie dokumentu dokładnie omawiającego usuwanie małych fragmentów tekstu. Spacja pozwala na przewijanie dokumentu. Wydanie polecenia Q powoduje opuszczenie strony info. Te same informacje możesz znaleźć w podręczniku użytkownika dostępnym w edytorze emacs (Ctrl+H r, patrz w dalszej części rozdziału). Uruchom emacs i wprowadź kilka wierszy tekstu. Jeżeli popełnisz błąd, to popraw go, używając przedstawionych wcześniej sposobów usuwania znaków. Klawisz Enter powoduje wstawienie w buforze niewidocznego znaku końca wiersza, a kursor przechodzi do lewej krawędzi kolejnego wiersza. Jeżeli kursor znajduje się na początku wiersza i cofniesz go, wtedy przejdziesz na koniec poprzedniego wiersza. Przykładowy bufor został pokazany na rysunku 7.3.

Poradnik — rozpoczęcie pracy z edytorem emacs  245

Rysunek 7.3. Przykładowy bufor

WSKAZÓWKA Używaj klawiszy strzałek Czasami najłatwiejszym sposobem poruszania kursorem jest użycie klawiszy strzałek.

PRZENOSZENIE KURSORA Kursor możesz umieścić nad dowolnym znakiem w oknie emacs oraz przesuwać wspomniane okno, aby wyświetlać dowolny fragment bufora. Przenoszenie kursora do przodu lub do tyłu tekstu (patrz rysunek 6.8 w rozdziale 6.) może odbywać się o różne jednostki miary, na przykład znaki, słowa, zdania, wiersze lub akapity. Każde polecenie przeniesienia kursora można poprzedzić współczynnikiem powtórzenia (Ctrl+U i następnie argument liczbowy), który powoduje, że kursor zostanie przeniesiony o wskazaną liczbę jednostek miary. Argumenty liczbowe będą omówione w dalszej części rozdziału.

PRZENOSZENIE KURSORA O ZNAKI Naciśnięcie strzałki w prawo lub Ctrl+F powoduje przeniesienie kursora do przodu (w prawą stronę) o jeden znak. Jeżeli kursor znajduje się na końcu wiersza, polecenie zawinie wiersz i umieści kursor na początku następnego. Na przykład polecenie Ctrl+U 7 Ctrl+F powoduje przeniesienie kursora o siedem znaków do przodu.

Ctrl+F

Naciśnięcie strzałki w lewo lub Ctrl+B powoduje przeniesienie kursora do tyłu (w lewą stronę) o jeden znak. Na przykład polecenie Ctrl+U 7 Ctrl+B powoduje przeniesienie kursora o siedem znaków do tyłu. Polecenie Ctrl+B działa w podobny sposób jak polecenie Ctrl+F (patrz rysunek 7.4).

Ctrl+B

Rysunek 7.4. Przenoszenie kursora o znaki

PRZENOSZENIE KURSORA O SŁOWA Naciśnięcie Meta+f powoduje przeniesienie kursora do przodu o jedno słowo. Aby wywołać to polecenie, naciśnij klawisz Meta lub Alt, a następnie klawisz F. Jeżeli używana przez Ciebie klawiatura nie ma klawiszy Meta lub Alt, naciśnij i puść klawisz Esc, a następnie naciśnij F. Polecenie spowoduje umieszczenie kursora na pierwszym znaku niebędącym częścią słowa, w którym znajdował się kursor w chwili wykonania polecenia. Natomiast polecenie Ctrl+U 4 Meta+f powoduje przeniesienie kursora do przodu do miejsca znajdującego się o jedną spację za czwartym słowem. Więcej informacji znajdziesz w punkcie „Klawisze — notacja i użycie” nieco dalej w rozdziale.

Meta+f

246  ROZDZIAŁ 7. EDYTOR EMACS Naciśnięcie Meta+b powoduje przeniesienie kursora do tyłu o jedno słowo i umieszczenie kursora na pierwszej literze słowa. Jeżeli kursor znajdował się w miejscu pierwszej litery słowa, polecenie Meta+b przeniesie go do pierwszej litery poprzedniego słowa. Polecenie Meta+b działa podobnie jak polecenie Meta+f (patrz rysunek 7.5).

Meta+b

Rysunek 7.5. Przenoszenie kursora o słowa

PRZENOSZENIE KURSORA O WIERSZE Naciśnięcie Ctrl+A powoduje przeniesienie kursora na początek bieżącego wiersza, natomiast Ctrl+E na koniec bieżącego wiersza. Klawisz strzałka w górę lub Ctrl+P przenosi kursor o jeden wiersz w górę bezpośrednio nad miejsce, w którym kursor się znajdował. Z kolei klawisz strzałka w dół lub Ctrl+N przenosi kursor o jeden wiersz w dół. Podobnie jak w przypadku innych poleceń poruszania kursorem polecenia Ctrl+P i Ctrl+N można poprzedzić Ctrl+U wraz z argumentem liczbowym i tym samym przenieść kursor o wskazaną liczbę wierszy. Istnieje również możliwość użycia pary poleceń i przeniesienia kursora na przykład na początek poprzedniego wiersza, na koniec kolejnego wiersza itd. (patrz rysunek 7.6).

Ctrl+A Ctrl+E Ctrl+P Ctrl+N

Rysunek 7.6. Przenoszenie kursora o wiersze

PRZENOSZENIE KURSORA O ZDANIA, AKAPITY I W OBRĘBIE OKNA Naciśnięcie Meta+a przenosi kursor na początek bieżącego zdania, natomiast Meta+E na jego koniec. Polecenie Meta+{ przenosi kursor na początek bieżącego akapitu, a Meta+} na jego koniec. (Definicje zdań i akapitów przedstawiono w dalszej części rozdziału). Wymienione polecenia można poprzedzić współczynnikiem powtórzenia (Ctrl+U wraz z argumentem liczbowym) i przenieść kursor o wskazaną liczbę zdań lub akapitów.

Meta+a Meta+e Meta+{ Meta+}

Naciśnięcie Meta+r przenosi kursor na początek środkowego wiersza wyświetlanego w oknie. Polecenie można poprzedzić poleceniem Ctrl+U wraz z numerem wiersza (tutaj Ctrl+U nie wskazuje wartości współczynnika powtórzenia, ale numer wiersza na ekranie). Polecenie Ctrl+U 0 Meta+r przenosi kursor na początek pierwszego wiersza (wiersz zero) w oknie. Z kolei polecenie Ctrl+U (znak minus) przenosi kursor na początek ostatniego wiersza w oknie (patrz rysunek 7.7).

Meta+r

Poradnik — rozpoczęcie pracy z edytorem emacs  247

Rysunek 7.7. Przenoszenie kursora o zdania, akapity i w obrębie okna

EDYCJA W MIEJSCU POŁOŻENIA KURSORA Po umieszczeniu kursora w miejscu, w którym chcesz wstawić tekst, jego wprowadzanie nie wymaga żadnych poleceń. Podczas wpisywania tekstu emacs wyświetla go w położeniu kursora. Jakikolwiek znak znajdujący się pod kursorem lub po jego prawej stronie zostanie przesunięty w prawo. Jeżeli wprowadzi się dużą liczbę znaków i tekst przekroczy prawą krawędź okna, emacs wyświetli ukośnik (\) w pobliżu prawej krawędzi okna i zawinie tekst do kolejnego wiersza. Ukośnik pojawia się na ekranie, ale nie jest zapisywany w pliku i nigdy nie będzie wydrukowany. Wprawdzie masz możliwość tworzenia bardzo długich wierszy, ale niektóre narzędzia systemu Linux mają problemy z obsługą plików tekstowych zawierających tego typu wiersze. W celu podziału wiersza na dwa umieść kursor w miejscu podziału, a następnie naciśnij Enter. Naciśnięcie klawisza Backspace powoduje usunięcie znaku znajdującego się po lewej stronie kursora. Po każdym naciśnięciu Backspace kursor oraz pozostała część tekstu w tym wierszu przesuną się w lewą stronę.

Usuwanie tekstu

Aby połączyć wiersz ze znajdującym się powyżej, musisz umieścić kursor w pierwszym znaku drugiego wiersza, a następnie nacisnąć Backspace. Naciśnięcie Ctrl+D powoduje usunięcie znaku znajdującego się pod kursorem. Kursor pozostaje na swoim miejscu, ale pozostały tekst w wierszu przesuwa się w lewą stronę, zastępując usunięty znak. Jeżeli omówione tutaj polecenia nie działają w przedstawiony sposób, zapoznaj się ze wskazówką „Więcej informacji na temat usuwania znaków” we wcześniejszej części rozdziału.

ZAPISYWANIE I POBIERANIE BUFORA Niezależnie od zmian, jakie wprowadzisz w buforze podczas sesji pracy z edytorem emacs, plik powiązany z buforem nie zostanie uaktualniony aż do chwili zapisu bufora. Jeżeli zakończysz pracę edytora emacs bez zapisu bufora (emacs pozwala na to, o ile będziesz wytrwały), plik nie zostanie zmieniony, a wszelkie zmiany wprowadzone w trakcie sesji edycji będą utracone. Podczas zapisu zmodyfikowanego bufora z powrotem w pliku emacs może opcjonalnie najpierw utworzyć kopię zapasową pierwotnego pliku. Możesz zrezygnować z tworzenia wspomnianych kopii zapasowych i zdecydować się na tylko jeden poziom kopii zapasowej (to ustawienie domyślne) lub na tworzenie dowolnej liczby kopii zapasowych. Jeden poziom kopii zapasowej oznacza, że do nazwy pierwotnego pliku jest dodawana tylda (~). Z kolei wielopoziomowe kopie zapasowe charakteryzują się dodaniem .~n~ do nazwy pliku, gdzie n oznacza kolejny numer kopii, począwszy od 1. Zmienna version-control określa liczbę kopii tworzonych przez emacs. Więcej informacji na temat przypisywania wartości zmiennym edytora emacs znajdziesz w dalszej części rozdziału.

Kopia zapasowa

Polecenie Ctrl+X Ctrl+S powoduje zapis bieżącego bufora w powiązanym z nim pliku. Edytor emacs potwierdza powodzenie operacji przez wyświetlenie odpowiedniego komunikatu w obszarze Echo Area.

Zapis bufora

248  ROZDZIAŁ 7. EDYTOR EMACS Kiedy edytujesz plik za pomocą emacs i chciałbyś rozpocząć edycję innego pliku (w dokumentacji edytora emacs jest to określone mianem wizyty pliku), zawartość nowego pliku możesz umieścić w nowym buforze, używając polecenia Ctrl+X Ctrl+F. Edytor poprosi o podanie nazwy pliku, wczyta go do nowego bufora, a następnie wyświetli ten bufor w bieżącym oknie. Posiadanie dwóch plików otworzonych w jednej sesji edycji jest wygodniejsze niż zakończenie pracy z edytorem emacs, powrót do powłoki i uruchomienie kolejnej kopii emacs w celu edycji innego pliku.

Odczyt innego pliku

WSKAZÓWKA Odczyt pliku za pomocą polecenia Ctrl+X Ctrl+F Kiedy wydajesz polecenie Ctrl+X Ctrl+F w celu odczytu pliku, emacs wyświetla ścieżkę dostępu do katalogu, w którym spodziewa się znaleźć plik. Standardowo oznacza to ścieżkę do katalogu roboczego, ale w pewnych sytuacjach może być wyświetlona inna ścieżka dostępu, na przykład do katalogu domowego. Jeżeli wyświetlona ścieżka dostępu nie prowadzi do odpowiedniego katalogu, to musisz ją zmienić. Polecenie zapewnia mechanizm uzupełniania nazw ścieżek (patrz nieco dalej w rozdziale).

PODSTAWOWE POLECENIA EDYCJI W tym podrozdziale dokładniej omówię podstawowe polecenia edycji tekstu w jak edytować plik w pojedynczym pliku oraz pojedynczym oknie emacs.

emacs.

Dowiesz się,

KLAWISZE — NOTACJA I UŻYCIE Wprawdzie edytor emacs został zinternacjonalizowany, ale dane wejściowe pochodzące z klawiatury nadal ewoluują i stanowią rozszerzony kod ASCII, a jedno naciśnięcie klawisza zwykle oznacza jeden bajt. Klawiatury ASCII mają znane z maszyn do pisania klawisze Shift i Ctrl. Niektóre klawiatury mają również tak zwany klawisz Meta (inaczej Alt), który kontroluje ósmy bit. Opisanie znaku ASCII wymaga siedmiu bitów, ósmy bit w bajcie jest używany do przekazania informacji dodatkowych. Ponieważ ogromna ilość poleceń edytora emacs wykorzystuje znaki Ctrl lub Meta, Stallman był jednym z pierwszych, który opracował nienumeryczną notację w celu opisu naciśniętych klawiszy. Opracowane przez niego rozwiązanie, które nadal jest używane w społeczności edytora emacs, jest przejrzyste i jednoznaczne (patrz tabela 7.1). Wielkie litery C i M zostały użyte do wskazania naciśnięcia klawiszy odpowiednio Ctrl i Meta (Alt), a kilka prostych akronimów służy do wskazania większości najczęściej stosowanych znaków specjalnych, na przykład RET (w tej książce używamy Enter), LFD (LINEFEED), DEL (DELETE), ESC (ESCAPE), SPC (SPACE) i TAB. Większość dokumentacji emacs, włączając pomoc w internecie, stosuje tę notację. Tabela 7.1. Notacja klawiszy w edytorze emacs Znak

Klasyczna notacja edytora emacs

a (mała litera a)

a

Shift+a (duża litera A)

A

Ctrl+a

C-a

Ctrl+A

C-a (nie jest używany klawisz Shift), odpowiednik Ctrl+a

Meta+a

M-a

Meta+A

M-A (używany jest klawisz Shift), różni się od M-a

Ctrl+Meta+a

C-M-a

Meta+Ctrl+a

M-C-a (niezbyt często używane)

Podstawowe polecenia edycji  249

Sposób używania klawiszy przez emacs rodził pewne problemy. Wiele klawiatur nie było wyposażonych w klawisz Meta, a pewne systemy operacyjne odrzucały bit Meta. Oprócz tego zestaw poleceń emacs był sprzeczny z coraz bardziej przedawnionym modelem synchronizacji XON-XOFF, który również używał klawiszy Ctrl+S i Ctrl+Q. W systemie OS X większość klawiatur nie posiada klawisza Meta lub Alt1. Z dodatku D dowiesz się, jak skonfigurować klawisz Option w komputerze Mac, aby pełnił taką samą rolę jak Meta. Problem z brakującym klawiszem Meta został rozwiązany poprzez zdefiniowanie opcjonalnej dwuklawiszowej sekwencji początkowej, w której klawisz Esc zastępuje Meta. Jeżeli używana przez Ciebie klawiatura nie ma klawisza Meta lub Alt, możesz użyć sekwencji z Esc — naciskasz klawisz Esc, zwalniasz go, a następnie naciskasz klawisz, który w książce znajduje się po klawiszu Meta. Na przykład możesz użyć polecenia Esc a zamiast Meta+a lub Esc Ctrl+A zamiast Ctrl+Meta+A. Stallman uznaje model synchronizacji XON-XOFF za problem historyczny i nie ma w planach zmiany zestawu poleceń emacs. Jednak w dokumentach FAQ w pomocy dla edytora emacs można znaleźć kilka rozwiązań problemu.

WSKAZÓWKA Notacja stosowana w tej książce W tej książce zastosowano następującą notację: wielka litera po klawiszu Ctrl i mała litera po klawiszu Meta. W obu przypadkach nie trzeba naciskać klawisza Shift podczas naciskania klawisza Ctrl lub Meta. Wprawdzie wielka litera po klawiszu Meta (na przykład Meta+A) oznacza inny znak, ale z reguły nie ma żadnego skutku lub działa dokładnie tak samo, jak polecenie z użyciem małej litery.

POLECENIA I SEKWENCJE KLAWISZY W edytorze emacs związek pomiędzy sekwencją klawiszy (jeden lub więcej jednocześnie naciskanych klawiszy w celu wydania polecenia emacs) i poleceniami jest niezwykle elastyczny. Dlatego też zapewnia ogromną możliwość w zakresie dopasowania do własnych potrzeb. Sekwencje klawiszy możesz zmieniać i ponownie mapować na inne polecenia, a także zastępować bądź modyfikować same polecenia. Wprawdzie większość dokumentacji edytora emacs przedstawia szczegóły dotyczące naciśnięć klawiszy, jakby były poleceniami, ale trzeba koniecznie pamiętać, że obsługujący je mechanizm jest oddzielny od sekwencji klawiszy. Masz więc możliwość zmiany zachowania sekwencji klawiszy i poleceń. Więcej informacji znajdziesz w podrozdziale „Dostosowanie edytora emacs do własnych potrzeb” w dalszej części rozdziału.

META+X — WYKONANIE POLECENIA BEZ PRZYPISANIA KLAWISZY Mapowanie klawiszy w edytorze emacs (tabele, czyli wektory używane przez emacs do przekładania sekwencji klawiszy na polecenia, patrz nieco dalej w rozdziale) są bardzo intensywnie stosowane i bardzo często nie ma możliwości przypisania wszystkich poleceń sekwencjom klawiszy. Dowolne polecenie można wydać przez poprzedzenie jego nazwy kombinacją klawiszy Meta+x. Po naciśnięciu klawiszy Meta+x w obszarze Echo Area możesz wprowadzić polecenie. Naciśnięcie klawisza Enter po poleceniu powoduje jego wykonanie. Kiedy polecenie nie ma przypisanej sekwencji klawiszy, czasami jest opisane jako Meta+x nazwa-polecenia. Edytor emacs oferuje sprytny mechanizm uzupełniania większości oczekiwanych odpowiedzi. Po wprowadzeniu fragmentu odpowiedzi naciśnięcie klawisza spacji lub tabulatora

Sprytne uzupełnianie

1

To nieprawda, od kilku lat klawiatury standardowo dodawane przez Apple do komputerów Mac mają klawisz Alt, wcześniej klawisz Alt był opisany jako Option. W systemie OS X działanie klawiszy Alt i Option jest identyczne — przyp. tłum.

250  ROZDZIAŁ 7. EDYTOR EMACS powoduje (o ile to możliwe) uzupełnienie odpowiednio bieżącego słowa lub nawet całego polecenia. Wymuszenie uzupełnienia poza ostatni jednoznaczny fragment odpowiedzi lub wpisanie znaku zapytania powoduje wyświetlenie okna Completion List zawierającego listę dostępnych opcji. Mechanizm sprytnego uzupełniania działa podobnie jak uzupełnianie ścieżki dostępu (patrz nieco dalej w rozdziale).

ARGUMENTY LICZBOWE Niektóre polecenia edycji w edytorze emacs akceptują argument liczbowy podawany w charakterze współczynnika powtórzenia. Ten argument należy umieścić bezpośrednio przed sekwencją klawiszy dla danego polecenia. Brak wspomnianego argumentu niemal zawsze oznacza przyjęcie dla niego wartości 1. Nawet zwykły znak alfabetu może być poprzedzony argumentem liczbowym, co oznacza „wstaw ten znak podaną ilość razy”. Aby użyć argumentu liczbowego w poleceniu, skorzystaj z jednej z wymienionych poniżej technik.  Naciśnij klawisz Meta wraz z odpowiednią cyfrą (0 – 9) lub znak minus (-). Na przykład: aby wstawić dziesięć liter z, wydaj polecenie Meta+1 Meta+0 z.  Naciśnij klawisze Ctrl+U przed liczbą, włączając w nią także znak minus. Na przykład: aby przesunąć kursor o 20 słów do przodu, wydaj polecenie Ctrl+U 20 Meta+f. Dla wygody domyślną wartością współczynnika powtórzenia po naciśnięciu Ctrl+U jest 4, wymieniona wartość jest stosowana, jeśli po kombinacji nie podasz żadnej liczby. Na przykład polecenie Ctrl+U r spowoduje wstawienie ciągu tekstowego rrrr (4 * 1), natomiast Ctrl+U Ctrl+U r oznacza wstawienie rrrrrrrrrrrrrrrr (4 * 4 * 1). Aby szybko przewijać wysokie okno, możesz używać sekwencji Ctrl+U Ctrl+V (przewinięcie o 4 wiersze w dół), Ctrl+U Meta+v (przewinięcie o 4 wiersze w górę), Ctrl+U Ctrl+U Ctrl+V (przewinięcie o 16 wierszy w dół) lub Ctrl+U Ctrl+U Meta+v (przewinięcie o 16 wierszy w górę).

Ctrl+U

PUNKT I KURSOR Punkt to konkretne miejsce w buforze wskazujące, gdzie przeprowadzana jest operacja edycji i gdzie położony jest kursor. Ujmując rzecz dokładniej, punkt wskazuje lewą krawędź kursora — można uznać, że znajduje się pomiędzy dwoma znakami. Każde okno ma własny punkt, ale istnieje tylko jeden kursor. Kiedy kursor znajduje się w oknie, przeniesienie kursora oznacza także przeniesienie punktu. Opuszczenie okna przez kursor nie zmienia położenia punktu danego okna, pozostaje on na miejscu, gdy kursor powróci do okna. Wszystkie omówione wcześniej polecenia przenoszenia kursora powodują także przeniesienie punktu.

PRZEWIJANIE ZAWARTOŚCI BUFORA Bufor jest znacznie większy niż okno, w którym będzie wyświetlany. Konieczne jest więc zapewnienie sposobu na przewijanie zawartości bufora w górę oraz w dół, aby interesująca użytkownika jego część była wyświetlana w oknie. Przewijanie do przodu oznacza przesunięcie tekstu w górę, a nowe wiersze tekstu pojawiają się na dole okna. Naciśnięcie klawiszy Ctrl+V lub Page Down powoduje przewinięcie jednego okna (minus dwa wiersze w celu zachowania kontekstu). Przewijanie do tyłu oznacza przesunięcie tekstu w dół, a nowe wiersze tekstu pojawiają się na górze okna. Naciśnięcie klawiszy Meta+v lub Page Up powoduje przewinięcie jednego okna (ponownie minus dwa wiersze w celu zachowania kontekstu). Naciśnięcie klawiszy Ctrl+L czyści ekran i odświeża go, a kursor zostaje przeniesiony do środkowego wiersza w oknie. To polecenie jest użyteczne, gdy ekran zostanie zaśmiecony.

Ctrl+V Meta+V oraz Ctrl+L

Podstawowe polecenia edycji  251

Argument numeryczny poleceń Ctrl+V i Meta+v oznacza „przewiń o wskazaną liczbę wierszy”. Na przykład polecenie Ctrl+U 10 Ctrl+V powoduje przewinięcie tekstu w górę o dziesięć wierszy. Argument numeryczny polecenia Ctrl+L oznacza „przewijaj tekst, dopóki kursor nie znajdzie się we wskazanym wierszu tekstu”, gdzie 0 oznacza wiersz pierwszy, natomiast -1 oznacza wiersz na dole tuż nad wierszem trybu. Przewijanie odbywa się automatycznie, jeśli przekroczysz ograniczenia okna lub naciśniesz Ctrl+P bądź Ctrl+N. Istnieje możliwość przeniesienie kursora na początek bufora przez wydanie polecenia Meta+< lub na koniec po wydaniu polecenia Meta+>.

Meta+< oraz Meta+>

USUWANIE TEKSTU Pozbywasz się tekstu, możesz go usunąć na stałe lub przenieść do obszaru tymczasowego i opcjonalnie później przywrócić usunięty tekst. Słowo usunąć oznacza trwałe usunięcie tekstu, natomiast wycięcie oznacza jego przeniesienie do obszaru tymczasowego. Wspomniany obszar tymczasowy jest określany mianem Kill Ring i może zawierać kilka fragmentów wyciętego tekstu. Tekstu znajdującego się w obszarze Kill Ring można używać na wiele różnych sposobów (patrz punkt „Wytnij i wklej — wklejanie wyciętego tekstu” w dalszej części rozdziału).

Usunięcie kontra wycięcie

Polecenie Meta+d powoduje wycięcie tekstu, począwszy od kursora aż do końca bieżącego słowa. Polecenie Ctrl+K wycina tekst, począwszy od kursora, aż do końca wiersza. Znak końca wiersza (LINEFEED) nie zostaje usunięty, o ile punkt i kursor nie znajdują się po lewej stronie tego znaku. Taka konfiguracja pozwala na dotarcie do lewego końca wiersza za pomocą polecenia Ctrl+A, wycięcie całego wiersza poleceniem Ctrl+K i od razu wprowadzenie nowej zawartości wiersza bez konieczności tworzenia dla niego miejsca. Ponadto jeśli kursor jest na początku wiersza, to wydanie polecenia Ctrl+K Ctrl+U (lub Ctrl+U 2 Ctrl+K) powoduje wycięcie wiersza tekstu i miejsca zajmowanego przez ten wiersz.

Meta+d oraz Ctrl+K

WYSZUKIWANIE TEKSTU Edytor emacs pozwala na wyszukiwanie tekstu na wymienione poniżej sposoby.  Przyrostowo dla ciągu tekstowego.  Przyrostowo dla wyrażeń regularnych (możliwe, ale rzadko stosowane).  Kompletnego ciągu tekstowego.  Kompletnego wyrażenia regularnego (patrz dodatek A).

Każdy z wymienionych rodzajów wyszukiwania można prowadzić w obu kierunkach, do przodu i do tyłu bufora. Kompletne wyszukiwanie działa w taki sam sposób jak przeprowadzane w innych edytorach tekstu. Operacja rozpoczyna się dopiero po podaniu całego szukanego ciągu tekstowego. Natomiast wyszukiwanie przyrostowe rozpoczyna się po podaniu pierwszego znaku szukanego ciągu tekstowego i trwa w trakcie podawania kolejnych znaków. Początkowo takie podejście może wydawać się dezorientujące, ale okazuje się zaskakująco użyteczne.

WYSZUKIWANIE PRZYROSTOWE Pojedyncze polecenie wskazuje kierunek i rozpoczyna wyszukiwanie przyrostowe. Polecenie Ctrl+S rozpoczyna wyszukiwanie przyrostowe do przodu, natomiast Ctrl+R w przeciwnym kierunku.

Ctrl+S oraz Ctrl+R

Kiedy rozpoczyna się wyszukiwanie przyrostowe, w obszarze Echo Area emacs wyświetla komunikat I-search:. Po wprowadzeniu znaku edytor natychmiast zaczyna jego wyszukiwanie w buforze. Jeżeli znak zostanie znaleziony, emacs przenosi punkt i kursor do położenia znalezionego znaku, dzięki

252  ROZDZIAŁ 7. EDYTOR EMACS czemu możesz obserwować postęp operacji wyszukiwania. Jeśli wyszukiwanie zakończy się niepowodzeniem, emacs wyświetli odpowiedni komunikat. Po wprowadzeniu kolejnych znaków szukanego ciągu tekstowego masz możliwość podjęcia kilku działań, w zależności od wyniku wyszukiwania w danej chwili. Poniżej przedstawiono listę wyników oraz dostępne działania.  Operacja wyszukiwania znalazła interesujący Cię ciąg tekstowy i umieściła kursor po jego

prawej stronie. Przez naciśnięcie klawisza Enter możesz zatrzymać wyszukiwanie i pozostawić kursor w nowym położeniu. (Wszelkie polecenia edytora emacs, które nie są powiązane z operacją wyszukiwania, również spowodują zatrzymanie wyszukiwania. Dla początkujących użytkowników naciśnięcie klawisza Enter jest bezpieczniejsze).  Wyszukiwanie znalazło ciąg tekstowy, ale nie ten, którego szukałeś. Możesz doprecyzować

szukany ciąg tekstowy przez dodanie kolejnej litery, nacisnąć Ctrl+R lub Ctrl+S w celu znalezienia kolejnego wystąpienia szukanego ciągu tekstowego bądź też nacisnąć Enter, aby zatrzymać operację wyszukiwania i pozostawić kursor w bieżącym położeniu.  Wyszukiwanie dotarło do początku lub końca bufora i nastąpiło wyświetlenie komunikatu

Failing I-Search. W takim przypadku możesz podjąć jedno z poniższych działań.  Jeżeli popełniłeś błąd w trakcie wpisywania szukanego ciągu tekstowego, za pomocą

klawisza Backspace usuń niepotrzebne znaki z szukanego ciągu tekstowego. Tekst i kursor w oknie będą się zmieniać w trakcie usuwania kolejnych znaków.  Jeżeli chcesz „przeskoczyć” przez początek lub koniec bufora i kontynuować wyszukiwanie,

możesz to wymusić, naciskając Ctrl+R lub Ctrl+S.  Jeżeli szukany ciąg tekstowy nie został znaleziony, ale chcesz pozostawić kursor w bieżącym

położeniu, naciśnij klawisz Enter w celu zatrzymania operacji wyszukiwania.  Jeżeli wyszukiwanie się nie powiodło i chcesz po prostu powrócić do miejsca jego

rozpoczęcia, to naciśnij Ctrl+G (znak wyjścia). W przypadku nieudanego wyszukiwania pojedyncze polecenie Ctrl+G powoduje wyrzucenie z szukanego ciągu tekstowego wszystkich znaków, które nie mogą być znalezione. Jeżeli ta operacja spowoduje powrót do miejsca, od którego chcesz kontynuować wyszukiwanie, to możesz ponownie dodawać znaki do szukanego ciągu tekstowego. Natomiast jeśli nie chcesz kontynuować wyszukiwania od wspomnianego miejsca, drugie naciśnięcie Ctrl+G zatrzymuje operację wyszukiwania i pozostawia kursor w miejscu, w którym znajdował się w chwili rozpoczęcia całej operacji wyszukiwania.

WYSZUKIWANIE ZWYKŁE Jeżeli wolisz, aby operacja wyszukiwania poinformowała o sukcesie lub niepowodzeniu bez wyświetlania wyników pośrednich, wówczas możesz wydać polecenie wyszukiwania zwykłego do przodu (Ctrl+S Enter) lub do tyłu (Ctrl+R Enter). Wyszukiwanie rozpocznie się dopiero wtedy, gdy wprowadzisz pełny szukany ciąg tekstowy i ponownie naciśniesz Enter. Wymienione polecenia nie powodują „przeskoku” przez koniec bufora.

Ctrl+S Enter oraz Ctrl+R Enter

WYSZUKIWANIE WYRAŻENIA REGULARNEGO W edytorze emacs istnieje możliwość przeprowadzenia wyszukiwania wyrażenia regularnego w sposób zarówno zwykły, jak i przyrostowy. Do rozpoczęcia wyszukiwania wyrażenia regularnego wykorzystaj polecenia wymienione w tabeli 7.2.

Podstawowe polecenia edycji  253

Tabela 7.2. Wyszukiwanie wyrażenia regularnego Polecenie

Wynik

Meta+Ctrl+s

Przyrostowe wyszukiwanie wyrażenia regularnego prowadzone do przodu; polecenie prosi o podanie wyrażenia regularnego, operacja jest wykonywana po każdym wprowadzonym znaku.

Meta+Ctrl+r

Przyrostowe wyszukiwanie wyrażenia regularnego prowadzone do tyłu; polecenie prosi o podanie wyrażenia regularnego, operacja jest wykonywana po każdym wprowadzonym znaku.

Meta+Ctrl+s Enter

Pytanie o wyrażenie regularne, po jego podaniu wykonywane jest przyrostowe wyszukiwanie całego wyrażenia regularnego prowadzone do przodu.

Meta+Ctrl+r Enter

Pytanie o wyrażenie regularne, po jego podaniu wykonywane jest przyrostowe wyszukiwanie całego wyrażenia regularnego prowadzone do tyłu.

UŻYWANIE PASKA MENU ZA POMOCĄ KLAWIATURY W tym punkcie omówię używanie klawiatury w celu obsługi paska menu edytora emacs (patrz rysunek 7.1 wcześniej w rozdziale). W środowisku graficznym do tego celu można również wykorzystać mysz. Opcje paska menu są dopasowane do aktualnego trybu podstawowego (zapoznaj się z punktem „Tryby podstawowe — edycja w zależności od języka” w dalszej części rozdziału). Na przykład podczas edycji programu utworzonego w języku C pasek zawiera menu o nazwie C, w którym znajdują się polecenia przeznaczone do edycji i stosowania wcięć w kodzie źródłowym w języku C. Aby dokonać wyboru z paska menu, należy w pierwszej kolejności nacisnąć klawisz F10, Meta+` (odwrócony apostrof) lub wydać polecenie Meta+x tmm-menubar Enter. Edytor emacs wyświetli okno Menubar Completion List wraz z opcjami menu najwyższego poziomu (File, Edit, Options itd.), a bieżący wybór będzie wyświetlony w minibuforze. Na rysunku 7.8 pokazano okno Menubar Completion List wraz z aktualnie wybranym w minibuforze menu File.

Rysunek 7.8. Okno Menubar Completion List wyświetla opcje menu najwyższego poziomu

Gdy okno Menubar Completion List jest wyświetlone, wtedy możesz podjąć jedno z wymienionych poniżej działań:  Anulować wybór menu poprzez naciśnięcie Ctrl+G lub Esc Esc Esc. Ekran powróci do stanu

sprzed wyświetlenia okna Menubar Completion List.  Użyć klawiszy strzałki w górę oraz strzałki w dół w celu wyświetlenia w minibuforze kolejnych

opcji menu. Naciśnięcie klawisza Enter powoduje wybór wyświetlonej opcji.

254  ROZDZIAŁ 7. EDYTOR EMACS  Wpisać pokazany w oknie Menubar Completion List jednoznakowy skrót, który spowoduje

wybór wskazanej opcji. Nie musisz naciskać klawisza Enter.  Naciśnięcie klawisza Page Up lub Meta+v powoduje przeniesienie kursora do okna Menubar Completion List. Za pomocą klawiszy strzałek można przenosić kursor pomiędzy opcjami. Naciśnięcie Enter zatwierdza wybór opcji wskazywanej przez kursor. Natomiast naciśnięcie Esc Esc Esc powoduje wyjście z okna Menubar Completion List i powrót kursora do minibufora. Kiedy dokonasz wyboru z menu najwyższego poziomu, w oknie Menubar Completion List edytor wyświetli odpowiednie menu drugiego poziomu. Powtórz jedno z przedstawionych powyżej działań, aby dokonać wyboru z wyświetlonego menu. Po dokonaniu ostatecznego wyboru emacs zamyka okno Menubar Completion List i wykonuje operację wskazaną przez wybraną opcję menu. Więcej informacji na temat paska menu znajdziesz w podręczniku użytkownika emacs (zapoznaj się ze wskazówką w punkcie „Uruchomienie edytora emacs” wcześniej w rozdziale). emacs

POMOC DOSTĘPNA W EDYTORZE System pomocy emacs zawsze jest dostępny. W przypadku domyślnego przypisania klawiszy uruchamiasz go za pomocą Ctrl+H. Następnie system pomocy prosi o podanie jednoliterowego polecenia pomocy. Jeżeli nie wiesz, jakiego polecenia użyć, po prostu wpisz ? lub naciśnij Ctrl+H, aby w bieżącym oknie wyświetlić listę poleceń pomocy, każde z jednowierszowym opisem. Następnie emacs ponownie poprosi o podanie jednoliterowego polecenia pomocy. Jeżeli zrezygnujesz z pomocy, naciśnięcie Ctrl+G spowoduje anulowanie żądania pomocy i powrót do bufora.

Ctrl+H

Jeżeli dane wyjściowe pomocy mieszczą się w pojedynczym wierszu, to zostaną wyświetlone w obszarze Echo Area. Natomiast jeśli są obszerniejsze niż tylko jeden wiersz, to będą wyświetlone we własnym oknie. Do przewijania zawartości bufora do przodu i do tyłu służą polecenia Ctrl+V i Meta+v. Kursor pomiędzy oknami możesz przenosić za pomocą polecenia Ctrl+X o (mała litera O). Więcej informacji na temat pracy z wieloma oknami znajdziesz w dalszej części rozdziału.

WSKAZÓWKA Zamknięcie okna pomocy Aby zamknąć okno pomocy, gdy kursor znajduje się w oknie zawierającym edytowany przez Ciebie tekst, wydaj polecenie Ctrl+X 1 (jeden). Ewentualnie możesz przenieść kursor do okna pomocy (Ctrl+X o [mała litera O]) i wydać polecenie Ctrl+X 0 (zero) zamykające bieżące okno. Jeżeli system pomocy wyświetli okno zajmujące cały ekran, jak ma to miejsce po wydaniu polecenia Ctrl+H n (informacje o nowościach dotyczących edytora emacs) lub Ctrl+H t (poradnik edytora emacs), zamknięcie bufora pomocy następuje po wydaniu polecenia Ctrl+X k bądź też po przełączeniu buforów przez wydanie polecenia Ctrl+X b (dwa ostatnie polecenia zostaną omówione w dalszej części rozdziału). W wielu terminalach klawisze Backspace i strzałka w lewo generują znak Ctrl+H. Jeżeli zapomnisz, że używasz edytora emacs i spróbujesz cofnąć się o kilka znaków, to możesz przypadkowo wejść do systemu pomocy. Taka operacja w żaden sposób nie zagraża edytowanemu buforowi, ale utrata zawartości okna może być niepokojąca, zwłaszcza gdy nie wiadomo, jak ją przywrócić. Kiedy zostaniesz zapytany o rodzaj żądanej pomocy, wydanie polecenia Ctrl+G spowoduje usunięcie pytania i powrót do edytowanego bufora. Niektórzy użytkownicy mogą zdecydować się na wybór innego polecenia pomocy (patrz nieco dalej w rozdziale). W tabeli 7.3 wymieniono niektóre z dostępnych poleceń pomocy.

Pomoc dostępna w edytorze  255

Tabela 7.3. Polecenia pomocy Polecenie

Rodzaj oferowanej pomocy

Ctrl+H a

Prosi o podanie ciągu tekstowego i wyświetla listę poleceń, których nazwy zawierają wprowadzony ciąg tekstowy.

Ctrl+H b

Wyświetla długą tabelę przypisań klawiszy.

Ctrl+H c sekwencjaklawiszy

Wyświetla nazwę polecenia przypisanego do podanej sekwencji klawiszy. Dozwolone jest używanie wielu sekwencji klawiszy. W przypadku długich sekwencji, w których rozpoznawana jest tylko pierwsza część, polecenie opisuje pierwszą część, a nierozpoznaną część umieszcza po cichu w buforze. To może się zdarzyć w przypadku trzyznakowych klawiszy funkcyjnych (na przykład F1, F2 itd. na klawiaturze), które generują sekwencje takie jak Esc [ Shift.

Ctrl+H f

Prosi o podanie nazwy funkcji Lisp, a następnie wyświetla dla niej dokumentację. Ponieważ polecenia są funkcjami Lisp, możesz w tym miejscu podać nazwę polecenia.

Ctrl+H i

Wyświetla stronę informacyjną, którą można przeglądać w poszukiwaniu dalszej dokumentacji dla edytora emacs.

Ctrl+H k sekwencjaklawiszy

Wyświetla nazwę i dokumentację polecenia przypisanego danej sekwencji klawiszy. (Zapoznaj się z przedstawionymi wcześniej informacjami o poleceniu Ctrl+H c).

Ctrl+H l (mała litera L)

Wyświetla ostatnie 100 wprowadzonych znaków. Rekord jest przechowywany po przeprowadzeniu pierwszego etapu translacji klawiatury. Jeżeli masz dostosowaną do własnych potrzeb tabelę translacji klawiatury, musisz upewnić się o przeprowadzeniu odwrotnej translacji.

Ctrl+H m

Wyświetla dokumentację i specjalne przypisania klawiszy dla bieżącego trybu podstawowego (tekst, C itd., patrz w dalszej części rozdziału).

Ctrl+H n

Wyświetla stronę z nowościami o edytorze emacs, na której wymieniono ostatnio wprowadzone zmiany (przy czym ostatnie zmiany są umieszczone na początku).

Ctrl+H r

Wyświetla podręcznik użytkownika dla edytora emacs.

Ctrl+H t

Uruchamia sesję poradnika dla emacs.

Ctrl+H v

Prosi o podanie nazwy zmiennej Lisp, a następnie wyświetla dokumentację dla tej zmiennej.

Ctrl+H w

Prosi o podanie nazwy polecenia, a następnie wyszukuje wszystkie sekwencje klawiszy przypisane temu poleceniu. Dozwolone jest używanie wielu sekwencji klawiszy. (Zapoznaj się przedstawionymi wcześniej informacjami o poleceniu Ctrl+H c).

INFORMACJE DODATKOWE Jak już wcześniej wspomniano, system pomocy edytora emacs możesz wykorzystać do przeglądania wewnętrznego systemu Lisp. Dla zainteresowanych poniżej przedstawiono listę ciągów tekstowych Stallmana, które dopasowują wiele nazw w systemie Lisp. Aby uzyskać obraz wewnętrznej funkcjonalności edytora emacs, możesz użyć dowolnego z wymienionych poniżej ciągów tekstowych wraz z poleceniem Ctrl+H a (lista poleceń systemu pomocy) lub Meta+x apropos (prośba o podanie ciągu tekstowego, a następnie wyświetlenie listy zmiennych, których nazwy zawierają podany ciąg tekstowy). backward beginning buffer case change char defun delete describe

dir down end file fill find forward goto indent

insert kill line list mark mode next page paragraph

previous region register screen search sentence set sexp up

view what window word yank

256  ROZDZIAŁ 7. EDYTOR EMACS

ZAAWANSOWANA EDYCJA Podstawowe polecenia edycji w emacs wystarczają do wykonania wielu zadań, ale doświadczony użytkownik szybko odkryje potrzebę uzyskania dostępu do bardziej zaawansowanych funkcji. W tym podrozdziale omówimy wybrane funkcje zaawansowane oferowane przez edytor emacs.

COFANIE WPROWADZONYCH ZMIAN Sesja edycji rozpoczyna się z chwilą wczytania pliku do bufora emacs. Na tym etapie zawartość bufora dokładnie odpowiada zawartości pliku. Po wprowadzeniu pewnego tekstu i wykonaniu poleceń edycyjnych zawartość bufora będzie się różniła od zawartości pliku. Jeżeli jesteś zadowolony z wprowadzonych zmian, zmodyfikowany bufor możesz zapisać z powrotem w pliku i zakończyć sesję. W pobliżu lewej krawędzi wiersza trybu (patrz rysunek 7.1 na początku rozdziału) znajduje się wskaźnik informujący o stanie bufora, którego zawartość jest wyświetlana w oknie. Istnieją trzy możliwe stany wspomnianego wskaźnika: -- (bufor nie został zmodyfikowany), ** (bufor jest zmodyfikowany) i %% (bufor jest tylko do odczytu). Edytor emacs przechowuje informacje o wszystkich naciśniętych klawiszach (tekst i polecenia) od początku sesji edycji, ale do maksymalnej wielkości 20 000 znaków. Jeżeli mieścisz się we wspomnianym ograniczeniu, całą sesję pracy w buforze możesz cofać po jednym kroku. Jeżeli masz wiele buforów, każdy z nich przechowuje własną historię naciśniętych klawiszy. Operacja cofnięcia jest tak ważna, że przypisano jej dodatkową sekwencję znaków na wypadek, gdyby klawiatura nie była w stanie łatwo obsłużyć sekwencji podstawowej. Dwie wspomniane sekwencje to Ctrl+_ (znak podkreślenia, na starych klawiaturach ASR-33 to strzałka w lewo) i Ctrl+X u. Po wydaniu polecenia Ctrl+_ edytor emacs cofnie ostatnio wykonaną operację i przeniesie kursor do miejsca w buforze, w którym nastąpiła zmiana. W ten sposób będziesz mógł się przekonać, co zostało zrobione. Jeżeli po raz kolejny wydasz polecenie Ctrl+_, to cofnięta zostanie przedostatnia operacja itd. Nieustanne wydawanie polecenia Ctrl+_ może ostatecznie doprowadzić do tego, że bufor znajdzie się w początkowym, niezmodyfikowanym stanie. W takim przypadku wskaźnik ** powróci do postaci --. Kiedy ciąg poleceń cofnięcia operacji przerwiesz przez wpisanie tekstu bądź wydanie innego polecenia, wszystkie wprowadzone dotąd cofnięcia operacji staną się częścią historii wykonanych poleceń i będą mogły być cofnięte. Dzięki takiej strategii staje się możliwe przywrócenie pewnych operacji. Jeżeli zorientujesz się, że cofnąłeś zbyt wiele operacji, wydaj polecenie (nieszkodliwe, które nie spowoduje zmiany bufora, na przykład Ctrl+F) i rozpocznij przywracanie zmian. W tabeli 7.4 wymieniono pewne polecenia pozwalające na cofnięcie operacji. Tabela 7.4. Polecenia cofania wprowadzonych zmian Polecenie

Opis

Ctrl+_

Cofnięcie ostatniej zmiany.

Ctrl+_ Ctrl+F Ctrl+_

Cofnięcie ostatniej zmiany i wprowadzenie jej z powrotem.

Ctrl+_ Ctrl+_

Cofnięcie dwóch ostatnich zmian.

Ctrl+_ Ctrl+_ Ctrl+F Ctrl+_ Ctrl+_

Cofnięcie dwóch ostatnich zmian i wprowadzenie ich z powrotem.

Ctrl+_ Ctrl+_ Ctrl+F Ctrl+_

Cofnięcie dwóch ostatnich zmian i wprowadzenie z powrotem ostatniej.

Jeżeli nie pamiętasz ostatniej wprowadzonej zmiany, możesz wydać polecenie Ctrl+_ i tym samym cofnąć ją. Teraz jeśli postanowisz o zachowaniu ostatnio wprowadzonej zmiany, wydanie polecenia Ctrl+F Ctrl+_ spowoduje jej przywrócenie. Gdy bufor został zmodyfikowany przez przypadek, wydawaj polecenia Ctrl+_ dopóty, dopóki wskaźnik w wierszu trybu nie przyjmie postaci --.

Zaawansowana edycja  257

Jeżeli bufor zostanie całkowicie zniszczony i będziesz chciał rozpocząć pracę od początku, wydaj polecenie Meta+x revert-buffer, które spowoduje odrzucenie bieżącej zawartości bufora i ponowne wczytanie zawartości powiązanego z nim pliku. Edytor emacs poprosi o potwierdzenie tej operacji.

PUNKT, ZNACZNIK I REGION Punkt wskazuje bieżące miejsce edycji w buforze. Przenosząc kursor, możesz przenieść punkt w dowolne miejsce bufora. Istnieje również możliwość ustawienia znacznika o nazwie Mark w buforze. Sąsiadujące ze sobą znaki znajdujące się pomiędzy punktem i znacznikiem (lub w odwrotnej kolejności) są nazywane regionem. Wiele operacji jest przeprowadzanych na regionie bufora, a nie jedynie na znakach znajdujących się w pobliżu punktu.

PRZENIESIENIE ZNACZNIKA I UTWORZENIE REGIONU W przeciwieństwie do punktu znacznik nie jest taki łatwy do przeniesienia. Po ustawieniu znacznik może być przeniesiony jedynie przez jego ustawienie w innym miejscu. Każdy bufor posiada tylko jeden znacznik. Polecenie Ctrl+@ (lub Ctrl+Spacja) powoduje ustawienie znacznika w bieżącym położeniu kursora (i punktu). Niektóre klawiatury powodują wygenerowanie znaku Ctrl+@ po naciśnięciu Ctrl+Q. Wprawdzie to nie jest drugie przypisanie klawiszy dla wspomnianej operacji, ale czasami okazuje się wygodną alternatywą. Polecenie Ctrl+X Ctrl+X służy do zamiany miejscami punktu i znacznika (i przeniesienia kursora do nowego punktu).

Ctrl+@ oraz Ctrl+Spacja oraz Ctrl+X Ctrl+X

Aby utworzyć region, zwykle umieszczasz kursor (i punkt) na jednym końcu obszaru, który ma być regionem, i definiujesz w nim znacznik. Następnie wydajesz polecenie Ctrl+@ i przenosisz kursor (oraz punkt) do drugiego końca obszaru, który ma być regionem. Jeżeli zapomnisz, gdzie ustawiłeś znacznik, to możesz powrócić do tego miejsca przez wydanie polecenia Ctrl+X Ctrl+X. Kolejne naciśnięcie Ctrl+X Ctrl+X powoduje powrót kursora do poprzedniego położenia. Kilkukrotne powtórzenie poleceń pozwala na wyraźne pokazanie regionu. Jeżeli granice regionu Ci nie odpowiadają, zamień miejscami punkt i znacznik, wydając polecenie Ctrl+X Ctrl+X i przenosząc w ten sposób kursor z jednego końca regionu do drugiego, a następnie przesuń punkt. Operację kontynuuj, dopóki region nie będzie obejmował żądanego tekstu.

OPERACJE NA REGIONIE W tabeli 7.5 wymieniono polecenia operujące na regionie. Wydaj polecenie Ctrl+H a wyświetlić pełną listę tych poleceń.

region,

Tabela 7.5. Operacje na regionie Polecenie

Opis

Meta+w

Niedestrukcyjne skopiowanie regionu do obszaru Kill Ring.

Ctrl+w

Usunięcie regionu.

Meta+x print-region

Wydruk wskazanego regionu.

Meta+x append-to-buffer

Wyświetla pytanie o bufor, a następnie dołącza region do wskazanego bufora.

Meta+x append-to-file

Wyświetla pytanie o nazwę pliku, a następnie dołącza region do wskazanego pliku.

Meta+x capitalize-region

Konwertuje region na wielkie litery.

Ctrl+X Ctrl+L

Konwertuje region na małe litery.

aby

258  ROZDZIAŁ 7. EDYTOR EMACS

LISTA MARK RING Za każdym razem, gdy ustawisz znacznik w buforze, poprzednie położenie znacznika jest zapisywane na tak zwanej liście Mark Ring znajdującej się w buforze. Mark Ring działa jako lista typu FIFO (ang. First In, First Out, czyli pierwszy na wejściu, pierwszy na wyjściu) i przechowuje 16 ostatnich położeń znacznika Mark. Każdy bufor posiada własną listę Mark Ring. Zapis ostatniego położenia znacznika jest użyteczny, ponieważ często zdarza się, że chcesz szybko dostać się do wspomnianego położenia. Przejście do lokalizacji wskazywanej przez Mark Ring będzie szybsze i łatwiejsze niż przewijanie lub wyszukiwanie bufora w celu znalezienia poprzedniej zmiany. Do poruszania się pomiędzy lokalizacjami znacznika używane jest polecenie Ctrl+U Ctrl+@ wydane jeden lub więcej razy. Za każdym razem, gdy wydasz wymienione polecenie, edytor emacs :  przeniesie punkt (i kursor) do bieżącego położenia znacznika;

Ctrl+U Ctrl+@

 zapisze bieżące położenie znacznika na samym końcu listy Mark Ring;  wyrzuci najnowszy wpis listy Mark Ring i ustawi znacznik.

Każde dodatkowe wydanie polecenia Ctrl+U Ctrl+@ powoduje, że emacs przenosi punkt i kursor do lokalizacji określonej przez poprzedni wpis na liście Mark Ring. Wprawdzie przedstawiony proces może wydawać się trudny, ale tak naprawdę pozwala na bezpieczne przejście do poprzedniego położenia znacznika. Sam proces pozostaje bezpieczny, ponieważ każda zmiana punktu początkowego jest zapisywana na liście Mark Ring, co ułatwia jej ponowne odszukanie. Masz możliwość przejścia do wszystkich poprzednich położeń zapisanych na liście Mark Ring (to może być mniej niż 16) przez ponowne wydawanie polecenia Ctrl+U Ctrl+@. Przez listę Mark Ring możesz przejść dowolną ilość razy i zatrzymać się w wybranym położeniu.

AUTOMATYCZNE USTAWIENIE ZNACZNIKA Niektóre polecenia automatycznie powodują ustawienie znacznika. Idea polega na tym, aby pozostawić zakładkę przed przeniesieniem punktu na dużą odległość. Na przykład polecenie Meta+> powoduje ustawienie znacznika przed przejściem na koniec bufora. Następnie możesz szybko powrócić do poprzedniego położenia, wydając polecenie Ctrl+U Ctrl+@. Operacja wyszukiwania działa podobnie. Aby pomóc Ci w uniknięciu niespodzianki, zarówno po ręcznym, jak i automatycznym ustawieniu znacznika w obszarze Echo Area zostaje wyświetlony komunikat Mark Set.

WYTNIJ I WKLEJ — WKLEJANIE WYCIĘTEGO TEKSTU Przypomnij sobie, że wycięty tekst nie jest od razu trwale usuwany, ale przechowywany w obszarze Kill Ring. Wspomniany obszar może przechowywać ostatnie 30 wyciętych fragmentów tekstu i jest dostępny we wszystkich buforach. Pobranie tekstu z obszaru Kill Ring nosi nazwę wklejania (ang. yanking). Znaczenie tego pojęcia w edytorze emacs jest zupełnie przeciwne do jego znaczenia w edytorze vim. W edytorze vim wklejanie oznacza wyciągnięcie tekstu z bufora i umieszczenie go w buforze. Operacje wycinania i wklejania są podstawowym mechanizmem oferowanym przez edytor emacs do przenoszenia i kopiowania tekstu. W tabeli 7.6 wymieniono najczęściej używane polecenia przeznaczone do wycinania i wklejania tekstu. Aby przenieść dwa wiersze tekstu, umieść punkt na początku pierwszego wiersza, a następnie wydaj polecenie Ctrl+U 2 Ctrl+K w celu wycięcia dwóch wierszy. Przenieś punkt do położenia docelowego i wydaj polecenie Ctrl+Y. Aby skopiować dwa wiersze tekstu, umieść punkt na początku pierwszego wiersza, a następnie wydaj polecenie Ctrl+U 2 Ctrl+K Ctrl+Y w celu wycięcia z tekstu dwóch wierszy. Przenieś punkt do położenia docelowego i wydaj polecenie Ctrl+Y.

Zaawansowana edycja  259

Tabela 7.6. Najczęściej używane polecenia wycinania i wklejania tekstu Polecenie

Opis

Meta+d

Wycięcie znaków do końca bieżącego słowa.

Meta+D

Wycięcie znaków od początku poprzedniego słowa.

Ctrl+K

Wycięcie znaków do końca bieżącego wiersza z pominięciem znaku wysuwu wiersza.

Ctrl+U 1 Ctrl+K

Wycięcie znaków do końca bieżącego wiersza łącznie ze znakiem wysuwu wiersza.

Ctrl+U 0 Ctrl+K

Wycięcie znaków od początku wiersza.

Meta+w

Skopiowanie regionu do obszaru Kill Ring, ale region nie zostaje usunięty z bufora.

Ctrl+W

Wycięcie regionu.

Meta+z znak

Wycięcie znaków aż do kolejnego wystąpienia znaku.

Ctrl+Y

Ostatnio wycięty tekst zostaje wklejony w bieżącym buforze w miejscu wskazywanym przez punkt; na początku tego tekstu zostaje ustawiony znacznik, a kursor i punkt znajdują się na końcu tekstu.

Meta+y

Usunięcie właśnie wyciętego tekstu, przeprowadzenie rotacji w obszarze Kill Ring i wycięcie kolejnego elementu (tylko po wydaniu polecenia Ctrl+Y lub Meta+y).

Aby skopiować do bufora większy fragment tekstu, zdefiniuj region obejmujący wspomniany fragment tekstu i wydaj polecenie Ctrl+W Ctrl+Y w celu wycięcia regionu i wklejenia go z powrotem. Przenieś punkt do położenia docelowego i wydaj polecenie Ctrl+Y. Istnieje również możliwość ustawienia regionu, a następnie użycia polecenia Meta+w w celu skopiowania regionu do obszaru Kill Ring. Obszar Kill Ring jest zaimplementowany w postaci listy typu FIFO o stałej wielkości, dodanie nowego elementu powoduje usunięcie najstarszego (po umieszczeniu 30 elementów na liście). Ogólnie rzecz biorąc, proste operacje wytnij i wklej używają jedynie ostatnio dodanych elementów listy. Starsze elementy pozostają na liście, w ten sposób zyskujesz czas na zmianę zdania odnośnie do ich usunięcia. Jeżeli zmienisz zdanie, to zawsze możesz „przekopać” Kill Ring, dotrzeć do usuniętego fragmentu tekstu, a następnie skopiować go z powrotem do bufora. Aby przejrzeć elementy znajdujące się na liście Kill Ring, rozpocznij sesję „przekopywania” przez naciśnięcie Ctrl+Y. To polecenie powoduje umieszczenie najmłodszego elementu listy Kill Ring w buforze, a dokładnie w bieżącym położeniu kursora. Jeżeli to nie jest oczekiwany przez Ciebie fragment tekstu, kontynuuj sesję, wydając polecenie Meta+y. Spowoduje to usunięcie z bufora ostatnio wklejonego tekstu i skopiowanie w to miejsce kolejnego z listy. Jeżeli to nadal nie będzie oczekiwany przez Ciebie tekst, ponownie wydaj polecenie Meta+y, aby usunąć tekst i pobrać następny element listy itd. Kolejno wydawane polecenia Meta+y pozwalają na dokopanie się do najstarszego elementu listy Kill Ring. Jeśli nadal będziesz wydawał polecenie Meta+y, powrócisz do najmłodszego elementu listy. W ten sposób możesz dowolną ilość razy sprawdzić każdy element listy Kill Ring. Sekwencja użyta w powyższej sesji składa się z wydania polecenia Ctrl+Y, a następnie dowolnego połączenia poleceń Ctrl+Y i Meta+y. Jeżeli wydasz inne polecenie niż Meta+y, sekwencja zostanie przerwana i ponownie trzeba będzie wydać polecenie Ctrl+Y i rozpocząć kolejną sesję przekopywania się przez elementy listy Kill Ring. Podczas przekopywania się przez elementy listy Kill Ring można wykorzystać wskaźnik Last Yank. Wymieniony wskaźnik nie jest zerowany, a więc nie jest przypisywany do najmłodszego elementu listy Kill Ring po wykonaniu kolejnej operacji usunięcia tekstu. Dzięki tej technice możesz częściowo przejrzeć listę Kill Ring za pomocą polecenia Ctrl+Y i kilku Meta+y, następnie wydać polecenia inne niż usuwające tekst, a później powrócić do przeglądania listy Kill Ring od miejsca, w którym poprzednio skończyłeś ją przeglądać. Wystarczy wydać polecenie Ctrl+Y i kontynuować wydawanie poleceń Meta+y. Istnieje również możliwość umieszczenia wskaźnika Last Yank wraz z dodatnim lub ujemnym argumentem polecenia Meta+y. Więcej informacji na ten temat znajdziesz w dokumentacji.

260  ROZDZIAŁ 7. EDYTOR EMACS

WSTAWIANIE ZNAKÓW SPECJALNYCH Jak już wcześniej wspomniano, to wszystko, co nie jest poleceniem, emacs wstawia w buforze, a dokładnie w bieżącym położeniu kursora. W celu wstawienia znaków tworzących polecenie emacs konieczne jest ich poprzedzenie znakiem sterującym, czyli Ctrl+Q. Istnieją dwa sposoby używania wymienionego znaku sterującego:  Polecenie Ctrl+Q, a po nim dowolny inny znak powoduje wstawienie danego znaku do bufora,

niezależnie od interpretacji polecenia.  Polecenie Ctrl+Q, a po nim trzy cyfry ósemkowe powoduje wstawienie do bufora bajta o podanej wartości.

WSKAZÓWKA Polecenie Ctrl+Q W zależności od konfiguracji terminala polecenie Ctrl+Q może zakłócać działanie poleceń kontrolujących przepływ sterowania. Jeżeli polecenie Ctrl+Q nie przynosi żądanego skutku, prawdopodobnie jest używane jako polecenie kontrolujące przepływ sterowania. W takim przypadku musisz przypisać inną kombinację klawiszy poleceniu quoted-insert (patrz nieco dalej w rozdziale).

GLOBALNE POLECENIA DOTYCZĄCE BUFORA Edytor vim i jego poprzednicy zawierają polecenia globalne pozwalające na przeprowadzanie operacji wyszukiwania tekstu w buforze oraz jego zastępowania. Wspomniane polecenia działają na całym buforze. Edytor emacs ma podobną rodzinę poleceń. Działają one na fragmencie bufora pomiędzy punktem i końcem bufora. Jeżeli chcesz przeprowadzać operacje na całym buforze, wydaj polecenie Meta+< w celu przeniesienia punktu na początek bufora, a dopiero później wydawaj żądane polecenia.

OPERACJE NA WIERSZACH Polecenia wymienione w tabeli 7.7 pobierają wyrażenia regularne, a następnie stosują je względem wierszy znajdujących się pomiędzy punktem i końcem bufora. Tabela 7.7. Operacje na wierszach Polecenie

Opis

Meta+x occur

Polecenie prosi o podanie wyrażenia regularnego i kopiuje do bufora o nazwie *Occur* każdy wiersz zawierający dopasowane wyrażenie.

Meta+x delete-matching-lines

Polecenie prosi o podanie wyrażenia regularnego i usuwa wszystkie wiersze zawierające dopasowane wyrażenie.

Meta+x delete-non-matching-lines

Polecenie prosi o podanie wyrażenia regularnego i usuwa wszystkie wiersze, które nie zawierają dopasowanego wyrażenia.

Polecenie Meta+x occur powoduje umieszczenie danych wyjściowych w specjalnym buforze o nazwie *Occur*, który można wykorzystać na przykład w celu szybkiego przejścia do każdego wiersza. W tym celu należy się przełączyć do bufora *Occur*, wydając polecenie Ctrl+X o (mała litera O), przenieść kursor do kopii żądanego wiersza docelowego i wydać polecenie Ctrl+C Ctrl+C. Wymienione polecenie spowoduje przeniesienie kursora do przeszukiwanego bufora i umieszczenie go w wierszu dopasowanym przez wyrażenie regularne. Podobnie jak jest w przypadku każdej zmiany bufora, także efekt polecenia usunięcia tekstu można cofnąć.

Zaawansowana edycja  261

ZASTĘPOWANIE BEZWARUNKOWE I INTERAKTYWNE Polecenia wymienione w tabeli 7.8 działają na znakach znajdujących się pomiędzy punktem i końcem bufora, zmieniając każde dopasowanie ciągu tekstowego lub wyrażenia regularnego. Operacja zastępowania bezwarunkowego powoduje automatycznie wykonanie wszystkich zastąpień. Z kolei operacja zastępowania interaktywnego daje możliwość zobaczenia i zaakceptowania każdej zmiany przed jej wprowadzeniem. Tabela 7.8. Polecenia zastępowania Polecenie

Opis

Meta+x replace-string

Prosi o podanie starego i nowego ciągu tekstowego, a następnie zastępuje każde wystąpienie starego ciągu tekstowego nowym. Punkt pozostanie w miejscu ostatniej operacji zastąpienia. Po wydaniu polecenia nastąpi ustawienie znacznika, więc możesz do niego powrócić za pomocą Ctrl+U Ctrl+@.

Meta-x replace-regexp

Prosi o podanie wyrażenia-regularnego i ciągu-tekstowego, a następnie zastępuje każde wystąpienie wyrażenia-regularnego wskazanym ciągiemtekstowym. Punkt pozostanie w miejscu ostatniej operacji zastąpienia. Po wydaniu polecenia nastąpi ustawienie znacznika, więc możesz do niego powrócić za pomocą Ctrl+U Ctrl+@.

Meta+% ciąg-tekstowy lub Meta+x query-replace

Pierwsza wersja używa ciągu-tekstowego, natomiast druga prosi o jego podanie. Obie wersje proszą o podanie nowego-ciągu-tekstowego, sprawdzają wszystkie wystąpienia ciągu-tekstowgo i w zależności od odpowiedzi użytkownika zastępują go nowym-ciągiem-tekstowym. Punkt pozostanie w miejscu ostatniej operacji zastąpienia. Po wydaniu polecenia nastąpi ustawienie znacznika, więc możesz do niego powrócić za pomocą Ctrl+U Ctrl+@.

Meta+x query-replace-

Prosi o podanie wyrażenia-regularnego i nowego-ciągu-tekstowego, sprawdzając wszystkie dopasowania wyrażenia-regularnego i w zależności od odpowiedzi użytkownika zastępuje je nowym-ciągiem-tekstowym. Punkt pozostanie w miejscu ostatniej operacji zastąpienia. Po wydaniu polecenia nastąpi ustawienie znacznika, więc możesz do niego powrócić za pomocą Ctrl+U Ctrl+@.

regexp

Jeżeli przeprowadzasz interaktywną operację zastępowania, edytor emacs wyświetli każdy egzemplarz ciągu tekstowego lub dopasowania wyrażenia regularnego i poprosi o podjęcie odpowiedniego działania. W tabeli 7.9 wymieniono niektóre z możliwych odpowiedzi. Tabela 7.9. Odpowiedzi udzielane na interaktywne polecenia zastępowania Odpowiedź

Opis

Enter

Nie wykonuj już żadnych operacji zastąpień; zakończenie operacji.

Spacja

Wykonaj zastąpienie i kontynuuj operację.

Delete

Nie wykonuj tego zastąpienia, pomiń je i kontynuuj operację.

, (przecinek)

Wykonaj to zastąpienie, wyświetl wynik i poproś o inne polecenie. Dozwolone jest dowolne polecenie, ale naciśnięcie klawisza Delete jest traktowane jak naciśnięcie Spacji i nie można cofnąć zmiany.

. (kropka)

Wykonaj to zastąpienie i zakończ operację wyszukiwania.

! (wykrzyknik)

Zastąp to oraz wszystkie pozostałe wystąpienia bez zadawania kolejnych pytań.

262  ROZDZIAŁ 7. EDYTOR EMACS

WIZYTOWANIE I ZAPISYWANIE PLIKÓW Kiedy wizytujesz (stosowane w edytorze emacs pojęcie oznaczające wywołanie pliku) plik, emacs wczytuje jego zawartość do bufora (patrz nieco dalej w rozdziale), pozwala na edycję bufora i na koniec zwykle następuje zapis tego bufora z powrotem w pliku. Omówione w tym punkcie polecenia są związane z wizytowaniem i zapisywaniem plików. Każdy bufor edytora emacs przechowuje informacje o nazwie jego katalogu domyślnego (katalog, z którego plik został odczytany, bądź też katalog roboczy, jeśli to zupełnie nowy plik) dołączanej do każdej podanej względnej ścieżki dostępu. Dzięki temu nie trzeba wpisywać pełnej ścieżki dostępu. Wydanie polecenia Meta+x pwd powoduje wyświetlenie katalogu domyślnego dla bieżącego bufora, natomiast Meta+x cd pozwala na podanie nowego katalogu domyślnego i przypisanie go buforowi. W kolejnym punkcie omówię uzupełnianie ścieżki dostępu; z tego mechanizmu można skorzystać, gdy emacs poprosi o podanie ścieżki dostępu.

Meta+x pwd oraz Meta+x cd

WIZYTOWANIE PLIKÓW Edytor emacs działa doskonale, kiedy wizytujesz plik, który został już wcześniej wywołany, a jego zawartość znajduje się w buforze. Po sprawdzeniu daty i godziny ostatniej modyfikacji w celu upewnienia się, że plik nie został zmodyfikowany od chwili jego ostatniego wywołania, emacs po prostu przechodzi do bufora z zawartością wskazanego pliku. W tabeli 7.10 wymieniono polecenia przeznaczone do wizytacji plików. Tabela 7.10. Wizytowanie plików Polecenie

Opis

Ctrl+X Ctrl+F

Polecenie prosi o podanie nazwy pliku i wczytuje jego zawartość do nowego bufora. Prosta nazwa pliku jest stosowana jako nazwa bufora. Pozostałe bufory są nietknięte. Stosowanie takiego rozwiązania jest powszechną praktyką, pozwala na jednoczesne otworzenie wielu plików do edycji.

Ctrl+X Ctrl+V

Polecenie prosi o podanie nazwy pliku i zastępuje bieżący bufor buforem zawierającym zawartość wskazanego pliku. Dotychczasowa zawartość bieżącego bufora zostaje usunięta.

Ctrl+X 4 Ctrl+F

Polecenie prosi o podanie nazwy pliku i wczytuje jego zawartość do nowego bufora. Prosta nazwa pliku jest stosowana jako nazwa bufora. Tworzy nowe okno dla bufora i wybiera je. Okno wybrane przed wykonaniem tego polecenia nadal wyświetla ten sam bufor jak przed operacją, choć nowe okno może częściowo przykryć stare.

Aby utworzyć nowy plik, wystarczy go wywołać. Edytor utworzy pusty bufor i nada mu wskazaną nazwę, pod którą będzie można na końcu sesji edycji zapisać plik. W obszarze Echo Area zostanie wyświetlony komunikat (New File) informujący użytkownika, że emacs doskonale wie, co należy zrobić. Jeżeli dla nowego pliku podasz błędną nazwę, wydanie polecenia Ctrl+X Ctrl+V pozwoli na jej skorygowanie.

UZUPEŁNIANIE NAZWY ŚCIEŻKI Kiedy w minibuforze zostaniesz poproszony o podanie ścieżki dostępu do pliku, możesz ją podać w całości i nacisnąć klawisz Enter. Alternatywne rozwiązanie polega na wykorzystaniu możliwości oferowanych przez mechanizm uzupełniania ścieżki dostępu, który działa podobnie do uzupełniania nazwy pliku w powłoce bash (patrz rozdział 8.). Wspomniany mechanizm pomaga we wprowadzeniu ścieżki dostępu. Podczas wpisywania ścieżki dostępu w minibuforze naciśnięcie klawisza Tab powoduje, że edytor spróbuje uzupełnić maksymalną ilość znaków w ścieżce dostępu. Jeżeli uzupełniona ścieżka dostępu będzie prawidłowa, naciśnij Enter. W pewnych przypadkach edytor nie będzie mógł uzupełnić ścieżki dostępu. Na przykład wtedy, gdy podany katalog nie istnieje lub nie masz uprawnień do emacs

Zaawansowana edycja  263

jego odczytu. Jeżeli emacs nie będzie mógł uzupełnić ścieżki dostępu, w obszarze Echo Area wyświetli odpowiedni komunikat. Jeżeli w ścieżce dostępu znaki po ostatnim ukośniku / można dopasować do więcej niż tylko jednej nazwy, naciśnięcie klawisza Tab spowoduje wyświetlenie komunikatu [Complete, but not unique]. Powtórne naciśnięcie klawisza Tab powoduje wyświetlenie okna Pathname Completion List zawierającego listę dopasowanych elementów (patrz rysunek 7.9). Wspomniane okno możesz wyświetlić ręcznie podczas wpisywania ścieżki dostępu, w tym celu wystarczy wpisać znak zapytania (?).

Rysunek 7.9. Okno Pathname Completion List

Po wyświetleniu okna Pathname Completion List możesz wykonać jedno z poniższych działań.  Anulować wybór przez wydanie polecenia Ctrl+G lub Esc Esc Esc. Ekran powróci do stanu sprzed wyświetlenia okna Pathname Completion List.  Wpisać więcej znaków w minibuforze, aby umożliwić uzupełnienie ścieżki dostępu. Naciśnięcie

klawisza Enter powoduje wybór ścieżki dostępu, a emacs zamknie okno Pathname Completion List.  Wpisać kolejne znaki w minibuforze, aby umożliwić jednoznaczne dopasowanie elementu,

a następnie ponownie nacisnąć klawisz Tab.  Nacisnąć Meta+v lub Page Up w celu przeniesienia kursora do okna Pathname Completion List.

Za pomocą klawiszy kursora można poruszać się pomiędzy dostępnymi opcjami. Naciśnięcie klawisza Enter powoduje wybór elementu wskazywanego przez kursor. Z kolei naciśnięcie Ctrl+G lub Esc Esc Esc powoduje opuszczenie okna i powrót kursora do minibufora. Naciśnięcie klawisza Enter powoduje zamknięcie okna Pathname Completion List, dodanie wybranego elementu na końcu wpisywanej ścieżki dostępu i przeniesienie kursora na jej koniec w minibuforze. Teraz możesz kontynuować wpisywanie ścieżki i dokonywać kolejnych uzupełnień przed naciśnięciem klawisza Enter akceptującym pełną ścieżkę dostępu. Więcej informacji znajdziesz w dokumentacji emacs.

ZAPISYWANIE PLIKÓW Bufor zapisujesz przez umieszczenie jego zawartości z powrotem w pliku, z którego została pobrana. Polecenia pozwalające na zapis plików wymieniono w tabeli 7.11. OSTRZEŻENIE Możesz zakończyć pracę bez ostrzeżenia Usunięcie flagi modyfikacji (polecenie Meta+~) pozwala na zakończenie pracy edytora emacs bez zapisu zmodyfikowanego bufora. Użytkownikowi nie jest wyświetlane żadne ostrzeżenie. Jeżeli używasz polecenia Meta+~, to upewnij się, że wiesz, co robisz.

264  ROZDZIAŁ 7. EDYTOR EMACS OSTRZEŻENIE Czy zmodyfikowałeś bufor przez przypadek? Po wydaniu polecenia Ctrl+X s możesz odkryć pliki, których bufory zostały zmodyfikowane przez przypadek, ponieważ emacs próbuje zapisać nieprawidłowe zmiany w pliku. Kiedy emacs poprosi o potwierdzenie operacji zapisu, nie udzielaj odpowiedzi y, jeśli nie jesteś pewien. W pierwszej kolejność zakończ polecenie Ctrl+X s, udzielając odpowiedzi n, a następnie masz do wyboru kilka możliwości.  Podejrzany bufor zapisz w pliku tymczasowym, wydając polecenie Ctrl+X Ctrl+W, a później go przeanalizuj.  Cofnij zmiany, wydając polecenia Ctrl+_ aż do zniknięcia wskaźnika ** w wierszu trybu danego bufora.  Jeżeli jesteś pewien, że zmiany są nieprawidłowe, wydaj polecenie Meta+x revert-buffer — otrzymasz w ten sposób świeżą zawartość bufora pobraną z pliku.  Zamknij bufor. Ponieważ został zmodyfikowany, emacs poprosi o potwierdzenie wykonania tej operacji.  Wydaj polecenie Meta+~ (tylda) usuwające flagę modyfikacji i wskaźnik **. Kolejne polecenie Ctrl+X s „uzna”, że bufor nie wymaga zapisu w pliku. Tabela 7.11. Zapisywanie plików Polecenie

Opis

Ctrl+X Ctrl+S

To polecenie powoduje zapisanie bieżącego bufora do jego oryginalnego pliku. Jeżeli bieżący bufor nie został zmodyfikowany, emacs wyświetli odpowiedni komunikat.

Ctrl+X s

Dla każdego zmodyfikowanego bufora zostanie wyświetlone pytanie o jego zapis. Możesz udzielić odpowiedzi y lub n. To polecenie jest wykonywane automatycznie podczas kończenia pracy z edytorem emacs i pozwala na zapis wszystkich buforów, które zostały zmodyfikowane, ale jeszcze nie zapisane. Wydając to polecenie, zapisujesz w plikach dotychczasową zawartość poszczególnych buforów.

Meta+x set-visited-file-name

Polecenie prosi o podanie nazwy pliku, która następnie jest stosowana jako „oryginalna” nazwa dla bieżącego bufora.

Ctrl+X Ctrl+W

Polecenie prosi o podanie nazwy pliku, następnie jest ona stosowana jako „oryginalna” nazwa dla bieżącego bufora, który zostaje zapisany w podanym pliku. Jest to odpowiednik dwóch poleceń: Meta+x set-visited-file-name i Ctrl+X Ctrl+S.

Meta+~(tylda)

Usuwa flagę modyfikacji z bieżącego bufora. Jeżeli przypadkowo wykonasz to polecenie względem bufora, w którym chcesz zachować wprowadzone zmiany, musisz się upewnić o wprowadzeniu zmiany i włączeniu wskaźnika ** dla bufora przed zakończeniem pracy z edytorem emacs. W przeciwnym razie stracisz zmiany wprowadzone w danym buforze. Najłatwiejszym sposobem oznaczenia bufora jako zmodyfikowanego jest wstawienie spacji, a następnie jej usunięcie.

BUFORY Bufor edytora emacs to obiekt magazynu danych, który można edytować. Bardzo często przechowuje zawartość pliku, ale może także istnieć bez powiązanego z nim pliku. W danej chwili można wybrać tylko jeden bufor, który staje się w ten sposób buforem bieżącym. Większość poleceń działa jedynie w buforze bieżącym, nawet pomimo tego, że okno wyświetla wiele buforów na ekranie. Na ogół bufor jest własnym światem: posiada nazwę, tryby pracy, powiązany z nim plik, własny stan określający modyfikację zawartości i prawdopodobnie własne przypisania klawiszy. Poleceń wymienionych w tabeli 7.12 można używać do tworzenia, wybierania, wyświetlania i wykonywania operacji na buforach.

Zaawansowana edycja  265

Tabela 7.12. Praca z buforami Polecenie

Opis

Ctrl+X b

Polecenie prosi o podanie nazwy bufora i wybiera go. Jeżeli podany bufor nie istnieje, polecenie go utworzy.

Ctrl+X 4 b

Polecenie prosi o podanie nazwy bufora i wybiera go w innym oknie. Istniejące okno pozostanie nietknięte, choć nowe okno może je częściowo przykryć.

Ctrl+X Ctrl+B

Tworzy bufor o nazwie *Buffer List* i wyświetla go w innym oknie. Istniejące okno pozostanie nietknięte, choć nowe okno może je częściowo przykryć. Nowy bufor nie zostaje wybrany. W buforze *Buffer List* wszystkie dane buforów są wyświetlone wraz z nazwą bufora, trybem pracy i nazwą oryginalnego pliku. Znak % oznacza bufor tylko do odczytu, znak * oznacza bufor zmodyfikowany, natomiast . (kropka) wskazuje na bufor wybrany.

Meta+x rename-buffer

Polecenie prosi o podanie nowej nazwy dla bufora, a następnie tę nazwę przypisuje buforowi bieżącemu.

Ctrl+X Ctrl+Q

Włącza lub wyłącza bieżącemu buforowi flagę tylko do odczytu oraz powiązany z nią wskaźnik %% w wierszu trybu. To polecenie może uchronić przed przypadkową modyfikacją bufora lub pozwolić na modyfikację bufora po odczytaniu pliku tylko do odczytu.

Meta+x append-to-buffer

Polecenie prosi o podanie nazwy bufora, a następnie na jego końcu dołącza zawartość regionu.

Meta+x prepend-to-buffer

Polecenie prosi o podanie nazwy bufora, a następnie na jego początku umieszcza zawartość regionu.

Meta+x copy-to-buffer

Polecenie prosi o podanie nazwy bufora, a następnie usuwa jego zawartość i kopiuje do wyczyszczonego bufora zawartość regionu.

Meta+x insert-buffer

Polecenie prosi o podanie nazwy bufora, a następnie wstawia zawartość tego bufora w buforze bieżącym, w miejscu wskazywanym przez punkt.

Ctrl+X k

Polecenie prosi o podanie nazwy bufora, a następnie usuwa go. Jeżeli bufor został zmodyfikowany, ale nie zapisany, edytor emacs poprosi o potwierdzenie wykonania operacji.

Meta+x kill-some-buffers

Przechodzi przez listę buforów i oferuje możliwość ich usuwania. Podobnie jak w przypadku polecenia Ctrl+X k emacs prosi o potwierdzenie wykonania operacji, jeśli zmodyfikowany bufor nie został zapisany.

OKNA Okno edytora emacs wyświetla zawartość bufora. Po uruchomieniu ekran emacs zawiera tylko jedno okno, ale tę przestrzeń można później podzielić na dwa lub więcej okien. Na ekranie okno bieżące zawiera kursor oraz widok bufora bieżącego. Więcej informacji na temat przedstawionej terminologii znajdziesz we wskazówce „Ekran i okna emacs” na początku rozdziału. Jednorazowo okno wyświetla tylko jeden bufor. Polecenie Ctrl+X b nazwa-bufora powoduje przejście do bufora wyświetlanego przez bieżące okno. Wiele okien może wyświetlać ten sam bufor, a każde z nich może wyświetlać inną część bufora. Wszelkie zmiany wprowadzane w buforze będą odzwierciedlane we wszystkich wyświetlających go oknach. Ponadto bufor może istnieć bez wyświetlającego go okna.

Ctrl+X b nazwa-bufora

PODZIAŁ OKNA Jednym ze sposobów podziału ekranu jest podział początkowego okna na dwa lub więcej. Polecenie Ctrl+X 2 powoduje podział bieżącego okna na dwa, przy czym nowe okno pojawia się powyżej istniejącego. Opcjonalny argument liczbowy wskazuje liczbę wierszy w górnym oknie. Polecenie Ctrl+X 3

266  ROZDZIAŁ 7. EDYTOR EMACS powoduje podział bieżącego okna na dwa wyświetlane obok siebie (patrz rysunek 7.10). Opcjonalny argument liczbowy określa liczbę kolumn w lewym oknie. Na przykład polecenie Ctrl+U Ctrl+X 2 powoduje podział bieżącego okna na dwa; ponieważ standardową wartością Ctrl+U jest „razy 4”, to górne okno będzie wyświetlało cztery wiersze (absolutne minimum, by okno było użyteczne).

Rysunek 7.10. Poziomy podział okna

Wprawdzie wymienione polecenia powodują podział okna bieżącego, ale oba okna wyświetlają ten sam bufor. Inny bufor możesz wskazać w jednym lub obu oknach, ewentualnie przewinąć ich zawartość w taki sposób, aby każde wyświetlało inną część tego samego bufora.

OPERACJE NA OKNACH Polecenie Ctrl+X o (mała litera O) służy do wyboru innego okna. Jeżeli na ekranie są wyświetlane więcej niż dwa okna, sekwencja poleceń Ctrl+X o pozwala na poruszanie się pomiędzy nimi w kolejności od góry do dołu i od lewej do prawej strony. Polecenie Meta+Ctrl+V przewija zawartość drugiego okna. Jeżeli na ekranie są wyświetlane więcej niż dwa okna, polecenie będzie przewijało zawartość tego okna, które przez polecenie Ctrl+X o zostanie wybrane jako następne. Istnieje możliwość wyboru dodatniego lub ujemnego argumentu przewijania, podobnie jak w przypadku polecenia Ctrl+V przewijającego zawartość w oknie bieżącym.

Ctrl+X o oraz Meta+Ctrl+V

WYŚWIETLANIE INNYCH OKIEN W normalnym działaniu emacs wyraźny podział okna nie jest tak często spotykany jak podział za pomocą rodziny poleceń Ctrl+X 4. Polecenie Ctrl+X 4b prosi o podanie nazwy bufora, a następnie wybiera go w innym oknie. Jeżeli inne okno nie istnieje, wymienione polecenie dzieli bieżące okno na dwa ułożone jedno pod drugim. Z kolei polecenie Ctrl+X 4f prosi o podanie nazwy pliku, wyświetla zawartość w innym oknie, a następnie wybiera wspomniane okno. Jeżeli inne okno nie istnieje, wymienione polecenie dzieli bieżące okno na dwa ułożone jedno pod drugim.

Ctrl+X 4b oraz Ctrl+X 4f

DOSTOSOWYWANIE I USUWANIE OKIEN Gdy okno przeszkadza, to można je usunąć. Taka operacja nie powoduje utraty żadnych danych w buforze powiązanym z usuwanym oknem, a gdy tylko zachcesz, możesz utworzyć inne okno. Polecenie Ctrl+X 0 (zero) powoduje usunięcie bieżącego okna i przekazanie zajmowanego przez nie miejsca oknom sąsiednim. Z kolei polecenie Ctrl+X 1 usuwa wszystkie okna poza bieżącym.

Ctrl+X 0 oraz Ctrl+X 1

Zaawansowana edycja  267

Istnieje możliwość dopasowania wymiarów okna bieżącego kosztem okien sąsiednich. Aby skrócić okno, należy wydać polecenie Meta+x shrink-window. Wydanie polecenia Ctrl+X ^ powoduje wydłużenie okna, polecenie Ctrl+X } rozszerza okna, natomiast Ctrl+X { zwęża je. O ile nie zostanie poprzedzone argumentem liczbowym, każde z wymienionych poleceń dodaje jeden wiersz bądź kolumnę do okna lub je odejmuje.

Meta+x shrink-window oraz Ctrl+X ^ oraz Ctrl+X }oraz Ctrl+X {

Edytor emacs ma zdefiniowane pewne wytyczne dotyczące minimalnej użytecznej wielkości okna i może usunąć okno, zanim wymusisz zmniejszenie jednego z jego wymiarów do zera. Nawet jeśli okno zostanie usunięte z ekranu, bufor pozostanie nietknięty.

PIERWSZOPLANOWE POLECENIA POWŁOKI Edytor emacs może uruchomić podpowłokę (to znaczy proces potomny emacs — patrz punkt „Uruchamianie poleceń” w rozdziale 8.) w celu wykonania pojedynczego polecenia powłoki, opcjonalnie ze standardowymi danymi wejściowymi pochodzącymi z regionu bieżącego bufora i standardowymi danymi wyjściowymi zastępującymi region (patrz tabela 7.13). Ten proces jest analogiczny do wykonywania poleceń powłoki z poziomu edytora vim, gdzie dane wejściowe mogą pochodzić z edytowanego pliku, a wyjściowe zostać umieszczone w tym samym pliku (patrz rozdział 6.). Podobnie jak w przypadku edytora vim skuteczność rozwiązania zależy po części od możliwości oferowanych przez powłokę. Tabela 7.13. Pierwszoplanowe polecenia powłoki Polecenie

Opis

Meta+! (wykrzyknik)

Polecenie prosi o podanie nazwy polecenia powłoki, wykonuje je i wyświetla dane wyjściowe wygenerowane przez to polecenie.

Ctrl+U Meta+! (wykrzyknik)

Polecenie prosi o podanie nazwy polecenia powłoki, wykonuje je, a dane wyjściowe wygenerowane przez to polecenie wstawia w miejscu wskazanym przez punkt.

Meta+| (pionowa kreska)

Polecenie prosi o podanie nazwy polecenia powłoki, przekazuje region jako dane wejściowe polecenia, filtruje region w poleceniu i wyświetla wygenerowane dane wyjściowe.

Ctrl+U Meta+| (pionowa kreska)

Polecenie prosi o podanie nazwy polecenia powłoki, przekazuje region jako dane wejściowe polecenia, filtruje region w poleceniu, usuwa stary region i wstawia w jego miejsce wygenerowane dane wyjściowe.

Edytor emacs pozwala również na uruchomienie interaktywnej podpowłoki, która będzie nieustannie działała we własnym buforze. Więcej informacji na ten temat znajdziesz w podrozdziale „Tryb powłoki” w dalszej części rozdziału.

POLECENIA POWŁOKI DZIAŁAJĄCE W TLE Edytor emacs może uruchomić proces działający w tle, jego dane wyjściowe mogą być umieszczane w rozrastającym się buforze emacs, który wcale nie musi pozostawać w widoku. Kiedy proces działa w tle, nadal możesz zajmować się edycją innego bufora, a dane wyjściowe polecenia przejrzeć później. W ten sposób można uruchomić dowolne polecenie powłoki. Rozrastający się bufor danych wyjściowych zawsze nosi nazwę *compilation*. Masz możliwość odczytu jego zawartości, kopiowania i edytowania w dowolny sposób bez konieczności oczekiwania na zakończenie procesu działającego w tle. Wymieniony bufor najczęściej jest używany do otrzymywania danych wyjściowych kompilowanego programu oraz do poprawiania wszelkich błędów składni wykrytych przez kompilator.

268  ROZDZIAŁ 7. EDYTOR EMACS Aby uruchomić proces w tle, konieczne jest wydanie polecenia Meta+x compile, co pozwoli na podanie nazwy polecenia powłoki i rozpocznie jego wykonywanie jako procesu działającego w tle. Ekran zostanie podzielony na pół i będzie pokazywał bufor *compilation*.

Meta+x compile

Jeżeli chcesz, możesz przejść do bufora *compilation* i obserwować wykonywanie polecenia. Aby ekran był przewijany wraz z kolejnymi napływającymi danymi wyjściowymi polecenia, umieść kursor na końcu tekstu, wydając polecenie Meta+>. Jeżeli nie jesteś zainteresowany śledzeniem danych wyjściowych polecenia, po prostu zamknij okno za pomocą Ctrl+x 0 (zero), gdy znajdujesz się w tym oknie, lub za pomocą Ctrl+X 1, gdy pracujesz w innym. Do bufora *compilation* możesz przejść później, wydając polecenie Ctrl+X b. Aby zakończyć proces działający w tle, wydaj polecenie Meta+x kill-compilation. Edytor poprosi o potwierdzenie operacji, a następnie zakończy proces działający w tle.

emacs

Jeżeli w buforze *compilation* pojawią się komunikaty standardowego strumienia błędów, to możesz automatycznie przejść do wiersza, w którym wystąpił dany błąd. Wydaj polecenie Ctrl+X ` (odwrotny apostrof), które spowoduje podział ekranu na dwa okna oraz wyświetlenie pliku i wiersza kolejnego komunikatu błędu. Przewijaj bufor *compilation* tak długo, dopóki wspomniany komunikat błędu nie znajdzie się na górze okna. Wydanie polecenia Ctrl+U Ctrl+` pozwala na rozpoczęcie od pierwszego komunikatu błędu i wyświetlenie odpowiedniego pliku oraz wiersza.

TRYBY PODSTAWOWE — EDYCJA W ZALEŻNOŚCI OD JĘZYKA Edytor emacs posiada ogromny zbiór zestawów funkcji, każdy przeznaczony dla określonego rodzaju tekstu. Wspomniane zestawy są nazywane trybami podstawowymi. Bufor może mieć ustawiony tylko jeden tryb podstawowy w danej chwili. Tryb podstawowy bufora nie ma żadnego wpływu na edycję w innych buforach. Jeżeli przejdziesz do kolejnego bufora działającego w innym trybie podstawowym, reguły dotyczące tego nowego trybu zostaną natychmiast wprowadzone. Aby można było uniknąć zamieszania, nazwa trybu podstawowego bufora pojawia się w wierszu trybu każdego okna wyświetlającego ten bufor (patrz rysunek 7.1 na początku rozdziału). Trzy klasy trybów podstawowych są używane do wykonywania wymienionych poniżej zadań.  Edycja tekstu w językach czytelnych dla człowieka (na przykład tekst, plik w formacie nroff, TeX).

 Edycja kodu źródłowego w językach programowania (na przykład C, Fortran, Lisp).  Cele specjalne (na przykład powłoka, poczta, ftp itd.).

Oprócz tego jeden tryb podstawowy o nazwie Fundamental nie ma specjalnego znaczenia. Tryb podstawowy najczęściej służy do przeprowadzenia następującej konfiguracji.  Polecenia specjalne unikatowe dla danego trybu, najczęściej własne przypisania klawiszy.

Podczas gdy języki mają kilka poleceń specjalnych, tryby specjalnego przeznaczenia mogą ich mieć dziesiątki.  Charakterystyczna dla danego trybu składnia znaków i wyrażenia regularne definiujące słowa,

ograniczniki, komentarze, znaki odstępu itd. To powoduje konfigurację warunków zachowania poleceń zorientowanych pod kątem jednostek składni, na przykład słów, zdań, komentarzy lub wyrażeń ujętych w nawiasy.

Tryby podstawowe — edycja w zależności od języka  269

WYBÓR TRYBU PODSTAWOWEGO Edytor emacs wybiera i aktywuje tryb, gdy otworzony plik zostanie dopasowany względem zestawu wzorców wyrażenia regularnego opisującego nazwę pliku i jego rozszerzenie. Poleceniem, które pozwala na ręczne włączenie trybu podstawowego, jest Meta+x nazwa-trybu. Wymienione polecenie jest najczęściej używane do wybrania odpowiedniego trybu podstawowego, gdy emacs dokona nieprawidłowego wyboru.

Meta+x nazwa-trybu

Aby przygotować plik definiujący własny tryb, w pierwszym niepustym wierszu pliku należy umieścić tekst -*- nazwatrybu -*-. Wymieniony tekst najczęściej umieszcza się wewnątrz komentarza właściwego dla języka programowania, którego kod źródłowy znajduje się w danym pliku.

TRYBY JĘZYKÓW CZYTELNYCH DLA CZŁOWIEKA Jak sama nazwa wskazuje, język czytelny dla człowieka oznacza język, który może być czytelny dla człowieka, często po sformatowaniu przez odpowiedni program. Języki czytelne dla człowieka stosują wiele tych samych konwencji dotyczących struktury słów, zdań i akapitów. Pod względem jednostek tekstowych większość trybów języków czytelnych dla człowieka zachowuje się w ten sam sposób. Poza wspomnianymi cechami wspólnymi poszczególne tryby oferują funkcje dodatkowe przeznaczone do formatowania konkretnego tekstu, na przykład w formacie TeX, LaTeX, nroff/troff. Rozszerzenia przeznaczone do formatowania teksu wykraczają poza temat niniejszego rozdziału i dlatego skoncentrujemy się na poleceniach związanych z formatowaniem jednostek tekstu.

SŁOWA Przypisania dla słów są definiowane równolegle z przypisaniami znaków Ctrl+F, Ctrl+B, Ctrl+D, Delete i Ctrl+T. Podobnie jak polecenia Ctrl+F i Ctrl+B powodują przesunięcie kursora o jeden znak do przodu i do tyłu, tak polecenia Meta+f i Meta+b pozwalają na poruszanie się o jedno słowo do przodu i do tyłu. Początek może znajdować się wewnątrz lub na zewnątrz słowa, ale we wszystkich przypadkach punkt ostatecznie zostaje umieszczony poza słowem i przylega do ostatniego „przeskoczonego” znaku. Oba wymienione polecenia akceptują argumenty wskazujące liczbę słów, o które ma nastąpić przeskok.

Meta+f oraz Meta+b

Podobnie jak polecenia Ctrl+D i Delete usuwają znaki do przodu i do tyłu, polecenia Meta+D i Meta+Delete usuwają słowa do przodu i do tyłu. Punkt pozostaje dokładnie w takim samym położeniu jak w przypadku poleceń Meta+f i Meta+b, ale przeskakiwane słowa są usuwane. Wymienione polecenia również akceptują argumenty liczbowe wskazujące ilość powtórzeń.

Meta+d oraz Meta+Delete

Meta+t

Polecenie przenosi przed punkt słowo znajdujące się za nim.

ZDANIA Trzy z wymienionych sekwencji są definiowane równolegle z przypisaniami poleceń działających na wierszach: Ctrl+A, Ctrl+E i Ctrl+K. Polecenie Meta+a przechodzi do tyłu na początek zdania, Meta+e do przodu na koniec zdania. Natomiast polecenie Ctrl+X Delete powoduje usunięcie tekstu do tyłu, do początku zdania, a polecenie Meta+k usuwa tekst do przodu, do końca zdania.

Meta+a oraz Meta+e oraz Ctrl+X Delete oraz Meta+k

Edytor emacs rozpoznaje końce zdania przez odwołanie się do wyrażenia regularnego przechowywanego w zmiennej o nazwie sentence-end. W skrócie: emacs szuka znaków ., ? lub !, po których znajdują się dwie spacje lub znak końca wiersza, prawdopodobnie z zamykającym cudzysłowem lub nawiasem. Wydanie polecenia Ctrl+H sentence-end Enter powoduje wyświetlenie wartości wymienionej zmiennej.

270  ROZDZIAŁ 7. EDYTOR EMACS Polecenia Meta+a i Meta+e pozostawiają punkt przylegający do pierwszego lub ostatniego niebiałego znaku zdania. Akceptują argument liczbowy oznaczający ilość zdań do przeskoczenia. Wartość ujemna wspomnianego argumentu powoduje poruszanie się w przeciwnym kierunku. Polecenia Meta+k i Ctrl+X Delete usuwają zdania do przodu i do tyłu w analogiczny sposób jak w przypadku usuwania wierszy przez polecenie Ctrl+K. Punkt pozostaje w dokładnie takim samym położeniu jak po wykonaniu polecenia Meta+a lub Meta+e, ale przeskakiwane zdania są usuwane. Polecenia akceptują argument liczbowy. Użycie polecenia Ctrl+X Delete jest użyteczne w celu usunięcia w połowie ukończonego zdania.

AKAPITY Polecenie Meta+{ powoduje przejście do tyłu — na początek akapitu, natomiast Meta+} przejście do przodu na koniec akapitu. Z kolei polecenie Meta+h oznacza jako region akapit, w którym znajduje się kursor (to znaczy umieszcza punkt na początku i znacznik na końcu akapitu) lub zaznacza kolejny akapit, jeśli kursor znajduje się pomiędzy dwoma akapitami.

Meta+{ oraz Meta+} oraz Meta+h

Polecenia Meta+} i Meta+{ pozostawiają punkt na początku wiersza, przylegający do odpowiednio pierwszego lub ostatniego znaku akapitu. Akceptują argument liczbowy wskazujący ilość akapitów, o które ma nastąpić przeskok. Podanie wartości ujemnej powoduje przejście w przeciwnym kierunku. W trybach języków czytelnych dla człowieka akapity są podzielone pustymi wierszami i poleceniami formatowania tekstu, a wiersz rozpoczynający akapit jest wcięty. Rozpoznawanie akapitu odbywa się na podstawie wyrażenia regularnego przechowywanego w zmiennych paragraph-separate i paragraph-start. Akapit składa się z pełnych wierszy oraz znaku ograniczającego ostatni wiersz. Jeżeli akapit rozpoczyna się od jednego lub większej liczby pustych wierszy, ostatni pusty wiersz przed akapitem również się do niego zalicza.

WYPEŁNIANIE Edytor emacs potrafi wypełnić akapit w taki sposób, aby miał określoną długość. W tym celu odpowiednio łamie wiersze i układa je. Znaki nowego wiersza są umieszczane pomiędzy słowami. Uzupełnianie może być przeprowadzane automatycznie, gdy wpisujesz tekst, lub wykonane po wywołaniu polecenia. Polecenie Meta+x auto-fill-mode włącza i wyłącza funkcję automatycznego wypełniania. Po włączeniu wymienionej funkcji emacs automatycznie łamie wiersz po naciśnięciu klawisza spacji lub Enter, o ile kursor znajduje się poza wskazaną długością wiersza. Ta funkcja jest użyteczna podczas wprowadzania nowego tekstu.

Meta+x auto-fill-mode

Funkcja automatycznego wypełniania nie powoduje ponownego automatycznego wypełnienia bieżącego akapitu. Jeżeli w środku akapitu dodasz nowy tekst, funkcja automatycznie złamie nowo dodane wiersze, ale nie przeprowadzi korekty złamań wierszy w pozostałej części akapitu. Aby móc ponownie przeprowadzić wypełnienie akapitu lub regionu akapitów, konieczne jest wydanie polecenia Meta+q w celu wypełnienia akapitu lub Meta+x fill-region w celu wypełnienie danego akapitu regionu (pomiędzy punktem i znacznikiem).

Meta+q oraz Meta+x fill-region

Domyślna szerokość wypełniania wynosi 70, ale tę wartość możesz zmienić przez ustawienie zmiennej Wydanie polecenia Ctrl+X f powoduje przypisanie zmiennej fill-column bieżącego położenia kursora, natomiast polecenie Ctrl+U nnn Ctrl+X f powoduje ustawienie zmiennej fill-column wartości nnn, gdzie 0 oznacza lewy margines. fill-column.

KONWERSJA WIELKOŚCI LITER Edytor emacs pozwala na wymuszenie zmiany wielkości liter w słowach lub regionach na wielkie, małe lub na postać, w której pierwsza litera słowa jest wielka, pozostałe są małe. Służące do tego celu polecenia zostały wymienione w tabeli 7.14.

Tryby podstawowe — edycja w zależności od języka  271

Tabela 7.14. Konwersja wielkości liter Polecenie

Opis

Meta+l (mała litera L)

Konwertuje słowo znajdujące się po prawej stronie punktu na zapisane małymi literami.

Meta+u

Konwertuje słowo znajdujące się po prawej stronie punktu na zapisane wielkimi literami.

Meta+c

Konwertuje słowo znajdujące się po prawej stronie punktu na postać, w której tylko pierwsza litera jest wielka.

Ctrl+X Ctrl+L

Konwertuje region na zapisany małymi literami.

Ctrl+X Ctrl+U

Konwertuje region na zapisany wielkimi literami.

Polecenia działające na słowach powodują przeniesienie punktu tuż za skonwertowane słowo (podobnie jak w przypadku polecenia Meta+f), co pozwala użytkownikowi na przejście przez tekst i konwersję każdego słowa za pomocą poleceń Meta+l, Meta+u lub Meta+c bądź pozostawienie aktualnej postaci słowa przy użyciu polecenia Meta+f. Dodatni argument liczbowy powoduje konwersję wskazanej liczby słów po prawej stronie punktu i jednoczesne jego przesunięcie. Z kolei ujemna wartość punktu konwertuje wskazaną liczbę słów po lewej stronie punktu, który jednak pozostaje w swoim położeniu. Taka funkcja jest użyteczna i pozwala na szybką zmianę wielkości dopiero wpisanych słów. Kilka przykładów konwersji przedstawiono w tabeli 7.15. Tabela 7.15. Przykłady konwersji wielkości liter Znaki i polecenia

Wynik działania

HELLOMeta—Meta+l (mała litera L)

hello

helloMeta—Meta+u

HELLO

helloMeta—Meta+c

Hello

Kiedy kursor (punkt) znajduje się w środku słowa, polecenia konwersji wielkości znaków przeprowadzają konwersję znaków po lewej stronie kursora.

TRYB TEKSTOWY Z kilkoma wyjątkami polecenia dla jednostek tekstowych języków czytelnych dla człowieka zawsze są włączone i dostępne, nawet po aktywacji trybu przeznaczonego do pracy z językiem programowania. Tryb tekstowy niewiele dodaje do poleceń podstawowych, ale warto go włączyć w celu aktywacji funkcji klawisza tabulatora (patrz poniżej). Aktywacja trybu tekstowego następuje po wydaniu polecenia Meta+x text-mode.

Meta+x text-mode

W trybie tekstowym naciśnięcie klawisza tabulacji powoduje uruchomienie funkcji tab-to-tab-stop. Domyślna wielkość tabulatora wynosi osiem znaków. Tę wartość można zmienić za pomocą polecenia Meta+X edit-tab-stops, które powoduje przejście do specjalnego bufora *Tab Stops*. Bieżące położenia tabulatora w wymienionym buforze mają zastosowanie podczas edycji w innych. Nowe położenia będą aktywowane po wydaniu polecenia Ctrl+C Ctrl+C. Oczywiście możesz zamknąć bufor *Tab Stops* (Ctrl+X k) lub przejść do innego (Ctrl+X b) bez zmiany położenia tabulatorów.

Meta+x edit-tab-stops

Położenia tabulatora zdefiniowane za pomocą polecenia Meta+x edit-tab-stops mają zastosowanie jedynie w przypadków znaków tabulatora pochodzących z klawiatury. Edytor emacs automatycznie wstawia odpowiednią liczbę spacji, aby przejść do położenia tabulatora. Polecenie nie ma wpływu na interpretację znaków tabulatora znajdujących się już w buforze oraz powiązanym z nim pliku. Jeżeli przeprowadzisz edycję położenia tabulatorów i będziesz stosował zdefiniowane położenia, po wydruku dokumentu otrzymasz go w postaci wyświetlanej na ekranie.

272  ROZDZIAŁ 7. EDYTOR EMACS

TRYB C Języki programowania są czytelne dla człowieka, ale interpretowane przez komputery. Poza obsługą niektórych jednostek tekstu znanych z języków czytelnych dla człowieka (na przykład słów i zdań) tryby podstawowe dla języków programowania rozwiązują jeszcze kilka problemów.  Zajmują się obsługą zrównoważonych wyrażeń ujętych w nawiasy jako jednostek tekstu.  Obsługują komentarze jako jednostki tekstu.  Zajmują się obsługą wcięć.

Edytor emacs zawiera tryby podstawowe przeznaczone do obsługi języków C, Fortran oraz kilku odmian Lisp. Oprócz tego wielu użytkowników opracowało tryby przeznaczone do obsługi używanych przez nich języków. We wspomnianych trybach polecenia dla jednostek tekstowych czytelnych dla człowieka nadal istnieją, choć czasami są nieco przedefiniowane. Na przykład akapit jest ograniczony jedynie pustymi wierszami, a wcięcie wiersza nie oznacza początku akapitu. Ponadto każdy tryb posiada własny kod przeznaczony do obsługi konwencji charakterystycznych dla danego języka w zakresie obsługi zrównoważonych wyrażeń, komentarzy i wcięć. W tym rozdziale omówiony zostanie jedynie tryb dla języka C.

WYRAŻENIA Tryby podstawowe w edytorze emacs są ograniczone do analizy leksykalnej. Potrafią rozpoznać większość tokenów (na przykład symbole, ciągi tekstowe i liczby) oraz dopasowane zestawy różnych nawiasów. To będzie zupełnie wystarczające w przypadku języka Lisp, ale niewystarczające dla języka C. Tryb języka C nie zapewnia obsługi analizatora pełnej składni funkcji i nie jest przygotowany do rozpoznawania wszystkich dostępnych wyrażeń C2. W tabeli 7.16 wymieniono listę poleceń edytora emacs przeznaczonych do obsługi wyrażeń ujętych w nawiasy oraz pewnych tokenów. Zgodnie z konwencją przypisania działają równolegle; polecenia z użyciem klawisza Ctrl dotyczą znaków, natomiast z użyciem klawisza Meta dotyczą słów. Wszystkie wymienione polecenia akceptują argument liczbowy; jeśli jego wartość będzie ujemna, wówczas działają w przeciwnym kierunku. Tabela 7.16. Polecenia dla wyrażeń i tokenów

2

Polecenie

Opis

Ctrl+Meta+f

Przejście do przodu przez wyrażenie. Dokładne zachowanie zależy od znaku znajdującego się po prawej stronie punktu (lub lewej w zależności od kierunku poruszania się punktu).  Jeżeli pierwszym znakiem innym niż znak odstępu jest otwierający ogranicznik (nawias okrągły, kwadratowy lub ostry), punkt zostanie przeniesiony tuż za zamykający ogranicznik.  Jeżeli pierwszym znakiem innym niż znak odstępu jest token, punkt zostanie przeniesiony tuż za token.

Ctrl+Meta+b

Przejście do tyłu przez wyrażenie.

Ctrl+Meta+k

Usunięcie wyrażenia znajdującego się z przodu. To polecenie pozostawia punkt w tym samym położeniu jak w przypadku polecenia Ctrl+Meta+f, ale usuwa wyrażenie.

Ctrl+Meta+@

Ustawienie znacznika w położeniu, do którego przejście spowoduje wydanie polecenia Ctrl+Meta+f, ale punkt nie zostaje zmieniony. Aby wyraźnie zobaczyć oznaczony region, należy wydać parę poleceń Ctrl+X Ctrl+X w celu wymiany punktu i znacznika.

W dokumentacji edytora emacs często stosowane pojęcie sexp odwołuje się do wyrażenia S-expression języka Lisp. Niestety często jest stosowane wymiennie z wyrażeniem expression, nawet jeśli aktualnie omawianym językiem nie jest Lisp.

Tryby podstawowe — edycja w zależności od języka  273

DEFINICJE FUNKCJI W edytorze emacs zrównoważone wyrażenie na najbardziej zewnętrznym poziomie jest uznawane za definicję funkcji i często nazywane defun, nawet pomimo tego, że wymienione pojęcie jest wyrażeniem charakterystycznym dla języka Lisp. Ogólnie oznacza definicję funkcji w danym języku. W trybie języka C definicja funkcji zawiera zwracany typ danych, nazwę funkcji oraz deklarację argumentów przed znakiem {. W tabeli 7.17 wymieniono polecenia przeznaczone do działania z definicjami funkcji. Tabela 7.17. Polecenia definicji funkcji Polecenie

Opis

Ctrl+Meta+a

Powoduje przejście na początek ostatnio dodanej definicji funkcji. Tego polecenia możesz używać do przeglądania bufora wstecz, po jednej funkcji za każdym razem.

Ctrl+Meta+e

Powoduje przejście na koniec kolejnej definicji funkcji. Tego polecenia możesz używać do przeglądania bufora do przodu, po jednej funkcji za każdym razem.

Ctrl+Meta+h

Oznacza jako region bieżącą definicję funkcji (lub kolejną, jeśli kursor znajduje się pomiędzy dwoma funkcjami). To polecenie konfiguruje całą definicję funkcji dla operacji działającej na regionie, na przykład usuwania.

OSTRZEŻENIE Styl wcięcia funkcji W edytorze emacs przyjęto założenie, że nawias otwierający przy lewym marginesie jest częścią definicji funkcji. Takie założenie przyśpiesza odwrotne skanowanie w poszukiwaniu definicji. Jeżeli w kodzie jest stosowany styl wcięć, w którym nawias otwierający znajduje się w innym miejscu, wtedy można otrzymać nieoczekiwane wyniki.

WCIĘCIA Tryb języka C w edytorze emacs oferuje rozbudowaną logikę przeznaczoną do kontrolowania wcięć w programach utworzonych w języku C. Wspomnianą logikę możesz dostosować do wiele różnych stylów wcięć stosowanych w kodzie źródłowym C (patrz tabela 7.18). Tabela 7.18. Polecenia wcięć Polecenie

Opis

Tabulator

Dostosowuje wcięcie bieżącego wiersza. Tabulator powoduje wstawienie lub usunięcie znaków odstępu na początku wiersza; operacja jest powtarzana, dopóki wcięcie jest zgodne z bieżącym kontekstem i regułami. Punkt nie jest przenoszony, chyba że znajduje się w obszarze znaków odstępu — w takim przypadku będzie przeniesiony na koniec tego obszaru. Tabulator powoduje wstawienie spacji, możesz nacisnąć tabulator w dowolnym miejscu wiersza. Jeżeli chcesz wstawić tabulator w tekście, musisz użyć polecenia Meta+i lub Ctrl+Q Tab.

Wysuw wiersza

Skrót dla naciśnięcia klawiszy Enter i Tab. Wysuw wiersza jest wygodny podczas wprowadzania nowego kodu i powoduje automatyczne wcięcia na początku każdego wiersza.

Kolejne dwa polecenia pozwalają na wcięcie wielu wierszy za pomocą pojedynczego polecenia. Ctrl+Meta+q

Powoduje ponowne zastosowanie wcięć we wszystkich wierszach znajdujących się w kolejnej parze dopasowanych nawiasów. Przyjmuje się założenie, że lewy nawias jest prawidłowo wcięty i na jego podstawie są generowane pozostałe wcięcia. Jeżeli musisz dostosować lewy nawias, naciśnij Tab przed wydaniem omawianego polecenia. Wszystkie wiersze aż do dopasowanego nawiasu zostaną wcięte dokładnie tak, jakbyś w każdym w nich nacisnął klawisz Tab.

Ctrl+Meta+\

Powoduje ponowne zastosowanie wcięć we wszystkich wierszach regionu. Umieść punkt przed lub w miejscu lewego nawiasu, a następnie wydaj omawiane polecenie. Wszystkie wiersze aż do dopasowanego nawiasu zostaną wcięte dokładnie tak, jakbyś w każdym w nich nacisnął klawisz Tab.

274  ROZDZIAŁ 7. EDYTOR EMACS

DOSTOSOWANIE WCIĘĆ DO WŁASNYCH POTRZEB Opracowano wiele stylów programowania w języku C, a edytor emacs stara się jak najlepiej zapewnić automatyczną obsługę wcięć w każdym z nich. Mechanizm wcięć kodu został całkowicie utworzony od nowa w wersji 19 emacs, zapewnia teraz obsługę języków C, C++, Objective-C i Javy. Nowy analizator składni jest znacznie dokładniejszy i potrafi przypisać każdy element wiersza programu do pojedynczej kategorii składni (dostępnych jest ich około 50), takiej jak polecenie, ciąg tekstowy lub klauzula else. Na podstawie przeprowadzonej analizy emacs odwołuje się do tabeli o nazwie c-offsers-alist w celu sprawdzenia poziomu wcięcia danego wiersza względem poprzedniego. Aby dostosować wcięcia do własnych potrzeb, należy zmienić wartości wymienionej tabeli. Wprawdzie istnieje możliwość zdefiniowania zupełnie nowej tabeli dla własnego stylu wcięć, ale najczęściej znacznie wygodniejsze jest dostarczenie krótkiej listy opisującej wyjątki od standardowo zdefiniowanych reguł. Każdy z głównych stosowanych stylów (GNU, K&R [Kernighan i Ritchie], BSD itd.) ma tego rodzaju listę wyjątków; wszystkie zostały zebrane w c-style-alist. Poniżej przedstawiono pojedynczy wpis z wymienionej listy: ("gnu" (c-basic-offset . 2) (c-comment-only-line-offset . (0 . 0)) (c-offsets-alist . ((statement-block-intro . +) (knr-argdecl-intro . 5) (substatement-open . +) (label . 0) (statement-case-open . +) (statement-cont . +) (arglist-intro . c-lineup-arglist-intro-after-paren) (arglist-close . c-lineup-arglist) )) )

Utworzenie własnego stylu to temat wykraczający poza zakres niniejszej książki. Jeżeli jesteś ciekawy, jak to zrobić, w dokumentacji edytora emacs zapoznaj się z punktem „Customizing C Indentation”. Przykładowy plik .emacs przedstawiony w dalszej części rozdziału pokazuje dodanie bardzo prostego stylu, który będzie używany podczas edycji wszystkich plików .c.

KOMENTARZE Każdy bufor posiada własną zmienną comment-column, którą można wyświetlić po wydaniu polecenia Ctrl+H v comment-column Enter. W tabeli 7.19 wymieniono polecenia przeznaczone do pracy z komentarzami.

TRYBY SPECJALNEGO PRZEZNACZENIA Edytor emacs zawiera jeszcze trzecią rodzinę trybów podstawowych, które nie są zorientowane pod kątem określonego języka lub sposobu edycji. Zamiast tego wspomniane tryby pełnią pewne funkcje specjalne. Wymienione poniżej tryby mogą definiować własne przypisania klawiszy oraz polecenia w celu wykonania funkcji.  Rmail — odczyt, archiwizacja i tworzenie wiadomości e-mail.  Dired — poruszanie się po plikach i operacje na nich.  VIP — symulacja kompletnego środowiska edytora vi.  VC — pozwala na stosowanie systemu kontroli wersji (między innymi RCS, CVS i Subversion)

z poziomu edytora emacs.  GUD (ang. Grand Unified Debugger) — pozwala na uruchamianie i debugowanie programów

w języku C (i innych) z poziomu edytora emacs.

Tryby podstawowe — edycja w zależności od języka  275

Tabela 7.19. Polecenia komentarzy Polecenie

Opis

Meta+;

Wstawia komentarz w bieżącym wierszu lub wyrównuje istniejący komentarz. Zachowanie polecenia zależy od sytuacji.  Jeżeli wiersz nie zawiera komentarza, polecenie spowoduje utworzenie pustego komentarza w położeniu comment-column. Jeżeli wiersz zawiera tekst zachodzący na położenie wskazywane przez comment-column, polecenie spowoduje utworzenie pustego komentarza w odległości jednej spacji od końca wspomnianego tekstu.  Jeżeli wiersz zawiera już komentarz, ale nie w położeniu wskazywanym przez comment-column, polecenie spowoduje wyrównanie komentarza do podanej kolumny. Jeśli wspomniana kolumna zawiera inny tekst, komentarz będzie umieszczony w odległości jednej spacji od końca wspomnianego tekstu. Po wyrównaniu (prawdopodobnie pustego) komentarza istniejącego w wierszu punkt zostanie przeniesiony na początek tekstu komentarza. 

Ctrl+X ; Ctrl+U — Ctrl+X ;

Ustawienie wartości comment-column jako kolumny znajdującej się za punktem. Lewy margines jest kolumną 0. Usunięcie komentarza w bieżącym wierszu. To polecenie powoduje ustawienie comment-column na podstawie pierwszego komentarza znalezionego powyżej

bieżącego wiersza, a następnie wykonuje polecenie Meta+; w celu wstawienia lub wyrównania komentarza do wspomnianego położenia. Ctrl+U Ctrl+X ;

To polecenie powoduje ustawienie comment-column na podstawie pierwszego komentarza znalezionego powyżej bieżącego wiersza, a następnie wykonuje polecenie Meta+; w celu wstawienia lub wyrównania komentarza do wspomnianego położenia.

 Tramp — pozwala na edycję plików w zdalnym systemie, do którego dostęp można uzyskać

za pomocą ftp lub scp.  Powłoki — uruchamia interaktywną podpowłokę z poziomu bufora emacs.

W tej książce zostanie omówiony jedynie tryb powłoki.

TRYB POWŁOKI Jednorazowo wykonywane polecenia powłoki i filtrowanie regionu omówiono we wcześniejszej części rozdziału („Pierwszoplanowe polecenia powłoki”). Każdy bufor edytora emacs w trybie powłoki ma powiązaną z nim interaktywną powłokę. Wspomniana powłoka pobiera dane wejściowe z ostatniego wiersza bufora, a wygenerowane dane wyjściowe przekazuje do bufora i umieszcza w miejscu, gdzie znajduje się punkt. Jeżeli nie przeprowadzisz edycji bufora, będzie on zawierał zapis pełnej sesji powłoki. Powłoka działa asynchronicznie, niezależnie od tego, czy powiązany z nią bufor znajduje się aktualnie w widoku. Edytor emacs używa okresu bezczynności do odczytania danych wyjściowych powłoki i dodania ich do bufora. Polecenie Meta+x shell powoduje utworzenie bufora o nazwie *shell* i uruchomienie podpowłoki. Jeżeli bufor o podanej nazwie już istnieje, emacs przełączy się do niego. Powłoka uruchomiona w buforze *shell* jest wybierana na podstawie jednego z wymienionych poniżej źródeł:

Meta+x shell

 zmienna Lisp o nazwie explicit-shell-file-name;  zmienna środowiskowa ESHELL;  zmienna środowiskowa SHELL.

276  ROZDZIAŁ 7. EDYTOR EMACS Aby uruchomić drugą powłokę, w pierwszej kolejności wydaj polecenie Meta+x rename-buffer i zmień nazwę istniejącego bufora powłoki, a następnie wydaj polecenie Meta+x shell, uruchamiając tym samym kolejną powłokę. Masz możliwość uruchomienia dowolnej liczby powłok, wszystkie będą działały jednocześnie. W trybie powłoki dostępny jest specjalny zestaw poleceń (patrz tabela 7.20). Wymienione polecenia są najczęściej dwuklawiszowymi sekwencjami rozpoczynającymi się od Ctrl+C. Każda sekwencja jest podobna do zwykłych znaków kontrolnych w systemie Linux, ale używa poprzedzającej sekwencji Ctrl+C. Tabela 7.20. Polecenia trybu powłoki Polecenie

Opis

Enter

Jeżeli punkt znajduje się na końcu bufora, edytor emacs spowoduje wstawienie znaku Enter i wysłanie tego (ostatniego) wiersza do powłoki. Jeżeli punkt znajduje się w innym położeniu, kopiuje bieżący wiersz do końca bufora, usuwając znak zachęty powłoki (patrz wyrażenie regularne shell-prompt-pattern), jeśli istnieje. Następnie ten skopiowany wiersz — teraz ostatni w buforze — zostanie przekazany powłoce.

Ctrl+C Ctrl+D

Wysyła znak Ctrl+D powłoce lub jej podpowłoce.

Ctrl+C Ctrl+C

Wysyła znak Ctrl+C powłoce lub jej podpowłoce.

Ctrl+C Ctrl+\

Wysyła sygnał wyjścia powłoce lub jej podpowłoce.

Ctrl+C Ctrl+U

Wycina tekst w bieżącym wierszu, jeszcze nieukończony.

Ctrl+C Ctrl+R

Przechodzi na początek ostatnich danych wyjściowych powłoki i umieszcza pierwszy wiersz wspomnianych danych wyjściowych na początku okna.

Ctrl+C Ctrl+O

Usuwa ostatni fragment danych wyjściowych powłoki.

INFORMACJE DODATKOWE DOSTOSOWANIE EDYTORA EMACS DO WŁASNYCH POTRZEB Sercem edytora emacs jest interpreter Lisp utworzony w języku C. Ta wersja Lisp jest znacznie bardziej rozbudowana i zawiera wiele specjalnych poleceń edycyjnych. Podstawowym zadaniem interpretera jest wykonywanie kodu Lisp, w którym zaimplementowano wygląd i działanie edytora emacs. Po zredukowaniu do minimum wspomniany system implementuje nieskończoną pętlę oczekującą na naciśnięcia klawiszy, przetwarza je na polecenia, wykonuje polecenia i uaktualnia ekran. Opisane zachowanie można dostosować do własnych potrzeb na wiele sposobów.  Po pojedynczym naciśnięciu klawiszy są one natychmiast mapowane za pomocą tabeli mapowania klawiatury. Zmiana wpisów we wspomnianej tabeli pozwala na zamianę klawiszy. Jeżeli jesteś przyzwyczajony do pracy z edytorem vi lub vim, być może będziesz chciał zamienić działanie poleceń Delete i Ctrl+H. Następnie polecenie Ctrl+H będzie działało jak Backspace w edytorze vim, a Delete (nieużywane w vim) jako klawisz wywołujący pomoc. Jeżeli chcesz użyć Delete w charakterze klawisza przerwania, możesz wybrać inny klawisz do zastąpienia nim Ctrl+H.  Mapowane naciśnięcia klawiszy są zbierane w małe grupy zwane sekwencjami klawiszy. Sekwencja klawiszy może się składać z naciśnięcia tylko jednego znaku, na przykład Ctrl+N, lub dwóch bądź więcej, na przykład Ctrl+X Ctrl+F. Po zebraniu poleceń w grupie sekwencja klawiszy jest używana w celu wybrania określonej procedury do wykonania. Reguły określające zbieranie sekwencji klawiszy i nazwy wykonywanych procedur są zdefiniowane w serii tabel nazywanych keymaps. Przez modyfikację wspomnianych tabel można zmienić reguły zbierania naciśnięć klawiszy, a także polecenia przypisane poszczególnym sekwencjom. Jeśli na przykład przyzwyczaiłeś się do pracy z edytorem vi lub vim i używasz Ctrl+W do usunięcia słowa, możesz zmienić domyślne przypisanie tej sekwencji w edytorze emacs z kill-region na delete-word-backword.

Tryby podstawowe — edycja w zależności od języka  277

 

Zachowanie poleceń jest często uwarunkowane jedną lub większą liczbą zmiennych środowiskowych bądź opcji. Istnieje możliwość zmiany tego zachowania przez ustawienie wspomnianych zmiennych. Same polecenia są najczęściej programami w języku Lisp, które można przebudować i dostosować do własnych potrzeb. Wprawdzie takie zadanie nie jest przeznaczone dla początkujących, ale kod źródłowy Lisp jest dostępny dla niemalże wszystkich poleceń, a ponadto system Lisp jest w pełni udokumentowany. Jak już wcześniej wspomniano, najczęściej spotykane rozwiązanie polega na wczytaniu własnego kodu Lisp podczas uruchamiania edytora, nawet jeśli dodawanego kodu nie utworzyłeś samodzielnie.

Większość dokumentacji edytora emacs wyjaśnia kroki zbierania, mapowania i wyboru procedur, a także omawia naciśnięcia klawiszy tak, jakby były poleceniami. Trzeba jednak znać sposób działania wewnętrznego systemu, aby wiedzieć, jak zmodyfikować jego zachowanie.

PLIK STARTOWY .EMACS W trakcie uruchamiania edytora emacs następuje wczytanie pliku kodu Lisp o nazwie .emacs, który znajduje się w katalogu domowym użytkownika. Wykorzystanie wymienionego pliku to najczęściej używany sposób dostosowania emacs do własnych potrzeb. Dwie opcje wiersza poleceń kontrolują sposób użycia pliku .emacs. Opcja -q powoduje zupełne zignorowanie pliku .emacs, więc edytor zostanie uruchomiony bez jego wczytania; to jeden ze sposobów pominięcia nieprawidłowego pliku .emacs. Z kolei opcja -u użytkownik pozwala na użycie pliku ~użytkownik/.emacs (plik .emacs pochodzący z katalogu domowego użytkownika). Plik startowy .emacs koncentruje się głównie na przypisaniach klawiszy i ustawieniu opcji. Istnieje możliwość umieszczenia w nim poleceń Lisp przy użyciu bardzo prostego stylu. Każde polecenie Lisp umieszczone w nawiasie jest wywołaniem funkcji Lisp. Wewnątrz nawiasu pierwszy symbol to nazwa funkcji, natomiast pozostałe to rozdzielone spacjami argumenty tej funkcji. Najczęściej używaną w pliku .emacs funkcją jest setq, czyli proste przypisanie zmiennej globalnej. Pierwszy argument to nazwa zmiennej, natomiast drugi to jej wartość. Przedstawiony poniżej wiersz powoduje przypisanie wartości 8 zmiennej c-indent-level:

Przypisanie wartości zmiennej

(setq c-indent-level 8)

Podczas pracy w edytorze emacs polecenie Ctrl+H v powoduje wyświetlenie pytania o nazwę zmiennej. Po podaniu nazwy zmiennej i naciśnięciu klawisza Enter edytor wyświetla wartość tej zmiennej.

Wyświetlanie wartości zmiennej

Istnieje możliwość zdefiniowania wartości domyślnej zmiennej. Do tego celu służy funkcja setq-default, a wartość będzie obowiązywała w buforze. Aby elementowi przypisać wektor, należy użyć funkcji aset. Pierwszym argumentem jest nazwa wektora, drugim wartość przesunięcia, natomiast trzecim wpis docelowy. W pliku startowym nowe wartości są najczęściej stałymi. W tabeli 7.21 wymieniono formaty stosowane przez wspomniane stałe.

Ustawienie wartości domyślnej dla zmiennej

Tabela 7.21. Formaty stałych w pliku .emacs Polecenie

Opis

Liczby

Dziesiętne liczby całkowite wraz z opcjonalnym znakiem minus.

Ciągi tekstowe

Podobne do ciągów tekstowych języka C, ale z rozszerzeniami dla znaków Ctrl i Meta: \C-s oznacza Ctrl+S, \M-s oznacza Meta+S, natomiast \M-\C-s oznacza Ctrl+Meta+s.

Znaki

Nie przypomina znaków stosowanych w języku C. Rozpoczyna się znakiem ? i zawiera znak widzialny lub sekwencję poprzedzoną ukośnikiem, na przykład ?a, ?\C-i, ?\033.

Wartości boolowskie

Nie 1 i 0, należy użyć t dla wartości true i nil dla false.

Inne obiekty Lisp

Rozpoczyna się apostrofem, a następnie zawiera nazwę obiektu.

278  ROZDZIAŁ 7. EDYTOR EMACS

PONOWNE MAPOWANIE KLAWISZY Pętla poleceń emacs rozpoczyna każdy cykl przekształcania nadchodzących naciśnięć klawiszy na nazwę polecenia przeznaczonego do wykonania. Podstawowa operacja mapowania używa wartości ASCII przychodzącego znaku do zindeksowania 128-elementowego wektora nazwanego keymap. Czasami ósmy bit znaku jest interpretowany jako Meta, ale na tym mechanizmie nie można w pełni polegać. W chwili mapowania wszystkie znaki Meta pojawiają się jako prefiks Esc, niezależnie od tego, czy faktycznie zostały wprowadzone przez naciśnięcie klawisza Esc. Każde położenie w wektorze ma jedno z poniższych znaczeń:  Brak definicji — nie ma żadnego przekształcenia dla danego mapowania.  Nazwa innego mapowania — przejście do wskazanego mapowania i oczekiwanie na kolejny znak.  Nazwa funkcji Lisp do wywołania — proces przekształcenia został zakończony, wywołaj tę funkcję. Ponieważ mapowania mogą odwoływać się do innych mapowań, w ten sposób może powstać nawet skomplikowane drzewo zależności. Przypisania w edytorze emacs używają maksymalnie trzech klawiszy, stosowana jest niewielka grupa doskonale znanych klawiszy prefiksu, każdy z doskonale znaną nazwą mapowania. Poszczególne bufory mają lokalną kopię wektora keymap, która jest używana w pierwszej kolejności do obsługi wszelkich naciśnięć klawiszy, gdy wybrane jest okno zawierające dany bufor. Wspomniana lokalna kopia wektora pozwala na rozbudowę standardowego mapowania lub jego zmianę w poszczególnych buforach. Najczęściej jest używana w celu dodania przypisań klawiszy dla trybu podstawowego. Podstawowy proces przekształcenia przebiega w przedstawiony poniżej sposób.  Mapowanie pierwszego znaku za pomocą lokalnej kopii wektora. Jeżeli jest zdefiniowane jako nazwa funkcji Lisp, przekształcenie się kończy i emacs wykonuje wskazaną funkcję. Natomiast jeśli dla tego mapowania nie ma zdefiniowanej funkcji, ten sam znak jest sprawdzany w globalnym wektorze keymap.  Mapowanie pierwszego znaku za pomocą globalnego wektora keymap o nazwie global-map. Na tym etapie może wystąpić jedna z przedstawionych poniżej sytuacji.  Jeżeli wpis dla danego znaku nie został zdefiniowany, mamy błąd. Terminal otrzymuje znak wywołujący sygnał dźwiękowy, a wszystkie znaki wprowadzone w tej sekwencji są odrzucane.  Jeżeli wpis dla danego znaku został zdefiniowany jako funkcja Lisp, przekształcenie się kończy i emacs wykonuje wskazaną funkcję.  Jeżeli wpis dla danego znaku został zdefiniowany jako nazwa innego mapowania, następuje przejście do wskazanego mapowania i oczekiwanie na kolejny znak pozwalający na wybór jednego z jego elementów. Wszystkie dane wejściowe otrzymane w trakcie procesu ponownego mapowania muszą tworzyć polecenie albo błąd. Zwykłe znaki umieszczane w buforze zwykle są przypisane do polecenia self-insert-command. W tabeli 7.22 wymieniono doskonale znane prefiksy znaków wraz z powiązanymi z nimi mapowaniami. Tabela 7.22. Prefiksy mapowania klawiszy Prefiks mapowania klawiszy

Ma zastosowanie dla

ctl-x-map

Znaków znajdujących się po Ctrl+X

ctl-x-4-map

Znaków znajdujących się po Ctrl+X 4

esc-map

Znaków znajdujących się po Esc (włączając również znaki Meta)

help-map

Znaków znajdujących się po Ctrl+H

określony-tryb-mapowania

Znaków znajdujących się po Ctrl+C

Aby wyświetlić bieżący stan mapowania, należy wydać polecenie Ctrl+H b. Informacje są wyświetlane w następującej kolejności: lokalne, globalne i skrócone mapowanie dla każdego klucza prefiksu. Każdy wiersz wskazuje nazwę wywoływanej funkcji Lisp, dokumentację dla wyświetlonej funkcji można wyświetlić po wydaniu polecenia Ctrl+H f nazwa-funkcji lub Ctrl+H k sekwencja-klawiszy.

Tryby podstawowe — edycja w zależności od języka  279

Najczęstszy rodzaj modyfikacji mapowania polega na wprowadzeniu niewielkich zmian w przypisaniach globalnych bez tworzenia nowych przypisań lub poleceń. Ten rodzaj dostosowania do własnych potrzeb można łatwo przeprowadzić w pliku .emacs, używając funkcji Lisp o nazwie define-key. Wymieniona funkcja pobiera trzy argumenty:  nazwę mapowania;  pojedynczy znak definiujący położenie w danym mapowaniu;  polecenie wykonywane po nadejściu wskazanego znaku. Na przykład w celu powiązania polecenia bacward-kill-word z sekwencją Ctrl+W należy użyć poniższego polecenia: (define-key global-map "\C-w" 'backward-kill-word)

Znak \ powoduje, że sekwencja C-w będzie interpretowana jako Ctrl+W zamiast trzech liter (odpowiednik \^w). Pojedynczy apostrof umieszczony na początku nazwy polecenia jest prawidłowy. W ten sposób Lisp chroni się przed zbyt szybkim wywołaniem funkcji. Aby przypisać funkcję kill-region do sekwencji Ctrl+X Ctrl+K, należy użyć poniższego polecenia: (define-key ctl-x-map "\C-k" 'kill-region)

PRZYKŁADOWY PLIK .EMACS Przedstawiony w tym punkcie przykładowy plik ~/.emacs tworzy proste środowisko edycyjne, które minimalizuje niespodzianki czekające na użytkowników edytorów vi i vim. Jeżeli którakolwiek sekcja lub wiersz poniższego pliku nie pasują do Twoich potrzeb, możesz wprowadzić odpowiednie modyfikacje bądź umieścić wiersz w komentarzu przez wstawienie średnika w pierwszej kolumnie. ;;; Zmienne ustawień (setq (setq (setq (setq (setq

make-backup-files nil) backup-by-copying t) delete-auto-save-files t) blink-matching-paren nil) require-final-newline 'ask)

;Nie twórz kopii zapasowych plików. ;Jeśli je utworzysz, przynajmniej nie niszcz dowiązań. ;Usuń pliki autosave podczas zapisu oryginału. ;Nie migaj otwierającym ogranicznikiem. ;Zapytaj o brakujący na końcu znak nowego wiersza.

;; Zamiana mapowania C-h i DEL. ;; Czasami jest użyteczne otrzymanie znaku DEL po naciśnięciu klawisza Backspace, ;; a pomoc będzie wtedy wywoływana klawiszem Delete. ;; NB: F1 zawsze prowadzi do pomocy. (keyboard-translate ?\C-h ?\177) (keyboard-translate ?\177 ?\C-h)

;; Coś dla użytkowników vi: emulacja polecenia CR, ;; które przenosi do pierwszego kolejnego niepustego wiersza.

(defun forward-line-1-skipws () "Umieszczenie w pierwszym niepustym znaku w kolejnym wierszu." (interactive) (if (= (forward-line) 0) ;Jeśli wszystko OK, rozpocznij nowy wiersz. (skip-chars-forward " \t"))) ;Pomiń poziomy znak odstępu.

;; Przypisanie do M-n. ("enhanced next-line") ;; C-M-n jest bardziej "odpowiednie", ale (1) wymaga użycia trzech palców ;; i (2) C-M-n jest już przypisane poleceniu forward-list. (define-key esc-map "n" 'forward-line-1-skipws)

;; Zmiana w trybie C: ustawienie wcięcia o wielkości 8 spacji. (require 'cc-mode) (setq c-default-style '( (java-mode . "java") (awk-mode . "awk") (c-mode . "bsd") (other . "gnu") ))

;kiss: upewnij się, że tryb to C

;; Więcej przykładów dotyczących konfiguracji stylu znajdziesz w pomocy dla trybu CC. ;; Koniec konfiguracji stylu trybu C.

280  ROZDZIAŁ 7. EDYTOR EMACS

WIĘCEJ INFORMACJI Ogromna ilość dokumentacji poświęconej edytorowi emacs jest dostępna zarówno w wersji papierowej, jak i elektronicznej. Strona emacs info i omówione wcześniej w rozdziale funkcje pomocy dostarczają mnóstwo informacji. Warto zajrzeć także na stronę internetową poświęconą edytorowi GNU emacs: http://www.gnu.org/software/emacs/. Grupy dyskusyjne comp.emacs i gnu.emacs.help oferują pomoc oraz możliwość ogólnej dyskusji o edytorze emacs.

UZYSKANIE DOSTĘPU DO EMACS Edytor emacs znajduje się w repozytoriach większości dystrybucji systemu Linux. Możesz go pobrać i zainstalować za pomocą narzędzia apt-get (patrz dodatek A) lub yum (patrz dodatek A). Najnowsza wersja kodu źródłowego emacs jest dostępna na witrynie http://www.gnu.org/. Fundacja Free Software Foundation jest dostępna pod poniższymi adresami: Free Software Foundation, Inc. 51 Franklin Street, Fifth Floor Boston, MA 02110-1301, USA E-mail [email protected] Telefon +1 617-542-5942 Faks +1 617 542 2652 WWW http://www.gnu.org/ Adres pocztowy

PODSUMOWANIE ROZDZIAŁU Wiele poleceń wymienionych w poniższych tabelach można poprzedzać argumentami liczbowymi i tym samym wskazać ilość powtórzeń danego polecenia. Poprzedzenie argumentu liczbowego poleceniem Ctrl+U powoduje, że emacs nie traktuje argumentu jako tekstu. W tabeli 7.23 wymieniono polecenia pozwalające na poruszanie kursorem Tabela 7.23. Poruszanie kursorem Polecenie

Opis

Ctrl+F

Do przodu o znaki.

Ctrl+B

Do tyłu o znaki.

Meta+f

Do przodu o znaki.

Meta+b

Do tyłu o znaki.

Meta+e

Na koniec zdania.

Meta+a

Na początek zdania.

Meta+}

Na koniec akapitu.

Meta+}

Na początek akapitu.

Meta+>

Do przodu do końca bufora.

Meta+
na początku każdego dołączonego wiersza? 9. Edytor emacs zawsze oferował bogate możliwości edycji przy użyciu klawiatury. Ogólnie rzecz ujmując, ten sam efekt można osiągnąć na kilka sposobów. W środowisku graficznym liczba sposobów jeszcze wzrasta, ponieważ do dyspozycji otrzymujesz kolejne techniki oparte na wykorzystaniu myszy. Z dostępnych możliwości wybierz tę, która najlepiej pozwoli Ci na wykonanie poniższego zadania.

288  ROZDZIAŁ 7. EDYTOR EMACS Weźmy pod uwagę poniższy fragment dzieła Szekspira: 1. Full fathom five thy father lies; 2. Of his bones are coral made; 3. Those are pearls that were his eyes: 4. Nothing of him that doth fade, 5. But doth suffer a sea-change 6. Into something rich and strange. 7. Sea-nymphs hourly ring his knell: 8. Ding-dong. 9. Hark! now I hear them-10. Ding-dong, bell!

Poniższy fragment został zapisany z pewnymi błędami: 1. Full fathiom five tyy father lies; 2. These are pearls that were his eyes: 3. Of his bones are coral made; 4. Nothin of him that doth fade, 5. But doth susffer a sea-change 6. Into something rich and strange. 7. Sea-nymphs hourly ring his knell: 8. Ding=dong. 9. Hard! now I hear them-10. Ding-dong, bell!

Używając jedynie klawiatury, spróbuj odpowiedzieć na następujące pytania. a) Na ile sposobów można przenosić kursor pomiędzy błędami w tekście? b) Kiedy kursor znajduje się w pobliżu błędu, na ile sposobów można poprawić błąd? c) Czy istnieje możliwość poprawienia błędów bez wyraźnego przechodzenia do nich lub ich wyszukiwania? Jak sądzisz, ile takich sposobów może być? d) W ponownie wprowadzonym tekście wiersze 2. i 3. są zamienione miejscami. Na ile sposobów można to poprawić?

ĆWICZENIA ZAAWANSOWANE 10. Przyjmujemy założenie, że bufor zawiera przedstawiony poniżej kod w języku C; tryb podstawowy jest ustawiony dla języka C, a kursor znajduje się na końcu wiersza while, na co wskazuje czarny kwadratowy kursor: /* * Kopiowanie ciągu tekstowego s2 do s1. Ciąg s1 musi być wystarczająco duży. * Wartością zwrotną jest s1. */ char *strcpy(char *s1, char *s2) { char *os1; os1 = s1; while (*s1++ = *s2++) ; return os1; }

/* * Kopiowanie source do dest, zatrzymanie po skopiowaniu '\0' * i zwrot wskaźnika do '\0' na końcu dest. Następnie wywołujący * może dołączyć do ciągu tekstowego dest bez konieczności innego wywołania strlen. */

Ćwiczenia zaawansowane  289

char *stpcpy (char *dest, char *source) { while ((*dest++ = *source++) != '\0') ■ ; /* pusta część główna pętli */ return (dest - 1); }

a) Które polecenie przeniesie kursor na początek otwierającego nawiasu strcpy? Które polecenie przeniesie kursor tuż za nawias zamykający? Czy tych poleceń możesz użyć do przejścia przez zawartość bufora w krokach co jedną procedurę? b) Przyjmujemy założenie, że kursor znajduje się za nawiasem zamykającym pętlę while. W jaki sposób można go przenieść do dopasowanego nawiasu otwierającego? Jak można go przenieść z powrotem do dopasowanego nawiasu zamykającego? Czy te same polecenia działają także z dopasowanymi nawiasami kwadratowymi [] i klamrowymi {}? Czym te polecenia różnią się od polecenia % edytora vim? c) Jedna procedura jest wcięta w stylu Berkeley, druga w stylu GNU. Które polecenie pozwala na ponowne zastosowanie wcięć wiersza zgodnie z aktualnie ustawionym stylem wcięć? Jak można ponownie zastosować wcięcia w całej procedurze? d) Przyjmujemy założenie, że chcesz napisać pięć procedur obsługi ciągów tekstowych i użyć strcpy jako punktu wyjścia dla dalszej edycji procedur. Jak możesz utworzyć pięć kopii procedury strcpy? e) Jak można skompilować ten kod bez opuszczania edytora emacs?

290  ROZDZIAŁ 7. EDYTOR EMACS

Część III Powłoki

ROZDZIAŁ 8. Powłoka Bourne Again Shell (bash)

ROZDZIAŁ 9. Powłoka TC Shell (tcsh)

292  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

Kilka słów o powłoce bash  293

8 Powłoka Bourne Again Shell (bash)

W tym rozdziale:

Cele rozdziału

Pliki startowe

Po przeczytaniu tego rozdziału będziesz potrafił:  Opisać historię i przeznaczenie powłoki bash.  Wymienić pliki startowe wykorzystywane przez powłokę bash.  Uruchomić skrypty powłoki, używając trzech różnych metod.  Opisać przeznaczenie zmiennej PATH.  Zarządzać wieloma procesami przy użyciu mechanizmu sterowania zadaniami (ang. job control).  Przekierować komunikaty o błędach do pliku.  Oddzielać i grupować polecenia przy użyciu znaków specjalnych.  Tworzyć zmienne oraz wyświetlać wartości zmiennych i parametrów.  Wymienić i opisać podstawowe zmienne systemowe.  Korzystać z historii poleceń powłoki do szybkiego przywoływania, modyfikowania i ponownego uruchamiania poprzednio wykonanych poleceń.  Używać znaków sterujących do edytowania wiersza poleceń.  Tworzyć, wyświetlać i usuwać aliasy poleceń oraz funkcje.  Dostosowywać środowisko powłoki bash przy użyciu wbudowanych poleceń set i shopt.  Opisać kolejność, w jakiej powłoka rozwija wiersz poleceń.

Przekierowywanie standardowego strumienia błędów Tworzenie i uruchamianie prostych skryptów powłoki Sterowanie zadaniami Wykorzystanie stosu katalogów Parametry i zmienne Ustawienia językowe Procesy Historia poleceń Ponowne wykonywanie i modyfikacja poleceń Funkcje Sterowanie powłoką bash — mechanizmy i opcje Przetwarzanie wiersza poleceń

294  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Tematyka zagadnień omawianych w tym rozdziale zaczyna się tam, gdzie zakończył się rozdział 5. Wszelkie różnice w implementacji powłoki tcsh omawianych tutaj funkcji będą wyraźnie oznaczone. Jeśli będzie konieczne, zostaniesz skierowany do miejsca, w którym znajdziesz omówienie alternatywnej implementacji. Z kolei rozdział 10. jest uzupełnieniem bieżącego rozdziału, opisującym takie zagadnienia jak polecenia sterujące wykonywaniem skryptów czy instrukcje warunkowe, a także poruszającym inne, bardziej zaawansowane aspekty programowania powłoki bash. Więcej szczegółowych informacji na temat powłoki bash znajdziesz na jej stronie domowej, http://www.gnu.org/software/bash/. Kompletną dokumentację powłoki Bourne Again Shell znajdziesz również na stronach podręcznika info. Powłoki bash i tcsh są interpreterami poleceń oraz językami programowania wysokiego poziomu. Jako interpreter poleceń powłoka przetwarza polecenia, które wpisujesz w wierszu poleceń po znaku zachęty. Kiedy używasz powłoki jako języka programowania, powłoka przetwarza polecenia zapisane w plikach tekstowych, nazywanych skryptami powłoki (ang. shell scripts). Podobnie jak w innych językach programowania, tak i w powłoce istnieją zmienne oraz polecenia sterujące realizacją programu (na przykład instrukcje warunkowe i pętle). Kiedy używasz powłoki jako interpretera poleceń, możesz dostosować do własnych potrzeb środowisko, w którym pracujesz. Możesz zmienić wygląd znaku zachęty na przykład tak, aby wyświetlał nazwę bieżącego katalogu roboczego, tworzyć własne funkcje czy aliasy poleceń (na przykład alias dla polecenia cp, tak aby zapobiegać nadpisywaniu niektórych rodzajów plików), korzystać ze zmiennych zmieniających sposób działania powłoki i tak dalej. Możesz również pisać skrypty powłoki, które będą realizowały Twoje własne zadania — począwszy od prostych, jednowierszowych „skrypcików”, przechowujących długie polecenia o skomplikowanej składni, aż do rozbudowanych, liczących setki wierszy skryptów, które automatycznie tworzą złożone raporty, drukują je i wysyłają Ci pocztą elektroniczną potwierdzenie o wykonaniu zadania. Bardziej skomplikowane skrypty powłoki są całkowicie samodzielnymi programami i w niczym nie przypominają prostej listy poleceń do wykonania. W rozdziale 10. znajdziesz kilka przykładów takich skryptów. Większość skryptów systemowych została przygotowana do pracy w powłoce bash (lub dash, o czym niebawem). Jeżeli kiedykolwiek będziesz pracował w trybie jednoużytkownikowym (ang. single-user mode) — na przykład kiedy będziesz przeprowadzał konserwację systemu, zadania administracyjne czy odtwarzanie i naprawianie systemu po awarii — to zdecydowanie powinieneś zaprzyjaźnić się z tą powłoką i nauczyć się z nią pracować. W tym rozdziale rozszerzymy zagadnienia omawiane w rozdziale 5., pokażemy, w jaki sposób możesz tworzyć i uruchamiać proste skrypty powłoki, przedstawimy mechanizm sterowania zadaniami, wspomnimy o lokalizacji powłoki, omówimy podstawowe zagadnienia związane z programowaniem powłoki, powiemy kilka słów o historii poleceń i aliasach, a także opiszemy, w jaki sposób powłoka rozwija wiersz poleceń. Tematem rozdziału 9. będzie interaktywne użycie powłoki TC Shell oraz programowanie w niej. Bardziej złożone zagadnienia dotyczące programowania powłoki zostaną omówione w rozdziale 10.

KILKA SŁÓW O POWŁOCE BASH Powłoka Bourne Again Shell (bash) została zbudowana w oparciu o powłokę Bourne Shell (jedna z pierwszych i najważniejszych powłok systemu UNIX; w celu uniknięcia nieporozumień, mówiąc o tej powłoce w naszej książce, będziemy posługiwać się określeniem oryginalna powłoka Bourne Shell), która została napisana przez Steve’a Bourne’a z Bell Laboratories firmy AT&T. Z biegiem lat oryginalna powłoka Bourne Shell została znacząco rozszerzona i udoskonalona, ale nadal pozostaje podstawową powłoką dla wielu komercyjnych dystrybucji systemu UNIX.

Powłoka bash

Kilka słów o powłoce bash  295

Ze względu na swoją długą, pełną sukcesów historię oryginalna powłoka Bourne Shell była wykorzystywana do napisania wielu efektywnych skryptów, ułatwiających zarządzanie systemami UNIX. Niektóre z tych skryptów pojawiły się w systemie Linux, dostosowane do powłoki bash. Choć powłoka bash posiada wiele rozszerzeń i nowych funkcji, których nie ma w oryginalnej powłoce Bourne Shell, to jednak powłoka bash zachowała kompatybilność z oryginalną powłoką Bourne Shell, dzięki czemu możesz bez problemów uruchamiać w niej skrypty z oryginalnej powłoki Bourne Shell. W systemach UNIX oryginalna powłoka Bourne Shell nosi nazwę sh.

Powłoka sh

W systemach Linux polecenie sh jest dowiązaniem symbolicznym do polecenia bash lub dash, dzięki czemu skrypty wymagające obecności oryginalnej powłoki Bourne Shell nadal będą działać. Kiedy powłoka bash zostanie wywołana jako sh, stara się jak najlepiej emulować zachowanie oryginalnej powłoki sh. W systemie OS X sh to po prostu kopia powłoki bash. Plik wykonywalny powłoki bash ma rozmiar prawie 900 kB, a sama powłoka posiada wiele mechanizmów i funkcji i jest dobrze dostosowana do spełniania roli powłoki logowania dla użytkownika. Z kolei powłoka dash (ang. Debian Almquist Shell) ma rozmiar zaledwie 100 kB, oferuje pełną kompatybilność z oryginalną powłoką sh (dla skryptów, do zastosowań nieinteraktywnych), a ze względu na swój niewielki rozmiar może zostać załadowana i wykonywać skrypty znacznie szybciej niż powłoka bash.

Powłoka dash

W dystrybucji System V UNIX pojawiła się powłoka Korn Shell (ksh), napisana przez Davida Korna. Nowa powłoka rozszerzała wiele mechanizmów oryginalnej powłoki Bourne Shell oraz dodawała wiele nowych funkcji. Niektóre mechanizmy powłoki bash, takie jak aliasy poleceń i edytowanie wiersza poleceń, są oparte na podobnych elementach powłoki Korn Shell.

Powłoka Korn

Rodzina standardów POSIX (ang. Portable Operating System Interface) jest opracowywana przez stowarzyszenie PASC (ang. IEEE’s Portable Application Standards Committee, patrz http://www.pasc.org/plato). Bardzo rozbudowany zestaw najczęściej zadawanych pytań na temat standardu POSIX znajdziesz na stronie http://www.opengroup.org/austin/papers/posix_faq.html.

POSIX

Funkcjonalność powłoki została opisana przez standard POSIX 1003.2. Powłoka bash posiada wiele mechanizmów zgodnych z tym standardem, a obecnie trwają prace mające na celu zapewnienie pełnej zgodności powłoki bash ze standardem POSIX. Do czasu opracowania nowej wersji powłoki możesz uruchamiać bash z opcją --posix, co przełącza ją w tryb pracy najbardziej zbliżony do wymagań tego standardu.

WSKAZÓWKA Polecenie chsh — zmiana powłoki logowania Osoba, która tworzy i konfiguruje Twoje konto użytkownika, określa, jakiej powłoki będziesz używał po pierwszym zalogowaniu się do systemu lub po uruchomieniu emulatora terminala w środowisku graficznym. W większości systemów Linux domyślną powłoką jest bash. Po zalogowaniu się możesz uruchomić dowolną powłokę. Aby to zrobić, wpisz w wierszu poleceń nazwę żądanej powłoki (bash, tcsh lub inne) i naciśnij klawisz Enter — kolejny znak zachęty zostanie wyświetlony już przez nową powłokę. Aby zakończyć pracę z nową powłoką i powrócić do poprzedniej powłoki, wykonaj polecenie exit. Ponieważ powłoki uruchamiane w ten sposób są zagnieżdżone (każda kolejna powłoka jest uruchamiana jako proces powłoki poprzedniej), wylogowanie się z systemu jest możliwe tylko z pierwszej, domyślnej powłoki systemowej. Jeżeli korzystasz z kilku zagnieżdżonych powłok, powinieneś wykonywać kolejne polecenia exit dotąd, aż powrócisz do oryginalnej początkowej powłoki. Po jej osiągnięciu możesz się wylogować z systemu. Aby na stałe zmienić rodzaj używanej powłoki, powinieneś skorzystać z polecenia chsh. Aby to zrobić, w wierszu poleceń wpisz polecenie chsh. Powłoka poprosi Cię o podanie hasła i następnie bezwzględnej ścieżki do nowej powłoki (na przykład /bin/bash, /bin/tcsh lub ścieżka do innej powłoki). Kiedy dokonasz w ten sposób zmiany powłoki logowania z poziomu okna emulatora terminala w środowisku graficznym, kolejne okna emulatora terminala nie będą się zmieniały dopóty, dopóki nie wylogujesz się z systemu i nie zalogujesz się ponownie. Przykład zastosowania polecenia chsh znajdziesz w rozdziale 9.

296  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

PLIKI STARTOWE Podczas uruchamiania powłoka wykonuje pliki startowe, które zawierają informacje niezbędne do zainicjalizowania sesji powłoki. To, które pliki zostaną wykonane, zależy od tego, czy uruchamiana jest powłoka logowania, powłoka interaktywna, która nie jest powłoką logowania (na przykład poprzez uruchomienie nowej powłoki z wiersza poleceń), czy powłoka nieinteraktywna (wykorzystywana do wykonywania skryptów powłoki). Aby wykonać polecenia zapisane w plikach startowych, musisz posiadać do nich prawo odczytu. Typowa dystrybucja systemu Linux umieszcza odpowiednie polecenia w kilku wybranych plikach startowych. W tej sekcji omówimy pliki startowe powłoki bash. Pliki startowe powłoki tcsh zostaną przedstawione w rozdziale 9., natomiast systemu OS X w dodatku D.

POWŁOKA LOGOWANIA Powłoka logowania jest pierwszą powłoką, która po zalogowaniu się użytkownika do systemu z poziomu konsoli systemowej lub wirtualnej czy zdalnej sesji ssh wyświetla na ekranie znak zachęty. Jeżeli korzystasz z graficznego interfejsu użytkownika i uruchamiasz emulator terminala, taki jak na przykład gnome-terminal, nie logujesz się do systemu (nie musisz podawać nazwy użytkownika i hasła dostępu), stąd emulator terminala nie wyświetla powłoki logowania — jest to przykład sesji powłoki interaktywnej, która nie jest powłoką logowania (ang. interactive nonlogin shell). Wszystkie powłoki logowania są interaktywne z definicji. Z rozdziału 10. dowiesz się, jak sprawdzić typ używanej powłoki. W tej sekcji opiszemy pliki startowe, które są wykonywane przez powłoki logowania oraz przez powłoki bash uruchamiane z opcją --login. Powłoka najpierw wykonuje polecenia zawarte w pliku /etc/profile, tworząc domyślne, systemowe ustawienia (profile) dla wszystkich użytkowników korzystających z powłoki bash. Oprócz wykonania swoich poleceń plik profile uruchamia również polecenia zapisane we wszystkich plikach z rozszerzeniem .sh, przechowywanych w katalogu /etc/profile.d. Takie rozwiązanie pozwala użytkownikowi pracującemu z uprawnieniami użytkownika root na modyfikowanie poleceń wykonywanych przez plik profile bez modyfikowania samej zawartości tego pliku. Ponieważ plik profile może zostać zamieniony podczas aktualizacji systemu, dokonywanie zmian w plikach znajdujących się w katalogu profile.d zapewnia, że wprowadzone zmiany pozostaną aktywne po dokonaniu aktualizacji systemu.

Plik /etc/profile

WSKAZÓWKA Definiuj zmienne globalne dla wszystkich użytkowników w plikach *.sh znajdujących się w katalogu /etc/profile.d Ustawianie i eksportowanie zmiennych w plikach z rozszerzeniem .sh znajdujących się w katalogu /etc/profile.d powoduje, że takie zmienne są dostępne dla powłoki logowania każdego użytkownika. Ponieważ takie zmienne są wyeksportowane, są również dostępne dla wszystkich interaktywnych i nieinteraktywnych podpowłok powłoki logowania. Następnie powłoka poszukuje plików ~/.bash_profile, ~/.bash_login lub ~/.profile (jak pamiętasz, ciąg znaków ~/ reprezentuje ścieżkę do katalogu domowego), w takiej właśnie kolejności i wykonuje polecenia z pierwszego napotkanego pliku. Wymienionych plików możesz użyć na przykład do modyfikacji globalnych ustawień domyślnych zdefiniowanych w pliku /etc/profile.

Pliki .bash_profile, .bash_login oraz .profile

Domyślnie w typowej dystrybucji systemu Linux nowe konta są tworzone z plikami ~/.bash_profile oraz ~/.bashrc. Zgodnie z ustawieniami domyślnymi plik ~/.bash_profile wywołuje plik ~/.bashrc, który z kolei wywołuje plik /etc/bashrc (o którym powiemy za chwilę). Kiedy rozpoczynasz proces wylogowania, powłoka bash wykonuje polecenia zapisane w pliku ~/.bash_logout. W pliku tym często przechowywane są polecenia, których zadaniem jest „posprzątanie” przed zakończeniem sesji (na przykład usunięcie plików tymczasowych).

Plik .bash_logout

Pliki startowe  297

POWŁOKI INTERAKTYWNE (TYPU NON-LOGIN) Polecenia przechowywane w omawianych powyżej plikach startowych nie są wykonywane przez powłoki interaktywne, które nie są powłokami logowania (ang. interactive nonlogin shell). Należy jednak pamiętać, że powłoki interaktywne dziedziczą zmienne, które są ustawiane przez powłoki logowania za pomocą plików startowych. Interaktywne powłoki typu non-login po uruchomieniu wykonują polecenia zapisane w pliku ~/.bashrc. Domyślnie plik ~/.bashrc wywołuje plik /etc/bashrc.

Plik .bashrc

Plik /etc/bashrc nie jest wywoływany przez powłokę bash — w wielu systemach Linux plik ten jest wywoływany przez plik ~/.bashrc.

Plik /etc/bashrc

POWŁOKI NIEINTERAKTYWNE Polecenia przechowywane w poprzednio opisywanych plikach startowych nie są wykonywane przez powłoki nieinteraktywne, wykorzystywane do uruchamiania skryptów powłoki. Pamiętaj, że podobnie jak w przypadku powłok interaktywnych, również powłoki nieinteraktywne dziedziczą zmienne, które są ustawiane przez powłoki logowania za pomocą plików startowych. Pliki crontab (patrz część VI książki) nie dziedziczą zmiennych z plików startowych. Powłoki nieinteraktywne sprawdzają, czy istnieje zmienna środowiskowa o nazwie i wykonują polecenia zapisane w pliku, którego nazwa jest przechowywana w tej zmiennej.

Zmienna BASH_ENV

BASH_ENV (lub ENV, jeżeli wywoływaną powłoką jest sh),

KONFIGURACJA PLIKÓW STARTOWYCH Choć istnieje wiele różnych plików startowych i wiele różnych powłok, to jednak w większości przypadków będą Ci potrzebne tylko pliki .bash_profile oraz .bashrc zlokalizowane w Twoim katalogu domowym. Polecenia podobne do przedstawionych poniżej, znajdujące się w pliku .bash_profile, uruchamiają polecenia z pliku .bashrc dla powłoki logowania (o ile plik .bashrc istnieje). Dzięki takiemu rozwiązaniu polecenia z pliku .bashrc są wykonywane zarówno przez powłoki logowania, jak i powłoki interakcyjne typu non-login. if [ -f ~/.bashrc ]; then . ~/.bashrc; fi

Polecenie [ –f ~/.bashrc ] sprawdza, czy w Twoim katalogu domowym istnieje plik o nazwie .bashrc. Więcej szczegółowych informacji na temat wbudowanego polecenia test oraz jego synonimu [] znajdziesz w rozdziale 10. oraz w części VI książki. Więcej szczegółowych informacji na temat zastosowania znaku kropli (.) przedstawimy już za chwilę.

WSKAZÓWKA Ustawianie zmiennej PATH w pliku .bash_profile Ponieważ polecenia w pliku .bashrc mogą być wykonywane wiele razy oraz ponieważ podpowłoki dziedziczą wszystkie zmienne, które zostały wyeksportowane, dobrym rozwiązaniem jest umieszczanie poleceń dodających i modyfikujących zmienne w pliku .bash_profile. Na przykład polecenie przedstawione poniżej, dodające podkatalog bin katalogu home do zmiennej PATH, powinno zostać umieszczone w pliku .bash_profile: PATH=$PATH:$HOME/bin

Jeżeli umieścisz powyższe polecenie w pliku .bash_profile, ale nie dodasz go do pliku .bashrc, to nowa ścieżka będzie dodawana do zmiennej PATH tylko raz — w momencie, kiedy logujesz się do systemu. Modyfikacja zmiennych w pliku .bash_profile powoduje, że zmiany wprowadzane w sesji interaktywnej są przenoszone na podpowłoki. Dla kontrastu modyfikacje zmiennych w pliku .bashrc nadpisują ustawienia dziedziczone z powłoki nadrzędnej.

298  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Poniżej zamieszczamy przykładową zawartość plików .bash_profile oraz .bashrc. Niektóre polecenia używane w tych plikach nie były jeszcze poruszane i zostaną omówione dopiero w dalszej części rozdziału. Zmienne i funkcje definiowane w plikach startowych, które mają być dostępne dla procesów podrzędnych, muszą zostać wyeksportowane. Więcej szczegółowych informacji na temat zasięgu zmiennych znajdziesz w rozdziale 10. $ cat ~/.bash_profile if [ -f ~/.bashrc ]; then . ~/.bashrc fi PATH=$PATH:/usr/local/bin export PS1='[\h \W \!]\$ '

# odczytaj lokalny plik startowy (jeżeli istnieje) # dodaj /usr/local/bin do zmiennej PATH # ustaw znak zachęty

Pierwsze polecenie w powyższym pliku .bash_profile sprawdza, czy w katalogu domowym użytkownika istnieje plik .bashrc, a jeżeli tak — wykonuje jego zawartość. Kolejne polecenie dodaje do zmiennej PATH nową ścieżkę. Zazwyczaj zmienna PATH jest ustawiana i eksportowana w pliku /etc/profile, zatem nie musi już być ponownie eksportowana w pliku startowym użytkownika. Ostatnie polecenie ustawia i eksportuje zmienną PS1, która jest odpowiedzialna za wygląd znaku zachęty wyświetlanego na ekranie. Poniżej przedstawiamy przykładową zawartość pliku .bashrc. Pierwsze polecenie sprawdza, czy istnieje plik /etc/bashrc, a jeżeli tak — wykonuje jego zawartość. Kolejne polecenie włącza opcję noclobber, wyłącza MAILCHECK, ustawia i eksportuje zmienne LANG i VIMINIT (ustawienia początkowe edytora vim) oraz definiuje kilka aliasów poleceń. Ostatnie polecenie definiuje funkcję, która zamienia nazwy dwóch plików. $ cat ~/.bashrc if [ -f /etc/bashrc ]; then source /etc/bashrc fi set -o noclobber unset MAILCHECK export LANG=C export VIMINIT='set ai aw' alias df='df -h' alias rm='rm -i' alias lt='ls -ltrh | tail' alias h='history | tail' alias ch='chmod 755 ' function switch() { local tmp=$$switch mv "$1" $tmp mv "$2" "$1" mv $tmp "$2" }

# odczytaj globalny plik startowy (jeżeli istnieje) # # # # # #

zapobiegaj nadpisywaniu plików wyłącz komunikat "you have new mail" ustaw zmienną LANG ustaw opcje edytora vim utwórz aliasy zawsze korzystaj z interaktywnego polecenia rm

# definicja funkcji zamieniającej nazwy dwóch plików

POLECENIE SOURCE LUB (.) — URUCHAMIANIE PLIKÓW STARTOWYCH W BIEŻĄCEJ POWŁOCE Po zakończeniu edycji plików startowych, takich jak .bashrc, nie musisz wylogowywać się i logować ponownie, aby wprowadzone zmiany weszły w życie. Zamiast tego możesz po prostu uruchomić pliki startowe, korzystając z wbudowanego polecenia source lub znaku kropki (.) będącego jego synonimem. W powłoce tcsh dostępne jest jedynie polecenie source (patrz rozdział 9.). Podobnie jak w przypadku innych poleceń, tak i w wierszu polecenia po znaku kropki musisz umieścić spację. Użycie polecenia . lub source jest podobne do uruchamiania skryptu powłoki, z tym tylko, że te polecenia uruchamiają skrypt jako część bieżącego procesu. Jeśli więc do uruchomienia skryptu używasz polecenia . lub source, zmiany ustawień zmiennych w skrypcie mają bezpośredni wpływ na powłokę, z poziomu której ten skrypt został uruchomiony. Jeżeli uruchomisz pliki startowe jako normalny skrypt powłoki (nie użyjesz polecenia . lub source), zmienne ustawiane przez takie pliki będą dostępne tylko w podpowłokach wykonujących skrypt, a nie w powłoce, z której zostały uruchomione. Polecenia . lub source możesz teoretycznie używać do uruchamiania dowolnych skryptów powłoki (a nie tylko plików startowych),

Polecenia, które są symbolami  299

ale w praktyce może to prowadzić do niepożądanych rezultatów (takich jak na przykład modyfikacja wartość zmiennych, z których korzystasz). Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Zasięg zmiennych” w rozdziale 10. W przykładzie przedstawionym poniżej, w pliku .bashrc ustawianych jest kilka zmiennych, łącznie ze zmienną PS1 (nowy znak zachęty, który będzie wyświetlał nazwę komputera). Zmiany są wprowadzane w życie za pomocą polecenia (.). $ cat ~/.bashrc export TERM=xterm export PS1="$(hostname -f): " export CDPATH=:$HOME stty kill '^u'

# # # #

ustaw ustaw dodaj ustaw

typ terminala znak zachęty HOME do zmiennej CDPATH znak usuwania wiersza na Ctrl+u

$ . ~/.bashrc helios:

POLECENIA, KTÓRE SĄ SYMBOLAMI Powłoka bash wykorzystuje symbole (, ), [, ] oraz $ na wiele różnych sposobów. Aby uniknąć nieporozumień, w tabeli 8.1 zamieszczamy najczęściej używane zastosowania tych symboli oraz numery rozdziałów, w których zastosowania danego symbolu są omawiane bardziej szczegółowo. Tabela 8.1. Wbudowane polecenia powłoki, które są symbolami Symbol

Polecenie

()

Podpowłoka (patrz dalsza część rozdziału 8.).

$()

Podstawienie polecenia (patrz dalsza część rozdziału 8.).

(())

Obliczenia arytmetyczne; synonim polecenia let (używane, kiedy w obliczanym wyrażeniu znajduje się znak równości; patrz rozdział 10.).

$(())

Rozwijanie wyrażeń arytmetycznych (patrz dalsza część rozdziału 8.).

[]

Polecenie test (patrz rozdział 10. oraz część VI książki).

[[]]

Wyrażenie warunkowe; podobne do [], ale dodaje porównywanie ciągów znaków (patrz rozdział 10.).

PRZEKIEROWYWANIE STANDARDOWEGO STRUMIENIA BŁĘDÓW W rozdziale 5. omówiliśmy pojęcie standardowego wyjścia polecenia i wyjaśniliśmy, w jaki sposób można przekierować strumień danych napływający ze standardowego wyjścia. Polecenia mogą wysyłać informacje nie tylko do standardowego wyjścia, ale i do standardowego strumienia błędów (ang. standard error). Zazwyczaj polecenia wysyłają na standardowe wyjście błędów komunikaty o błędach, dzięki czemu nie mieszają się one z informacjami wysyłanymi na standardowe wyjście. Podobnie jak w przypadku standardowego wyjścia standardowy strumień błędów jest domyślnie wysyłany na ekran. Z tego powodu w praktyce może być trudno rozpoznać, z którego strumienia pochodzą dane informacje, przynajmniej dopóty, dopóki nie przekierujesz jednego ze strumieni na przykład do pliku. W tej sekcji omówimy składnię poleceń wykorzystywaną przez powłokę bash do przekierowywania standardowego strumienia błędów oraz do odróżniania standardowego wyjścia od standardowego strumienia błędów. Jeżeli używasz powłoki tcsh odpowiednie informacje znajdziesz w rozdziale 9.

300  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Deskryptor pliku (ang. file descriptor) to miejsce, do którego program wysyła wyniki swojego działania i z którego pobiera dane. Kiedy uruchamiasz jakiś program, system Linux otwiera dla niego trzy deskryptory plików: 0 (standardowe wejście), 1 (standardowe wyjście) oraz 2 (standardowy strumień błędów). Symbol przekierowania > jest synonimem tokena 1>, który powoduje przekierowanie standardowego wyjścia. Podobnie symbol < jest synonimem tokena 0 powoduje przekierowanie standardowego strumienia błędów. Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Deskryptory plików” w rozdziale 10.

Deskryptory plików

Przykłady przedstawione poniżej ilustrują sposób przekierowania standardowego wyjścia i standardowego wejścia do różnych plików i do tego samego pliku. Kiedy uruchomisz polecenie cat z nazwą pliku, który nie istnieje, i z nazwą pliku istniejącego, cat wyśle komunikat o błędzie do standardowego strumienia błędów i skopiuje zawartość istniejącego pliku na standardowe wyjście. Jeżeli któryś ze strumieni (lub oba) nie zostanie przekierowany, oba komunikaty pojawią się na ekranie. $ cat y To jest $ cat x cat: x: $ cat x cat: x: To jest

plik y. Nie ma takiego pliku ani katalogu y Nie ma takiego pliku ani katalogu plik y.

Kiedy przekierujesz standardowe wyjście polecenia do pliku, nie ma to wpływu na standardowy strumień błędów, stąd komunikaty o błędach nadal pojawiają się na ekranie: $ cat x y > pliktxt cat: x: Nie ma takiego pliku ani katalogu $ cat pliktxt To jest plik y.

Podobnie kiedy wysyłasz standardowe wyjście do potoku, nie ma to wpływu na standardowy strumień błędów. W przykładzie przedstawionym poniżej standardowe wyjście polecenia cat jest przesyłane za pomocą potoku do polecenia tr (patrz część VI książki), które w naszym przykładzie zamienia wszystkie małe litery na wielkie (więcej szczegółowych informacji na temat polecenia tr znajdziesz na stronach podręcznika info). Komunikaty o błędach wysyłane do standardowego strumienia błędów nie są modyfikowane, ponieważ są przesyłane bezpośrednio na ekran, a nie do potoku danych. $ cat x y | tr "[a-z]" "[A-Z]" cat: x: Nie ma takiego pliku ani katalogu TO JEST PLIK Y.

W kolejnym przykładzie dokonujemy przekierowania standardowego wyjścia i standardowego strumienia błędów do różnych plików. Nazwa pliku po tokenie 2> określa miejsce (plik), do którego powłoka przekieruje dane ze standardowego strumienia błędów (deskryptor numer 2 pliku). Nazwa pliku po tokenie 1> określa miejsce (plik), do którego powłoka przekieruje dane ze standardowego wyjścia (deskryptor numer 1 pliku). Zamiast tokena 1> możesz użyć symbolu >. $ cat x y 1> plik1 2> plik2 $ cat plik1 To jest plik y. $ cat plik2 cat: x: Nie ma takiego pliku ani katalogu

W następnym przykładzie token &> powoduje przekierowanie standardowego wyjścia i standardowego strumienia błędów do jednego pliku. W powłoce tcsh token >& działa spełnia dokładnie tę samą funkcję.

Łączenie standardowego wyjścia i standardowego strumienia błędów

Przekierowywanie standardowego strumienia błędów  301

$ cat x y &> plik $ cat plik cat: x: Nie ma takiegio pliku ani katalogu To jest plik y.

W kolejnym przykładzie pierwszy token 1> powoduje przekierowanie standardowego wyjścia do pliku o nazwie plik, a następny token, 2>&1 deklaruje, że deskryptor numer 2 pliku jest duplikatem deskryptora numer 1 tego pliku. W rezultacie takiego polecenia zarówno standardowe wyjście, jak i standardowy strumień błędów są przekierowywane do pliku o nazwie plik.

Duplikowanie deskryptora pliku

$ cat x y 1> plik 2>&1 $ cat plik cat: x: Nie ma takiego pliku ani katalogu To jest plik y.

W tym przykładzie token 1> poprzedza token 2>&1. Gdyby kolejność występowania tokenów była odwrotna, standardowy strumień błędów zostałby duplikatem standardowego wyjścia jeszcze przed przekierowaniem standardowego wyjścia do pliku. W takiej sytuacji w pliku zapisywane byłyby tylko dane przesyłane ze standardowego wyjścia polecenia. W kolejnym przykładzie deklarujemy, że deskryptor numer 2 naszego pliku będzie duplikatem deskryptora numer 1, i wysyłamy dane z wyjścia deskryptora 1 poprzez potok do polecenia tr.

Wysyłanie komunikatów o błędach poprzez standardowy strumień błędów

$ cat x y 2>&1 | tr "[a-z]" "[A-Z]" CAT: X: NIE MA TAKIEGO PLIKU ANI KATALOGU TO JEST PLIK Y.

Token |& jest skróconą wersją 2>&1 |: $ cat x y |& tr "[a-z]" "[A-Z]" CAT: X: NIE MA TAKIEGO PLIKU ANI KATALOGU TO JEST PLIK Y.

W razie potrzeby możesz użyć tokena 1>&2 (lub po prostu >&2, 1 nie jest wymagana) do przekierowania standardowego wyjścia polecenia do standardowego strumienia błędów. Skrypty powłoki często używają tej techniki do wysyłania wyników działania polecenia echo do standardowego strumienia błędów. W skrypcie zamieszczonym poniżej standardowe wyjście pierwszego polecenia echo zostaje przekierowane do standardowego strumienia błędów:

Wysyłanie komunikatów o błędach do standardowego strumienia błędów

$ cat demo_komunikatu echo To jest komunikat o wystąpieniu błędu. 1>&2 echo To nie jest komunikat o wystąpieniu błędu.

Jeżeli przekierujesz standardowe wyjście skryptu demo_komunikatu, komunikaty o błędach, takie jak ten wygenerowany przez pierwsze polecenie echo, pojawiają się na ekranie, ponieważ nie dokonałeś przekierowania standardowego strumienia błędów. Ponieważ standardowe wyjście skryptów powłoki jest bardzo często przekierowywane do pliku, możesz użyć tej techniki do wyświetlania na ekranie dowolnych komunikatów o wystąpieniu błędu, generowanych przez Twój skrypt. Technika ta jest również wykorzystywana przez skrypt lnks, który opisujemy w rozdziale 10. Wbudowanego polecenia exec możesz użyć do utworzenia dodatkowych deskryptorów pliku i przekierowania standardowego wejścia, standardowego wyjścia i standardowego strumienia błędów skryptu powłoki z poziomu tego samego skryptu (patrz rozdział 10.). W tabeli 8.2 zamieszczono zestawienie operatorów przekierowania, które są obsługiwane przez powłokę bash.

302  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Tabela 8.2. Operatory przekierowania Operator

Znaczenie

< nazwa_pliku

Przekierowuje standardowe wejście do pobierania danych z pliku nazwa_pliku.

> nazwa_pliku

Przekierowuje standardowe wyjście do pliku nazwa_pliku, chyba że taki plik już istnieje i jest włączona opcja noclobber (patrz rozdział 5.). Jeżeli opcja noclobber nie jest włączona, użycie takiego przekierowania powoduje utworzenie pliku nazwa_pliku (jeżeli wcześniej nie istniał) lub nadpisanie jego zawartości (jeżeli już wcześniej istniał).

>! nazwa_pliku

Przekierowuje standardowe wyjście do pliku nazwa_pliku, nawet jeżeli taki plik już istnieje i opcja noclobber (patrz rozdział 5.) jest włączona.

>> nazwa_pliku

Przekierowuje standardowe wyjście i dołącza dane do pliku o nazwie nazwa_pliku. Jeżeli plik o takiej nazwie nie istnieje, zostanie utworzony.

&> nazwa_pliku

Przekierowuje standardowe wyjście i standardowy strumień błędów do pliku o nazwie nazwa_pliku.

&m

Tworzy duplikat standardowego wyjścia lub deskryptora numer n z deskryptora numer m (patrz rozdział 10.).

[n]&-

Zamyka standardowe wyjście lub podany deskryptor numer n (jeżeli został podany).

TWORZENIE I URUCHAMIANIE PROSTYCH SKRYPTÓW POWŁOKI Skrypt powłoki (ang. shell script) to plik przechowujący sekwencje poleceń, które mogą być wykonane przez powłokę. Polecenia zapisane w skrypcie powłoki mogą być dowolnymi poleceniami, które wprowadzasz w wierszu poleceń powłoki. Na przykład polecenia ze skryptów powłoki mogą uruchamiać wybrane narzędzia systemu Linux, skompilowany program czy wywoływać inne skrypty powłoki. Podobnie jak polecenia wywoływane z wiersza poleceń polecenia umieszczane w skryptach mogą używać wieloznacznych odwołań do plików, a ich standardowe wejście, wyjście i strumień błędów mogą być przekierowywane. Potoków i przekierowań możesz również używać do modyfikacji wejścia i wyjścia samego skryptu. Oprócz poleceń, których normalnie używasz w wierszu poleceń, bardzo często w skryptach możesz spotkać polecenia kontrolujące przepływ sterowania (ang. control flow command), zwane również strukturami sterującymi (ang. control structures). Jest to grupa poleceń, która pozwala Ci na modyfikowanie kolejności wykonywania poleceń w skrypcie w taki sam sposób, w jaki zmieniasz kolejność wykonywania poleceń w dowolnym, strukturalnym języku programowania. Więcej szczegółowych informacji na ten temat znajdziesz w podrozdziałach „Struktury sterujące” w rozdziałach 9. i 10. Powłoka interpretuje i wykonuje polecenia ze skryptu jedno po drugim. Dzięki takiemu rozwiązaniu możesz użyć skryptów powłoki do prostego i szybkiego wykonania serii złożonych zadań lub realizacji często powtarzających się zadań.

POLECENIE CHMOD — TWORZENIE PLIKÓW WYKONYWALNYCH Aby wykonać skrypt powłoki poprzez wpisanie jego nazwy jako nazwy polecenia do uruchomienia, musisz mieć odpowiednie prawa do odczytu i wykonania pliku zawierającego skrypt (patrz sekcja „Prawa dostępu” w rozdziale 4.). Prawo odczytu pozwala na odczytanie zawartości pliku przechowującego skrypt. Prawo do wykonania pliku informuje powłokę i system, że właściciel, grupa i (lub) pozostali użytkownicy mają odpowiednie uprawnienia do wykonania pliku — jednocześnie oznacza to, że zawartość takiego pliku jest wykonywalna.

Tworzenie i uruchamianie prostych skryptów powłoki  303

Kiedy przy użyciu edytora tekstu tworzysz skrypt powłoki, to plik, w którym skrypt jest zapisany, zazwyczaj nie posiada jeszcze praw do wykonania (inaczej mówiąc, nie jest oznaczony jako plik wykonywalny). Na poniższym przykładzie przedstawiono plik o nazwie whoson, który zawiera skrypt powłoki: $ cat whoson date echo "Lista aktualnie zalogowanych użytkowników:" who $ ./whoson bash: ./whoson: Brak dostępu

Jak widać, nie możesz wykonać pliku whoson poprzez użycie jego nazwy jako nazwy polecenia, ponieważ nie posiadasz prawa wykonywania tego pliku. Powłoka nie rozpoznaje pliku whoson jako pliku wykonywalnego i przy próbie uruchomienia pliku wyświetla na ekranie komunikat Brak dostępu (jeżeli próba wykonania tego pliku zakończy się wyświetleniem komunikatu nie odnaleziono polecenia..., powinieneś zajrzeć do wskazówki na następnej stronie). Jeżeli nazwę pliku podasz jako argument dla polecenia bash (bash whoson), powłoka bash przyjmie, że argument jest skryptem powłoki, i wykona go. W takiej sytuacji to bash jest poleceniem wykonywalnym, a whoson jest argumentem wykonywanym przez polecenie bash, stąd prawo wykonywania pliku whoson nie jest tutaj potrzebne — musisz jednak posiadać prawo odczytu tego pliku. Polecenie chmod pozwala na zmianę praw dostępu do pliku. Na rysunku 8.1 przedstawiono wyniki działania polecenia ls, które wyświetla prawa dostępu do pliku whoson przed i po nadaniu za pomocą polecenia chmod prawa wykonania pliku jego właścicielowi. $ ls -l whoson -rw-rw-r--. 1 kuba pubs 40 05-24 11:30 whoson $ chmod u+x whoson $ ls -l whoson -rwxrw-r--. 1 kuba pubs 40 05-24 11:30 whoson $ ./whoson śro, 25 maj 2011 11:40:49 CET Lista aktualnie zalogowanych użytkowników: dawid pts/7 2011-05-23 18:17 hls pts/1 2011-05-24 09:59 mateusz pts/12 2011-05-24 06:29 (jupiter) kuba pts/4 2011-05-24 09:08

Rysunek 8.1. Zastosowanie polecenia chmod do utworzenia wykonywalnego skryptu powłoki

Pierwsze polecenie ls na czwartej pozycji listy praw wyświetla znak (-), co wskazuje, że właściciel pliku nie ma prawa jego wykonania. Kolejne polecenie chmod nadaje właścicielowi takie prawo: argument u+x powoduje, że polecenie chmod dodaje (+) prawo wykonania (x) właścicielowi pliku (u) (jak pamiętasz, w terminologii polecenia chmod litera u (ang. user; użytkownik) oznacza tutaj właściciela pliku). Drugim argumentem tego polecenia jest nazwa pliku. Kolejne polecenie ls na czwartej pozycji listy praw wyświetla już znak x, co wskazuje, że właściciel pliku ma prawo jego wykonania.

WSKAZÓWKA Nie odnaleziono polecenia? Jeżeli użyjesz nazwy skryptu jako nazwy polecenia, ale nie poprzedzisz jej ciągiem znaków ./, powłoka w większości przypadków wyświetli na ekranie następujący komunikat o wystąpieniu błędu: $ whoson bash: whoson: nie odnaleziono polecenia...

Pojawienie się takiego komunikatu oznacza, że powłoka nie jest skonfigurowana do poszukiwania plików wykonywalnych w bieżącym katalogu roboczym. Zamiast samej nazwy skryptu spróbuj wpisać następujące polecenie:

304  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) $ ./whoson

Użycie ciągu znaków ./ informuje powłokę, że powinna poszukać pliku wykonywalnego w bieżącym katalogu roboczym. W razie potrzeby możesz również zmienić ustawienia środowiska tak, aby powłoka automatycznie poszukiwała plików wykonywalnych w bieżącym katalogu roboczym, aczkolwiek z punktu widzenia bezpieczeństwa systemu takie rozwiązanie zdecydowanie nie jest polecane (patrz sekcja „Zmienna PATH, czyli gdzie powłoka szuka programów” w dalszej części tego rozdziału). Jeżeli inni użytkownicy też mają korzystać z danego skryptu, musisz również zmienić prawa dostępu do pliku dla grupy i pozostałych użytkowników. Aby mieć możliwość uruchomienia pliku (użycia jego nazwy jako nazwy polecenia), każdy użytkownik musi posiadać prawo wykonania takiego pliku. Jeżeli dany plik jest skryptem powłoki, użytkownik próbujący go uruchomić musi dodatkowo posiadać prawo odczytu tego pliku. Do uruchamiania binarnych plików wykonywalnych (skompilowanych programów) nie musisz posiadać prawa odczytu. Kilka ostatnich wierszy na rysunku 8.1 przedstawia wyniki działania skryptu whoson po wykonaniu go przez powłokę (kiedy nazwa skryptu została użyta jako nazwa polecenia). Więcej szczegółowych informacji na temat praw dostępu oraz poleceń ls i chmod znajdziesz w sekcji „Prawa dostępu” w rozdziale 4., a także w części VI książki.

ZNAKI #! DEFINIUJĄ TYP POWŁOKI W pierwszym wierszu skryptu powłoki możesz wstawić specjalną sekwencję znaków, która poinformuje system operacyjny, która powłoka (lub inny program) powinien wykonać dany plik. Ponieważ system operacyjny sprawdza początkowe znaki (bajty) pliku (sprawdzenie sygnatury) przed próbą uruchomienia go za pomocą polecenia exec, to ich sprawdzenie zapobiega nieudanej próbie uruchomienia programu. Jeżeli pierwsze dwa znaki skryptu to #!, system interpretuje pozostałe znaki tego wiersza jako bezwzględną ścieżkę do programu, który powinien wykonać dany skrypt. Taka ścieżka może wskazywać na dowolny program, a nie tylko na powłokę. Takie rozwiązanie może być użyteczne w sytuacji, kiedy dany skrypt powinien być wykonany przez inną powłokę niż powłoka, z której zostaje wywołany. Na poniższym przykładzie przedstawiono skrypt, który powinien być wykonany przez powłokę bash: $ cat bash_script #!/bin/bash echo "To jest skrypt przeznaczony dla powłoki Bourne Again Shell."

WSKAZÓWKA Dzięki opcjom -e i -u powłoki bash Twoje programy będą mniej wybredne W powłoce bash opcja -e (errexit) powoduje zamknięcie powłoki, gdy działanie prostego polecenia (na przykład innego niż struktura sterująca) zakończy się niepowodzeniem. Z kolei opcja -u (nounset) w powłoce bash powoduje wyświetlenie komunikatu błędu i zamknięcie powłoki, gdy program próbuje rozwinąć nieustawioną zmienną. Więcej informacji na ten temat znajdziesz w tabeli 8.13. Wymienione opcje można bardzo łatwo włączyć w wierszu #! skryptu powłoki bash: #!/bin/bash -eu

Przedstawione powyżej opcje chronią Cię przed katastrofą, gdy w skrypcie popełnisz błąd, np. taki jak przedstawiono poniżej: MYDIR=/tmp/$$ cd $MYDIr; rm - rf .

W trakcie pracy możesz również użyć opcji -x w wierszu #!, włączając tym samym tryb debugowania. Skrypt przedstawiony w kolejnym przykładzie powinien być uruchamiany przez interpreter języka Perl. Dzięki opisanemu powyżej rozwiązaniu możemy uruchomić taki skrypt bezpośrednio z poziomu powłoki, bez konieczności bezpośredniego wywoływania interpretera języka z wiersza poleceń:

Tworzenie i uruchamianie prostych skryptów powłoki  305

$ cat ./perl_script.pl #!/usr/bin/perl -w print "To jest skrypt w języku Perl.\n"; $ ./perl_script.pl To jest skrypt w języku Perl

W kolejnym przykładzie przedstawiamy skrypt, który powinien być wykonywany przez powłokę tcsh: $ cat tcsh_script #!/bin/tcsh echo "To jest skrypt powłoki tcsh." set person = dawid echo "Wybrany użytkownik to $person"

Ze względu na obecność wiersza #! system operacyjny wybierze do uruchomienia tego skryptu powłokę tcsh, niezależnie od tego, z jakiej powłoki ten skrypt zostanie wywołany. Wewnątrz skryptu możesz użyć polecenia ps -f do wyświetlenia nazwy programu wykonującego ten skrypt. Trzy wiersze wyników działania polecenia ps pokazują proces związany z nadrzędną powłoką bash, proces, w którym działa skrypt tcsh, oraz proces, w którym działa samo polecenie ps. $ cat tcsh_script2 #!/bin/tcsh ps -f $ ./tcsh_script2 UID PID PPID kuba 3031 3030 kuba 9358 3031 kuba 9375 9358

C 0 0 0

STIME Nov16 21:13 21:13

TTY pts/4 pts/4 pts/4

TIME 00:00:00 00:00:00 00:00:00

CMD -bash /bin/tcsh ./tcsh_script2 ps -f

Jeżeli po ciągu znaków #! nie umieścisz nazwy programu wykonywalnego, powłoka wyświetli komunikat o błędzie informujący, że nie może odnaleźć programu, który chcesz uruchomić. Po ciągu znaków #! możesz użyć również spacji. Jeżeli w skrypcie na przykład przeznaczonym dla powłoki tcsh pominiesz wiersz #! i spróbujesz go uruchomić z poziomu powłoki bash, to skrypt zostanie wykonany, ale może wyświetlać komunikaty o wystąpieniu błędów lub po prostu nie działać poprawnie. Przykład samodzielnego skryptu sed używającego #! przedstawiono w rozdziale 15.

ZNAK # OZNACZA POCZĄTEK KOMENTARZA Użycie komentarzy powoduje, że kod źródłowy skryptu powłoki jest bardziej czytelny i łatwiejszy do zarządzania i modyfikacji zarówno przez autora, jak i innych użytkowników. Składnia komentarzy jest taka sama w powłokach Bourne Again Shell i TC Shell. Jeżeli znak # jest pierwszym znakiem wiersza i bezpośrednio po nim nie występuje znak wykrzyknika (!) lub jeżeli znak # występuje w dowolnym innym miejscu skryptu, powłoka interpretuje to miejsce jako początek komentarza i ignoruje wszystkie pozostałe znaki znajdujące się pomiędzy znakiem # a końcem wiersza.

WYKONYWANIE SKRYPTÓW POWŁOKI Jak już wspominaliśmy wcześniej, możesz uruchomić skrypt powłoki, do którego nie masz prawa wykonania, wykorzystując polecenie bash, które otworzy nową powłokę i bezpośrednio w niej wykona skrypt. W przykładzie poniżej polecenie bash uruchamia nową powłokę, która odczytuje dane z pliku whoson:

Funkcje systemowe fork i exec

$ bash whoson

306  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Ponieważ polecenie bash zakłada, że będzie odczytywało dane z pliku zawierającego polecenia, nie musisz posiadać prawa wykonania pliku whoson (aczkolwiek musisz mieć prawo odczytu tego pliku). Pomimo iż polecenie bash odczytuje i wykonuje polecenia z pliku whoson, standardowe wejście, standardowe wyjście i standardowy strumień błędów pobierają dane z i wysyłają do terminala. Alternatywnym rozwiązaniem jest dostarczenie powłoce bash poleceń poprzez standardowe wejście: $ bash < whoson

Chociaż możesz użyć polecenia bash do wykonania skryptu powłoki, taki sposób uruchomienia powoduje, że skrypt działa znacznie wolniej niż w przypadku, kiedy posiadasz prawo wykonania i uruchamiasz skrypt bezpośrednio z wiersza poleceń. Z tego powodu użytkownicy zazwyczaj wolą nadać plikowi prawo wykonania i uruchamiać go, wpisując po prostu nazwę skryptu w wierszu poleceń. Takie rozwiązanie jest proste, a co najważniejsze, spójne ze sposobem uruchamiania innych rodzajów programów (nie musisz pamiętać, czy uruchamiasz skrypt powłoki, czy binarny plik wykonywalny). Z drugiej strony, jeżeli bash nie jest Twoją powłoką interaktywną lub chcesz sprawdzić, jak dany skrypt działa z innymi powłokami, możesz spróbować uruchomić go, podając jego nazwę jako argument polecenia, na przykład bash czy tcsh.

OSTRZEŻENIE Polecenie sh nie wywołuje oryginalnej powłoki Bourne Shell Oryginalna powłoka Bourne Shell była wywoływana poleceniem sh. Choć obecnie możesz z poziomu powłoki bash wykonać polecenie sh, to jednak nie będzie to oryginalna powłoka Bourne Shell. Polecenie sh (/bin/sh) jest dowiązaniem symbolicznym do /bin/bash lub /bin/dash, czyli inaczej mówiąc, jest to po prostu inna nazwa dla polecenia bash lub dash. Kiedy wywołujesz powłokę bash przy użyciu polecenia sh, powłoka bash stara się dokładnie naśladować zachowanie powłoki Bourne Shell, aczkolwiek nie zawsze się to udaje.

OPERATORY STERUJĄCE — SEPARACJA I GRUPOWANIE POLECEŃ Kiedy wpisujesz kolejne polecenia w interaktywnej sesji powłoki czy tworzysz nowy skrypt powłoki, musisz oddzielać od siebie poszczególne polecenia. W tej sekcji powrócimy do sposobów separowania poleceń opisywanych w rozdziale 7., a także przedstawimy kilka nowych metod. Materiał dotyczy powłok Bourne Again Shell i TC Shell. Tokeny oddzielające, kończące i grupujące polecenia są nazywane operatorami sterującymi. Każdy operator sterujący zapewnia kontynuację wykonywania wiersza, co dokładnie omówiono w rozdziale 10. Poniżej przedstawiono listę operatorów sterujących omówionych w tym rozdziale:  ; — znak oddzielenia poleceń,  znak nowego wiersza,  & — zadanie działające w tle,  | — potokowanie,  |& — standardowy potok błędów,  () — grupowanie poleceń,  || — logiczne OR,  && — logiczne AND,  ;; — przerwanie bloku (zobacz rozdział 10.).

Operatory sterujące — separacja i grupowanie poleceń  307

ZNAK ŚREDNIKA I ZNAK NOWEGO WIERSZA ODDZIELAJĄ POLECENIA Znak nowego wiersza (ang. NEWLINE) jest unikatowym separatorem poleceń, ponieważ jego wstawienie jednocześnie rozpoczyna wykonywanie wpisanego przed nim polecenia. Z takim zachowaniem spotykałeś się za każdym razem, kiedy na końcu wiersza poleceń naciskałeś klawisz Enter. Znak średnika (;) jest separatorem poleceń, który nie rozpoczyna wykonania polecenia oraz nie zmienia żadnego aspektu funkcjonowania poleceń. Możesz wykonać kolejno całą serię poleceń, wpisując je jedno po drugim w wierszu polecenia i oddzielając je od siebie średnikami (;). Aby rozpocząć wykonywanie takiej serii poleceń, musisz nacisnąć klawisz Enter: $ x ; y ; z

Jeżeli x, y oraz z są poleceniami, to powyższe polecenie będzie miało dokładnie taki sam rezultat jak trzy polecenia przedstawione poniżej. Różnica polega na tym, że w poniższym przykładzie powłoka po wykonaniu każdego z poleceń (x, y oraz z) będzie wyświetlała znak zachęty i oczekiwała na wpisanie kolejnego polecenia, podczas gdy wpisanie tych trzech poleceń oddzielonych od siebie średnikami spowoduje wyświetlenie znaku zachęty dopiero po wykonaniu ostatniego polecenia (z): $ x $ y $ z

Choć wstawianie odstępów pomiędzy średnikami we wcześniejszym przykładzie nie jest konieczne, to taki sposób zapisu powoduje, że sekwencja poleceń jest znacznie bardziej przejrzysta i czytelna. Żaden separator poleceń nie musi być otoczony znakami spacji czy tabulacji.

Białe znaki

ZNAKI | ORAZ & — ODSEPARUJ POLECENIA I ZRÓB COŚ JESZCZE… Znak potoku (|) oraz symbol zadania drugoplanowego (&) również są separatorami poleceń. Oba znaki nie rozpoczynają wykonywania polecenia, ale zmieniają niektóre aspekty funkcjonowania poleceń. Znak potoku zmienia źródło danych napływających na standardowe wejście polecenia lub przeznaczenie strumienia danych wypływających ze standardowego wyjścia. Użycie symbolu zadania drugoplanowego powoduje, że powłoka uruchamia zadanie w tle i natychmiast wyświetla znak zachęty — dzięki temu możesz od razu wykonywać inne polecenia. Każdy z wierszy przedstawionych poniżej rozpoczyna wykonywanie zadania składającego się z trzech poleceń: $ x | y | z $ ls -l | grep tmp | less

W pierwszym wierszu powłoka przekierowuje standardowe wyjście polecenia x na standardowe wejście polecenia y oraz standardowe wyjście polecenia y na standardowe wejście polecenia z. Ponieważ całe zadanie zostaje uruchomione na pierwszym planie, powłoka nie będzie wyświetlała znaku zachęty aż do zakończenia działania polecenia z — inaczej mówiąc, polecenie z nie zakończy działania dopóty, dopóki nie zakończy działania polecenie y, a polecenie y nie zakończy działania, dopóki działać będzie polecenie x. W drugim wierszu rolę polecenia x spełnia ls -l, polecenie y to grep tmp, a polecenie z to komenda stronicująca less. Po uruchomieniu powłoka wyświetli pełną listę plików znajdujących się w bieżącym katalogu roboczym, których nazwy zawierają ciąg znaków tmp. Wyniki działania tych poleceń zostaną za pomocą potoku przesłane do polecenia less, które wyświetli je ekran po ekranie. W kolejnym przykładzie mamy listę wykonującą proste polecenia: w tle, a polecenie f na pierwszym planie: $ d & e & f [1] 14271 [2] 14272

d

oraz

e

zostają uruchomione

308  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Dla każdego procesu działającego w tle powłoka wyświetla numer zadania (w nawiasach kwadratowych) oraz identyfikator PID. Znak zachęty zostanie wyświetlony natychmiast po zakończeniu działania polecenia f, co może nastąpić jeszcze przed zakończeniem działania poleceń d i (lub) e. Przed wyświetleniem kolejnego znaku zachęty powłoka sprawdza, czy któreś z zadań drugoplanowych zakończyło działanie. Dla każdego zakończonego zadania powłoka wyświetla jego numer zadania, słowo Done oraz wiersz polecenia, za pomocą którego to zadanie zostało uruchomione. Kiedy wyświetlana jest lista kilku zakończonych zadań, po numerze ostatnio uruchomionego zadania wyświetlany jest znak (+), a po numerze poprzedniego zadania znak (-). Po numerach wszystkich wcześniejszych zadań wyświetlana jest spacja. Po wykonaniu ostatniego zadania (f) powłoka przed wyświetleniem znaku zachęty wyświetla następujące wiersze: [1]- Done [2]+ Done

d e

Kolejny wiersz poleceń powoduje uruchomienie wszystkich trzech zadań jako procesów drugoplanowych (działających w tle). Po naciśnięciu klawisza Enter powłoka uruchamia zadania i natychmiast wyświetla znak zachęty. $ d [1] [2] [3]

& e & f & 14290 14291 14292

Możesz użyć symbolu potoku do przekierowania wyjścia z jednego polecenia na wejście drugiego polecenia oraz znaku & na końcu wiersza do uruchomienia całego zadania w tle. I znów po uruchomieniu zadania powłoka natychmiast wyświetli nowy znak zachęty. Poszczególne polecenia powłoki połączone potokami tworzą jedno złożone zadanie. Polecenia połączone potokami traktowane są jako jedno zadanie niezależnie od tego, ile poleceń jest potokowanych ani jak bardzo są złożone. Po uruchomieniu takiego zadania powłoka bash zgłasza tylko jeden proces działający w tle (choć złożony jest z trzech poleceń): $ d | e | f & [1] 14295

Z kolei powłoka tcsh zgłasza trzy procesy działające w tle (choć wszystkie należą do zadania 1): tcsh $ d | e | f & [1] 14302 14304 14306

OPERATORY && I || Operatory boolowskie && (AND) i || (OR) są nazywane operatorami sterującymi typu short-circuiting. Jeżeli wynik użycia jednego z tych operatorów może być określony poprzez analizę tylko lewego operandu, prawy operand nie będzie sprawdzany. Wynikiem działania operatora boolowskiego jest 0 (true) lub 1 (false). Operator && powoduje, że powłoka sprawdza wartość kodu wyjścia polecenia poprzedzającego dany operator. Jeżeli wykonanie polecenia zakończy się powodzeniem, powłoka bash wykonuje kolejne polecenie. Natomiast jeśli wykonanie polecenia zakończyło się niepowodzeniem, następuje pominięcie kolejnego. Tę konstrukcję można wykorzystać do warunkowego wykonywania poleceń.

&&

$ mkdir bkup && cp -r src bkup

Powyższe polecenie powoduje utworzenie katalogu bkup. Jeżeli działanie polecenia mkdir zakończy się powodzeniem, zawartość katalogu src będzie rekurencyjnie skopiowana do katalogu bkup. ||

Operator sterujący || również powoduje, że powłoka bash sprawdza kod wyjścia poprzedniego polecenia. Jednak efekt sprawdzenia jest zupełnie przeciwny do efektu w operatorze && — pozostałe polecenia się wykonywane tylko wtedy, gdy wykonanie pierwszego zakończy się niepowodzeniem (czyli kod wyjścia będzie miał wartość inną niż zero). $ mkdir bkup || echo "mkdir of bkup failed" >> /tmp/log

Operatory sterujące — separacja i grupowanie poleceń  309

Kod wyjścia listy poleceń przyjmuje wartość kodu wyjścia ostatniego polecenia listy. Istnieje możliwość grupowania poleceń za pomocą nawiasów. Na przykład przedstawione wcześniej dwa polecenia można zgrupować w jedno: $ (mkdir bkup && cp -r src bkup) || echo "mkdir failed" >> /tmp/log

W przypadku braku nawiasów operatory && i || mają takie samo pierwszeństwo, a grupowanie następuje od lewej do prawej strony. Przedstawione przykłady używają narzędzi true i false, które jedynie zwracają wartość odpowiednio true (0) i false (1) dla kodu wyjścia: $ false; echo $? 1

Zmienna $? przechowuje kod wyjścia poprzedniego polecenia. Kolejne dwa polecenia mają wartość 1 (false) kodu wyjścia: $ $ 1 $ $ 1

true || false && false echo $? (true || false) && false echo $?

Podobnie dwa kolejne polecenia mają wartość 0 (true) kodu wyjścia: $ $ 0 $ $ 0

false && false || true echo $? (false && false) || true echo $?

Więcej przykładów znajdziesz w rozdziale 5.

INFORMACJE DODATKOWE GRUPOWANIE POLECEŃ Do grupowania poleceń możesz użyć nawiasów okrągłych. Dla każdej grupy poleceń powłoka utworzy swoją kopię, nazywaną podpowłoką (ang. subshell). Powłoka traktuje każdą grupę jako osobne zadanie i tworzy dla niej osobny proces (więcej szczegółowych informacji na temat tworzenia podpowłok znajdziesz w sekcji „Struktura procesu” w dalszej części tego rozdziału). Każda podpowłoka (zadanie) posiada swoje własne środowisko, co oznacza, że posiada również swój własny zestaw zmiennych, których wartości mogą się różnić od wartości zmiennych w innych podpowłokach. Wiersz polecenia przedstawiony poniżej powoduje, że polecenia a i b są wykonywane w tle jedno po drugim jako jedno zadanie, a równolegle polecenie c jest wykonywane w tle jako osobne zadanie. Po uruchomieniu zadań powłoka natychmiast wyświetla znak zachęty. $ (a ; b) & c & [1] 15520 [2] 15521

Różnica w stosunku do poprzedniego polecenia d & e & f & polega na tym, że polecenia a i b są wykonywane sekwencyjnie, a nie równolegle. Kolejny wiersz poleceń, przedstawiony poniżej, powoduje, że polecenia a i b są wykonywane sekwencyjnie w tle jako jedno zadanie i równolegle w tym samym czasie polecenia c i d są również wykonywane w tle jako kolejne zadanie. Jedna podpowłoka wykonuje polecenia a i b (pierwsze zadanie), a druga podpowłoka polecenia c i d (drugie zadanie). Po uruchomieniu zadań powłoka od razu wyświetla znak zachęty. $ (a ; b) & (c ; d) & [1] 15528 [2] 15529

310  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

W następnym przykładzie przedstawiamy prosty skrypt, którego zadaniem jest kopiowanie zawartości jednego katalogu do drugiego. Druga para nawiasów tworzy podpowłokę, która wykonuje polecenia znajdujące się po znaku potoku. Właśnie ze względu na obecność tych nawiasów wyniki działania pierwszego polecenia tar są dostępne dla drugiego polecenia tar pomimo znajdującego się pomiędzy nimi polecenia cd. Jeżeli nawiasy nie zostałyby użyte, wyniki działania pierwszego polecenia tar zostałyby przesłane na wejście polecenia cd, co zakończyłoby się ich utratą, ponieważ polecenie cd nie przetwarza danych pojawiających się na jego standardowym wejściu. Zmienne powłoki $1 oraz $2 przechowują odpowiednio pierwszy i drugi argument wywołania skryptu. Pierwsza para nawiasów, która tworzy podpowłokę wykonującą pierwsze dwa polecenia, pozwala na wywołanie skryptu cpdir ze ścieżkami względnymi. Bez użycia nawiasów pierwsze polecenie cd zmieniłoby katalog roboczy skryptu (i w konsekwencji katalog roboczy drugiego polecenia cd). Dzięki zastosowaniu nawiasów zmieniany jest tylko katalog roboczy pierwszej podpowłoki. $ cat cpdir (cd $1 ; tar -cf - . ) | (cd $2 ; tar -xvf - ) $ ./cpdir /home/kuba/sources /home/kuba/memo/biblio

Wykonanie wiersza z poleceniem cpdir powoduje skopiowanie plików i katalogów znajdujących się w katalogu /home/max/sources do katalogu /home/max/memo/biblio. Działanie tego skryptu jest niemal identyczne jak działanie polecenia cp z opcją -r. Więcej szczegółowych informacji na ten temat znajdziesz w części VI książki.

ZNAK \ OZNACZA KONTYNUACJĘ WIERSZA POLECENIA Kiedy wprowadzasz długie polecenie i kursor zaczyna dochodzić do prawej krawędzi ekranu, możesz użyć znaku lewego ukośnika (\) do oznaczenia kontynuacji polecenia w kolejnym wierszu. Lewy ukośnik powoduje cytowanie następującego po nim znaku nowego wiersza, dzięki czemu powłoka nie interpretuje go jako znaku zakończenia polecenia. Ujęcie znaku lewego ukośnika w apostrofy lub poprzedzenie go jeszcze jednym znakiem lewego ukośnika „wyłącza” jego zdolność do cytowania znaków specjalnych, takich jak znak nowego wiersza (to nie dotyczy powłoki tcsh, patrz prompt2 w rozdziale 9.). Ujęcie znaku lewego ukośnika w cudzysłów w żaden sposób nie zmienia znaczenia tego znaku (to nie dotyczy powłoki tcsh). Co prawda nic nie stoi na przeszkodzie, aby „złamać” wiersz polecenia na przykład w połowie wyrazu (tokena), to jednak w praktyce łatwiej kontynuować polecenie w nowym wierszu przed lub po wybranym znaku spacji lub tabulatora.

INFORMACJE DODATKOWE Znak nowego wiersza (naciśnięcie klawisza Enter) możesz wstawić w dowolnym miejscu ujętego w cudzysłów ciągu znaków bez konieczności stosowania lewego ukośnika. (Zobacz prompt2 w rozdziale 9., aby przekonać się, jak to działa w powłoce tcsh). Tak wstawiony znak nowego wiersza będzie stanowił integralną część ciągu znaków: $ echo "Proszę wprowadzić trzy wartości > niezbędne do zakończenia transakcji." Proszę wprowadzić trzy wartości niezbędne do zakończenia transakcji.

W trzech przykładach przedstawionych w tej sekcji powłoka nie będzie interpretowała naciśnięcia klawisza Enter jako zakończenia polecenia, ponieważ będzie to miało miejsce wewnątrz cytowanego ciągu znaków. Znak większości (>) jest wtórnym znakiem zachęty (patrz sekcja „Zmienna PS2 — wtórny znak zachęty” w dalszej części tego rozdziału), wskazującym, że powłoka oczekuje na kontynuację wpisywania niedokończonego polecenia. W kolejnym przykładzie pierwsze naciśnięcie klawisza Enter jest cytowane, stąd powłoka traktuje znak Enter jako separator i nie interpretuje dosłownie. $ echo "Proszę wprowadzić trzy wartości \ > niezbędne do zakończenia transakcji." Proszę wprowadzić trzy wartości niezbędne do zakończenia transakcji.

Apostrofy powodują, że powłoka interpretuje znak lewego ukośnika w sposób dosłowny: $ echo 'Proszę wprowadzić trzy wartości \ > niezbędne do zakończenia transakcji.' Proszę wprowadzić trzy wartości \ niezbędne do zakończenia transakcji.

Sterowanie zadaniami  311

STEROWANIE ZADANIAMI Jak się dowiedziałeś w rozdziale 5., zadanie to inna nazwa dla procesu wykonującego potok (który może być prostym poleceniem). Wydając polecenie w powłoce, uruchamiasz jedno lub więcej zadań. Na przykład: jeżeli w wierszu poleceń wpiszesz polecenie date i naciśniesz klawisz Enter, to uruchamiasz nowe zadanie. Wpisując w wierszu poleceń kilka poleceń, możesz uruchomić jednocześnie kilka zadań rozdzielonych operatorami sterującymi (w omawianym przykładzie to &): $ find . -print | sort | lpr & grep -l max /tmp/* > maxfiles & [1] 18839 [2] 18876

Pierwsza część wiersza poleceń, aż do pierwszego znaku &, tworzy jedno zadanie składające się z trzech procesów połączonych potokami: find, sort oraz lpr. Drugie zadanie to pojedynczy proces wykonujący polecenie grep. Ostatni znak & powoduje uruchomienie poszczególnych zadań w tle, dzięki czemu powłoka bash nie czeka na ich zakończenie przed wyświetleniem znaku zachęty. Używając mechanizmu sterowania zadaniami, możesz przenosić zadania pracujące na pierwszym planie do pracy w tle i odwrotnie, tymczasowo zatrzymywać działające zadania i wyświetlać listę wszystkich zadań zatrzymanych oraz działających w tle.

POLECENIE JOBS — WYŚWIETLANIE LISTY ZADAŃ Wbudowane polecenie jobs wyświetla listę wszystkich zadań działających w tle. W przykładzie przedstawionym poniżej polecenie sleep działa w tle jako zadanie drugoplanowe, a informacje o nim zostają następnie wyświetlone przez polecenie jobs: $ sleep 60 & [1] 7809 $ jobs [1] + Running

sleep 60 &

POLECENIE FG — PRZENOSZENIE ZADANIA DO PRACY NA PIERWSZYM PLANIE Do każdego zadania uruchamianego do pracy w tle powłoka przypisuje odpowiedni numer zadania i przed wyświetleniem znaku zachęty wyświetla numer zadania oraz jego identyfikator PID na ekranie: $ gnome-calculator & [1] 1246 $ date & [2] 1247 $ śro, 7 gru 2011, 11:44:40 CET [2]+ Done date $ find /usr -name ace -print > findout & [2] 1269 $ jobs [1]- Running gnome-calculator & [2]+ Running find /usr -name ace -print > findout &

Numery przypisane do zadań, które zostały zakończone, wracają „do puli” i mogą być ponownie użyte do oznaczenia innych zadań. Kiedy uruchamiasz nowe zadanie w tle lub przenosisz do pracy w tle zadanie pierwszoplanowe, powłoka systemu przypisuje mu numer zadania o jeden większy niż najwyższy numer zadania będący aktualnie w użyciu. W poprzednim przykładzie polecenie jobs wyświetla pierwsze zadanie gnome-calculator jako zadanie numer 1. Polecenie date nie pojawia się na liście, ponieważ zakończyło działanie przed uruchomieniem polecenia jobs. Ponieważ polecenie date zakończyło działanie, zanim zostało uruchomione polecenie find, to polecenie find zostaje oznaczone jako zadanie numer 2.

312  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Aby przenieść zadanie pracujące w tle na pierwszy plan, powinieneś użyć polecenia fg, po którym następuje numer zadania. Zamiast tego polecenia możesz również w wierszu polecenia wpisać znak % i po nim podać numer zadania. Oba polecenia dają taki sam efekt — przenoszą zadanie drugoplanowe o podanym numerze na pierwszy plan. Kiedy przenosisz dane zadanie do pracy na pierwszym planie, powłoka wyświetla na ekranie wiersz polecenia użytego do uruchomienia tego zadania. $ fg 2 find /usr -name ace -print > findout

lub $ %2 find /usr -name ace -print > findout

Do zadania możesz się również odwoływać, wpisując znak % oraz ciąg znaków, który w unikatowy sposób identyfikuje początek wiersza polecenia użytego do utworzenia takiego zadania. Zamiast poleceń przedstawionych powyżej możesz użyć na przykład polecenia fg %find czy nawet fg %f, ponieważ oba ciągi znaków jednoznacznie identyfikują zadanie numer 2. Jeżeli po znaku % umieścisz znak zapytania, to następujący po nim ciąg znaków może zawierać dowolny fragment wiersza polecenia użytego do uruchomienia zadania. Na przykład użycie polecenia fg %?ace również spowoduje przeniesienie naszego zadania numer 2 do pracy na pierwszym planie. Często zadanie, które chcesz przenieść na pierwszy plan, jest jedynym zadaniem działającym w tle lub jest zadaniem, które polecenie jobs oznacza znakiem (+). W takiej sytuacji do przeniesienia tego zadania na pierwszy plan możesz użyć polecenia fg bez żadnych argumentów.

ZAWIESZANIE REALIZACJI ZADANIA Naciśnięcie klawisza zawieszenia zadania (zazwyczaj jest to Ctrl+Z) powoduje natychmiastowe zawieszenie (tymczasowe zatrzymanie) realizacji zadania działającego na pierwszym planie i wyświetlenie na ekranie informacji o zatrzymaniu: Ctrl+Z [2]+ Stopped

find /usr -name ace -print > findout

Więcej szczegółowych informacji na ten temat znajdziesz w sekcji „Przenoszenie zadania z pierwszego planu do pracy w tle” w rozdziale 5.

POLECENIE BG — PRZENOSZENIE ZADANIA DO PRACY W TLE Aby przenieść zadanie pierwszoplanowe do pracy w tle, musisz najpierw zawiesić jego działanie (patrz poprzednia sekcja), a następnie użyć polecenia bg do wznowienia realizacji tego zadania w tle. $ bg [2]+ find /usr -name ace -print > findout &

Jeżeli zadanie działające w tle będzie próbowało odczytywać dane z terminala, powłoka zatrzyma wykonywanie zadania i wyświetli na ekranie komunikat informujący, że realizacja zadania została zatrzymana. Następnie musisz przenieść takie zadanie do pracy na pierwszym planie i dopiero wtedy będzie ono mogło pobierać dane z terminala. $ (sleep 5; cat > mójtekst) & [1] 1343 $ date śro, 7 gru 2011, 11:58:20 CET [1]+ Stopped ( sleep 5; cat > mójtekst) $ fg ( sleep 5; cat > mójtekst ) Pamiętaj, aby wypuścić kota na podwórko! Ctrl+D $

Wykorzystanie stosu katalogów  313

Na powyższym przykładzie powłoka zaraz po uruchomieniu zadania wyświetla numer zadania oraz jego identyfikator PID, a następnie wyświetla znak zachęty. Aby udowodnić, że w tym momencie możesz już wykonywać inne polecenia, wpisujemy polecenie date i otrzymujemy na ekranie wyniki jego działania. Przed wyświetleniem znaku zachęty (ale już po zakończeniu działania polecenia date) powłoka wyświetla informację, że wykonywanie zadania 1 zostało zatrzymane. Kiedy wykonasz polecenie fg, powłoka przeniesie zadanie do pracy na pierwszym planie i będziesz mógł wpisać z klawiatury dane, na które oczekuje to polecenie. W naszym przypadku wpisywanie tekstu z klawiatury musisz zakończyć naciśnięciem kombinacji klawiszy Ctrl+D, która wyśle sygnał końca pliku (ang. EOF — End Of File) do polecenia cat. Następnie powłoka wyświetli na ekranie kolejny znak zachęty. Powłoka zawsze na bieżąco informuje Cię o zmianach statusu poszczególnych zadań, wyświetlając komunikaty o rozpoczęciu działania zadania drugoplanowego, zakończeniu takiego zadania oraz zatrzymaniu jego realizacji (na przykład kiedy zadanie oczekuje na wpisanie danych z terminala). Powłoka poinformuje Cię również, kiedy zawieszone zostanie zadanie działające na pierwszym planie. Ponieważ komunikaty o uruchamianiu zadań działających w tle mogą Ci przeszkadzać w wykonywaniu bieżących zadań, powłoka opóźnia wyświetlanie takich komunikatów aż do chwili tuż przed wyświetleniem kolejnego znaku zachęty. W razie potrzeby możesz jednak to zmienić za pomocą polecenia notify (więcej szczegółowych informacji na ten temat znajdziesz w dalszej części tego rozdziału), tak aby powłoka wyświetlała takie powiadomienia bez zwłoki. Jeżeli spróbujesz wyjść (za pomocą polecenia exit) z powłoki typu non-login, w której znajdują się zatrzymane zadania, powłoka wyświetli na ekranie odpowiednie ostrzeżenie i nie pozwoli Ci na wyjście. Jeżeli następnie wykonasz polecenie jobs lub ponownie wykonasz polecenie exit, to tym razem powłoka pozwoli Ci zakończyć sesję. Jeżeli opcja huponexit (więcej szczegółowych informacji na temat tej opcji znajdziesz w dalszej części tego rozdziału) nie jest włączona (ustawienie domyślne), to zatrzymane zadania pozostają zatrzymane, a zadania działające w tle nadal będą działać. Jeżeli jednak ta opcja jest włączona, powłoka zakończy takie zadania.

WYKORZYSTANIE STOSU KATALOGÓW Powłoki Bourne Again Shell (bash) i TC Shell (tcsh) pozwalają na przechowywanie listy katalogów, z którymi pracujesz, dzięki czemu możesz łatwo przechodzić od jednego katalogu do drugiego. Taka lista jest nazywana stosem katalogów (ang. directory stack). Działanie tego stosu przypomina nieco stos talerzy w kuchni — talerze zazwyczaj bierzemy z góry stosu i odkładamy również na górę. Taki rodzaj stosu jest nazywany LIFO (ang. Last In, First Out).

POLECENIE DIRS — WYŚWIETLANIE STOSU KATALOGÓW Wbudowane polecenie dirs wyświetla zawartość stosu katalogów. Jeżeli wywołasz to polecenie w sytuacji, kiedy stos katalogów jest pusty, to wyświetli ono nazwę bieżącego katalogu roboczego: $ dirs ~/literatura

Polecenie dirs używa znaku tyldy (~) do oznaczenia nazwy katalogu domowego użytkownika. Przykłady omawiane w kilku kolejnych sekcjach zakładają, że odwołujesz się do struktury katalogów przedstawionej na rysunku 8.2.

314  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

Rysunek 8.2. Struktura katalogów używana w przykładach

POLECENIE PUSHD — UMIESZCZENIE NAZWY KATALOGU NA STOSIE Kiedy wykonasz wbudowane polecenie pushd (ang. push directory) z jednym argumentem, to umieści ono nazwę katalogu będącego argumentem tego polecenia na stosie, zmieni bieżący katalog roboczy na katalog podany jako argument i wyświetli zawartość stosu katalogów na ekranie. Przykład przedstawiony poniżej został zilustrowany na rysunku 8.3: $ pushd ../demo ~/demo ~/literatura $ pwd /home/mateusz/demo $ pushd ../nazwy ~/nazwy ~/demo ~/literatura $ pwd /home/mateusz/nazwy

Rysunek 8.3. Tworzenie stosu katalogów

Kiedy wykonasz polecenie pushd bez żadnego argumentu, to zamieni ono miejscami dwa ostatnie katalogi znajdujące się na szczycie stosu, zmieni bieżący katalog roboczy na najwyższy element stosu (czyli katalog, który do tej pory był drugi od góry na stosie) i wyświetli aktualną zawartość stosu (patrz rysunek 8.4). $ pushd ~/demo ~/nazwy ~/literatura $ pwd /home/mateusz/demo

Wykorzystanie stosu katalogów  315

Rysunek 8.4. Zastosowanie polecenia pushd do zmiany katalogów roboczych

Korzystając w ten sposób z polecenia pushd, możesz łatwo przełączać się pomiędzy dwoma katalogami. Aby przejść do poprzednio używanego katalogu, możesz również użyć polecenia cd -, które działa niezależnie od tego, czy utworzyłeś wcześniej stos katalogów, czy nie. Aby przejść do innego katalogu ze stosu, powinieneś wywołać polecenie pushd z argumentem numerycznym, poprzedzonym znakiem (+). Katalogi przechowywane na stosie są numerowane od góry, przy czym katalog znajdujący się na szczycie stosu ma numer 0. Polecenie pushd przedstawione poniżej jest kontynuacją poprzedniego przykładu i zmienia bieżący katalog roboczy na literatura, przenosząc tym samym katalog literatura na szczyt stosu: $ pushd +2 ~/literatura ~/demo ~/nazwy $ pwd /home/mateusz/literatura

POLECENIE POPD — ZDEJMOWANIE NAZWY KATALOGU ZE STOSU Aby zdjąć nazwę katalogu ze stosu, powinieneś użyć wbudowanego polecenia popd (ang. pop directory). Jak to zostało przedstawione na rysunku 8.5, wykonanie tego polecenia bez żadnych argumentów zdejmuje (usuwa) ze stosu nazwę katalogu znajdującego się na szczycie stosu i zmienia katalog roboczy na katalog, który obecnie znajduje się na szczycie stosu (przed wykonaniem tego polecenia ten katalog zajmował na stosie drugą pozycję). $ dirs ~/literatura ~/demo ~/nazwy $ popd ~/demo ~/nazwy $ pwd /home/mateusz/demo

Rysunek 8.5. Zastosowanie polecenia popd do usunięcia katalogu ze stosu

316  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Aby usunąć ze stosu inny katalog niż katalog znajdujący się na szczycie stosu, powinieneś użyć polecenia popd z argumentem numerycznym poprzedzonym znakiem (+). Polecenie przedstawione na przykładzie poniżej usuwa ze stosu katalog o numerze 1, demo. Usunięcie ze stosu innego katalogu niż katalog znajdujący się na szczycie stosu (czyli inaczej mówiąc, katalogu o numerze 0) nie powoduje zmiany bieżącego katalogu roboczego. $ dirs ~/literatura ~/demo ~/nazwy $ popd +1 ~/literatura ~/nazwy

PARAMETRY I ZMIENNE Parametr powłoki (ang. shell parameter) to element wewnątrz powłoki, powiązany z wartością, która jest dostępna dla użytkownika. Istnieje kilka rodzajów parametrów powłoki: zmienne tworzone przez użytkownika, słowa kluczowe zmiennych, parametry pozycyjne i parametry specjalne.

Parametr powłoki

Parametry, których nazwy składają się z liter, cyfr i znaków podkreślenia, są często określane mianem zmiennych powłoki (ang. shell variables) lub po prostu w skrócie zmiennych. Nazwa zmiennej musi rozpoczynać się od litery lub znaku podkreślenia (nie może rozpoczynać się od cyfry) — stąd nazwy takie jak A76, MÓJ_KOT czy ___X___ są poprawnymi nazwami zmiennych, podczas gdy 69_ULICA (nazwa rozpoczyna się od cyfry) czy MOJE-NAZWISKO (zawiera myślnik) nie są poprawnymi nazwami zmiennych.

Zmienne

Zmienne powłoki, którym sam nadajesz nazwy i przypisujesz wartości, są zmiennymi tworzonymi przez użytkownika (lub w skrócie zmiennymi użytkownika). Wartości zmiennych użytkownika możesz modyfikować w dowolnej chwili, a w razie potrzeby możesz również nadawać im atrybut tylko do odczytu, dzięki czemu wartość takiej zmiennej nie będzie mogła być zmieniona.

Zmienne tworzone przez użytkownika

Domyślnie zmienna jest zmienną jedynie w powłoce, w której została utworzona (zmienna lokalna). Ten rodzaj zmiennej nosi nazwę zmiennej powłoki. Używając polecenia export, możesz ją udostępnić w powłokach potomnych (zmienna globalna). Ten rodzaj zmiennej nosi nazwę zmiennej środowiskowej. Istnieje pewna ogólnie przyjęta konwencja tworzenia nazw zmiennych, zgodnie z którą nazwy zmiennych globalnych składają się tylko z wielkich liter, a nazwy pozostałych zmiennych posiadają małe i wielkie litery lub nawet składają się wyłącznie z małych liter. Więcej informacji na temat zmiennych globalnych znajdziesz w sekcji „Zasięg zmiennych” w rozdziale 10.

Zmienne powłoki i zmienne środowiskowe

Aby w powłoce Bourne Again Shell (bash) przypisać wartość do zmiennej, powinieneś użyć następującej składni polecenia: ZMIENNA=wartość

Pamiętaj, aby nie dodawać spacji ani po jednej, ani po drugiej stronie znaku =. Przykładowe polecenie przypisujące wartość do zmiennej wygląda następująco: $ mojazmienna=abc

W powłoce tcsh przypisanie musi być poprzedzone słowem set, a spacje po obu stronach znaku równości są opcjonalne: $ set mojazmienna = abc

Powłoka bash pozwala na przypisywanie wartości do zmiennych w wierszu polecenia. Taki rodzaj przypisania tworzy zmienną, która jest lokalna dla powłoki polecenia — oznacza to, że taka zmienna jest dostępna tylko z poziomu programu, który został uruchomiony przez to polecenie oraz jego programów potomnych. Nie będzie dostępna dla powłoki,

Deklarowanie i inicjalizacja zmiennej dla skryptu

Parametry i zmienne  317

w której zostało wydane polecenie. Skrypt przedstawiony w kolejnym przykładzie wyświetla wartość zmiennej TEMPDIR. Polecenie przedstawione poniżej uruchamia skrypt mój_skrypt ze zmienną TEMPDIR ustawioną na ścieżkę /home/mateusz/temp. Wykonanie wbudowanego polecenia echo pokazuje, że po uruchomieniu skryptu mój_skrypt zmienna TEMPDIR w powłoce interaktywnej nie posiada przypisanej żadnej wartości. Jeżeli zmienna TEMPDIR byłaby ustawiona z poziomu powłoki interaktywnej, wykonanie skryptu mój_skrypt w taki sposób nie miałoby żadnego wpływu na wartość tej zmiennej. $ cat mój_skrypt echo $TEMPDIR $ TEMPDIR=/home/mateusz/temp ./mój_skrypt /home/mateusz/temp $ echo $TEMPDIR $

Zmienne środowiskowe powłoki (ang. keyword shell variables) lub w skrócie zmienne środowiskowe mają specjalne znaczenie dla powłoki i zazwyczaj posiadają krótkie, mnemoniczne nazwy. Kiedy uruchamiasz powłokę (na przykład poprzez zalogowanie się do systemu), powłoka dziedziczy kilka zmiennych środowiskowych od systemu. Wśród nich są takie zmienne jak HOME, która identyfikuje Twój katalog domowy, czy zmienna PATH, określająca, w których katalogach i w jakiej kolejności powłoka będzie poszukiwać polecenia, które nakazałeś jej wykonać. Po uruchomieniu powłoka tworzy również inne zmienne środowiskowe i nadaje im domyślne wartości początkowe. Jeszcze inny zestaw zmiennych nie istnieje dopóty, dopóki samodzielnie nie nadasz im wartości.

Zmienne środowiskowe

Możesz zmieniać wartości większości zmiennych środowiskowych. Zazwyczaj nie ma potrzeby zmiany wartości zmiennych inicjowanych w plikach startowych systemu, takich jak /etc/profile czy /etc/csh.cshrc. Jeżeli musisz zmienić wartość zmiennej środowiskowej powłoki bash, możesz tego dokonać w jednym ze swoich plików startowych (opis dla powłoki bash znajdziesz w sekcji „Pliki startowe” we wcześniejszej części tego rozdziału, natomiast opis dla powłoki tcsh znajduje się w rozdziale 9.). Podobnie jak to miało miejsce w przypadku zmiennych użytkownika, zmiennym środowiskowym również możesz nadać status zmiennych globalnych — takie zadanie jest zazwyczaj automatycznie realizowane w plikach startowych. W razie potrzeby możesz również nadać zmiennej środowiskowej atrybut tylko do odczytu. Więcej informacji o zmiennych środowiskowych znajdziesz w dalszej części rozdziału. Nazwy parametrów pozycyjnych (ang. positional parameters) oraz specjalnych (ang. special parameters) powłoki nie przypominają w niczym nazw zmiennych. Większość tych parametrów posiada nazwy składające się tylko z jednego znaku (na przykład, 1, ? czy #) i odwołujemy się do nich (tak jak w przypadku zmiennych), poprzedzając ich nazwy znakiem dolara ($), na przykład $1, $? czy $#. Wartości tych parametrów odzwierciedlają różne aspekty Twojej interakcji z powłoką.

Parametry pozycyjne i parametry specjalne

Za każdym razem, kiedy uruchamiasz jakieś polecenie, poszczególne argumenty podane w wierszu polecenia stają się wartościami odpowiednich parametrów pozycyjnych (patrz rozdział 10.). Parametry pozycyjne dają Ci dostęp do poszczególnych argumentów wywołania polecenia, co jest bardzo często potrzebne podczas tworzenia skryptów powłoki. Wbudowane polecenie set pozwala na przypisywanie wartości do parametrów pozycyjnych. Inne często wykorzystywane w skryptach powłoki wartości, takie jak nazwa ostatnio wykonanego polecenia, liczba argumentów wywołania polecenia czy status ostatnio wykonanego polecenia, są dostępne za pośrednictwem parametrów specjalnych (patrz sekcja „Parametry specjalne” w rozdziale 10.). Nie możesz samodzielnie przypisywać wartości do parametrów specjalnych.

318  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

ZMIENNE TWORZONE PRZEZ UŻYTKOWNIKA W pierwszym wierszu poniższego przykładu deklarowana jest zmienna o nazwie person i nadawana jej jest wartość kuba: $ person=kuba $ echo person person $ echo $person kuba

Ponieważ wbudowane polecenie echo kopiuje swoje argumenty wywołania na standardowe wyjście, możesz używać go do wyświetlania wartości zmiennych. W drugim wierszu naszego przykładu widzimy, że ciąg znaków person nie reprezentuje wartości kuba. Zamiast tego polecenie echo wyświetla ciąg znaków person jako person. Powłoka podstawia odpowiednią wartość zmiennej tylko wtedy, kiedy poprzedzisz nazwę zmiennej znakiem dolara ($). Z tego powodu dopiero kolejne polecenie, echo $person, wyświetla wartość zmiennej person. W tym przypadku polecenie echo nie wyświetla ciągu znaków $person, ponieważ powłoka nie przekazuje tego ciągu znaków do polecenia echo jako argumentu wywołania. Ze względu na fakt, że ciąg znaków $person rozpoczyna się od znaku dolara ($), powłoka rozpoznaje go jako nazwę zmiennej, podstawia zamiast nazwy wartość zmiennej i przekazuje ją do polecenia echo. Następnie wbudowane polecenie echo wyświetla na swoim wyjściu wartość zmiennej — tak naprawdę polecenie echo „nie wie”, że w wierszu polecenia zostało wywołane ze zmienną.

Podstawianie parametrów

W razie potrzeby możesz spowodować, że powłoka nie będzie podstawiała wartości zmiennej, cytując znak $ znajdujący się na początku nazwy zmiennej. Zastosowanie cudzysłowu nie zapobiega podstawieniom — aby cytowanie było skuteczne, musisz użyć apostrofu lub lewego ukośnika (\).

Cytowanie znaku $

$ echo $person kuba $ echo "$person" kuba $ echo '$person' $person $ echo \$person $person

Ponieważ znaki cudzysłowu nie zapobiegają podstawianiu wartości zmiennych, ale jednocześnie wyłączają znaczenie specjalne wielu innych znaków, cudzysłowy są bardzo użyteczne przy nadawaniu wartości zmiennym oraz w sytuacji, kiedy korzystasz z takich wartości. Aby przypisać ciąg znaków (wartość) zawierający spacje i znaki tabulacji do zmiennej, powinieneś ująć taki ciąg znaków w cudzysłów. Stosowanie cudzysłowów nie zawsze jest konieczne, ale mimo to powinieneś sobie wyrobić dobry nawyk ich używania.

Spacje

$ person="kuba i dawid" $ echo $person kuba i dawid $ person=kuba i dawid bash: i: nie odnaleziono polecenia...

Kiedy odwołujesz się do zmiennej, której wartością jest ciąg znaków zawierający znaki tabulacji lub wiele kolejnych spacji, to aby zachować odpowiednie odstępy, musisz ująć taki ciąg znaków w cudzysłów. Jeżeli nie cytujesz zmiennej, przed jej przekazaniem do wywoływanego polecenia powłoka zredukuje każdy ciąg białych znaków do postaci pojedynczej spacji: $ person="kuba i $ echo $person kuba i dawid $ echo "$person" kuba i dawid

dawid"

Kiedy argumentem wywołania danego polecenia jest zmienna, powłoka zastępuje nazwę zmiennej jej wartością i dopiero wtedy przekazuje ją do wywoływanego programu. Jeżeli ciąg znaków będący wartością zmiennej zawiera jakieś znaki specjalne, takie jak * czy ?, powłoka może rozwinąć taką zmienną.

Rozwijanie ścieżek w przypisaniach zmiennych

Parametry i zmienne  319

Pierwsze polecenie na przykładzie przedstawionym poniżej przypisuje ciąg znaków kuba* do zmiennej memo. Jeżeli odwołujesz się do zmiennej, w której ciąg znaków będący jej wartością zawiera niecytowany znak specjalny, to wszystkie powłoki będą go interpretowały jako znak specjalny. W przykładzie przedstawionym poniżej powłoka rozwija wartość zmiennej memo, ponieważ nie jest ona cytowana w wierszu polecenia: $ memo=kuba* $ ls kuba.raport kuba.podsumowanie $ echo $memo kuba.raport kuba.podsumowanie

W tym przypadku powłoka zamiast zmiennej $memo podstawia jej wartość (kuba*), dokonuje rozwinięcia ścieżek do wartości kuba.raport oraz kuba.podsumowanie i dopiero wtedy przekazuje te dwie wartości do polecenia echo. W kolejnym przykładzie powłoka Bourne Again Shell nie rozwija ciągu znaków, ponieważ bash z definicji nie przeprowadza rozwijania ścieżek podczas przypisywania wartości do zmiennej. $ echo "$memo" kuba*

Wszystkie powłoki przetwarzają wiersz polecenia w ściśle określonej kolejności. Zgodnie z nią powłoka bash (choć już nie tcsh) rozwija zmienne przed rozpoczęciem interpretowania polecenia. W poleceniu echo, widocznym w drugim wierszu naszego przykładu, użycie cudzysłowu cytuje znak gwiazdki (*) w podstawionej wartości zmiennej $memo, co powoduje, że powłoka nie dokonuje rozwinięcia ścieżki w wartości zmiennej przekazywanej do polecenia echo.

INFORMACJE DODATKOWE Składnia $ZMIENNA jest szczególnym przypadkiem bardziej ogólnej składni ${ZMIENNA}, gdzie nazwa zmiennej jest poprzedzona znakiem dolara i ujęta w nawiasy klamrowe ${}. Zadaniem nawiasów klamrowych jest odizolowanie nazwy zmiennej od sąsiadujących z nią znaków. Użycie nawiasów klamrowych jest niezbędne w sytuacji, kiedy dokonujesz łączenia wartości zmiennej z innym ciągiem znaków:

Nawiasy klamrowe

$ $ $ $

PREF=przeciw ZM1=$PREFlotniczy ZM2=$PREFpożarowy echo $ZM1 $ZM2

$

Powyższy przykład nie będzie działał tak, jak moglibyśmy tego oczekiwać. Jedynym wynikiem działania ostatniego polecenia jest pusty wiersz — pomimo że PREFlotniczy i PREFpożarowy są poprawnymi nazwami zmiennych, to jednak nie zostają do nich przypisane żadne wartości. Domyślnie powłoka bash przyjmuje, że wartością zmiennej, do której nie została przypisana żadna inna wartość, jest pusty ciąg znaków (null) i wyświetla taki ciąg znaków na ekranie. Aby osiągnąć zamierzony rezultat, powinieneś ująć nazwę zmiennej PREF w nawiasy klamrowe: $ PREF=przeciw $ ZM1=${PREF}lotniczy $ ZM2=${PREF}pożarowy $ echo $ZM1 $ZM2 przeciwlotniczy przeciwpożarowy

Powłoka Bourne Again Shell odwołuje się do argumentów w wierszu polecenia za pomocą zmiennych specjalnych $1, $2, $3 i tak dalej aż do $99, reprezentujących argumenty wywołania polecenia w kolejności ich występowania. Jeżeli chcesz odwołać się do argumentów o numerach wyższych niż 9, musisz użyć nawiasów klamrowych, na przykład ${10}. Nazwa wywoływanego polecenia jest przechowywana w zmiennej $0 (patrz rozdział 10.).

320  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

POLECENIE UNSET — USUWANIE ZMIENNYCH Jeżeli zmienna nie zostanie usunięta, to będzie istniała tak długo, jak długo istnieje powłoka, w której została utworzona. Aby usunąć wartość zmiennej, ale bez usuwania samej zmiennej, powinieneś przypisać do wybranej zmiennej pustą wartość (null). W poniższym przykładzie polecenie set zostało użyte do wyświetlenia listy wszystkich zmiennych i ich wartości, natomiast grep — do wyodrębnienia wiersza zawierającego wartość zmiennej person: $ echo $person dawid $ person= $ echo $person $ set | grep person person=

Aby całkowicie usunąć wybraną zmienną, powinieneś użyć polecenia unset. Przykładowe polecenie przedstawione poniżej usuwa zmienną o nazwie person: $ unset person $ echo $person $ set | grep person $

ATRYBUTY ZMIENNYCH W tej sekcji omówimy atrybuty zmiennych i wyjaśnimy, jak przypisywać je do zmiennych.

POLECENIE READONLY — NADAWANIE ZMIENNEJ STAŁEJ WARTOŚCI Aby spowodować, że wartość danej zmiennej nie będzie mogła zostać zmieniona, powinieneś użyć wbudowanego polecenia readonly (niedostępne w powłoce tcsh). W przykładzie zamieszczonym poniżej polecenie to zostało użyte do nadania zmiennej person atrybutu tylko do odczytu. Pamiętaj, że musisz nadać takiej zmiennej wartość przed nadaniem jej atrybutu tylko do odczytu — po nadaniu tego atrybutu już nie będziesz mógł zmienić wartości tej zmiennej. Jeżeli spróbujesz usunąć taką zmienną poleceniem unset lub spróbujesz zmienić jej wartość, to powłoka wyświetli na ekranie odpowiedni komunikat o wystąpieniu błędu: $ person=dawid $ echo $person dawid $ readonly person $ person=helena bash: person: zmienna tylko do odczytu $ unset person bash: unset: person: nie można anulować definicji: zmienna tylko do odczytu

Jeżeli użyjesz wbudowanego polecenia readonly bez żadnych argumentów, to na ekranie zostanie wyświetlona lista wszystkich zmiennych powłoki, które są przeznaczone tylko do odczytu. Na tej liście znajdują się również zmienne środowiskowe, które są automatycznie ustawiane jako zmienne tylko do odczytu, oraz zmienne utworzone przez użytkownika, które zostały zadeklarowane jako tylko do odczytu. Przykłady takich zmiennych znajdziesz w kolejnej sekcji (polecenia readonly oraz declare -r dają taki sam rezultat).

POLECENIA DECLARE I TYPESET — NADAWANIE ATRYBUTÓW ZMIENNYM Wbudowane polecenia declare (niedostępne w powłoce tcsh) oraz typeset (są to w zasadzie dwie różne nazwy tego samego polecenia) pozwalają na nadawanie atrybutów i wartości zmiennym powłoki. W tabeli 8.3 znajdziesz listę pięciu przykładowych atrybutów.

Parametry i zmienne  321

Tabela 8.3. Atrybuty zmiennych (polecenia typeset lub declare) Atrybut

Znaczenie

-a

Deklaruje zmienną jako tablicę (patrz rozdział 10.)

-f

Deklaruje zmienną jako nazwę funkcji (patrz dalsza część tego rozdziału)

-i

Deklaruje zmienną jako wartość całkowitą typu integer (patrz dalsza część tego rozdziału)

-r

Deklaruje zmienną jako tylko do odczytu (patrz poprzednie sekcje tego rozdziału)

-x

Powoduje wyeksportowanie zmiennej (nadaje zmiennej status zmiennej globalnej), patrz także polecenie export (patrz rozdział 10.)

Polecenia przedstawione poniżej deklarują kilka zmiennych i ustawiają niektóre atrybuty. W pierwszym wierszu deklarowana jest zmienna person1 i nadawana jest jej wartość kuba. Takie polecenie będzie miało identyczny efekt zarówno z użyciem słowa declare, jak i bez niego. $ $ $ $

declare declare declare declare

person1=kuba -r person2=dawid -rx person3=helena -x person4

Wbudowane polecenia readonly oraz export są synonimami poleceń odpowiednio declare -r oraz declare -x. Możesz zadeklarować zmienną bez przypisywania jej wartości, tak jak to zostało zilustrowane powyżej przy deklaracji zmiennej person4. Taka deklaracja powoduje, że zmienna person4 staje się dostępna dla wszystkich podpowłok (zmienna staje się zmienną globalną). Dopóki nie nadasz takiej zmiennej innej wartości, będzie ona miała wartość NULL (wartość pusta).

Polecenia readonly i export

Poszczególne opcje polecenia declare możesz osobno umieszczać w wierszu polecenia w dowolnej kolejności. Polecenie przedstawione poniżej jest funkcjonalnym odpowiednikiem polecenia deklarującego w poprzednim przykładzie zmienną person3: $ declare -x -r person3=helena

Jeżeli chcesz usunąć wybrane atrybuty zmiennej, powinieneś w wywołaniu polecenia zamiast znaków (-) użyć znaków (+). Pamiętaj jednak, że nie możesz usunąć atrybutu tylko do odczytu. Po wykonaniu polecenia przedstawionego poniżej zmienna person3 nie będzie już dłużej wyeksportowana, ale nadal pozostanie zmienną tylko do odczytu. $ declare +x person3

Więcej informacji na temat eksportowania zmiennych znajdziesz w rozdziale 10. Jeżeli użyjesz polecenia declare bez żadnych argumentów ani opcji, wyświetlona zostanie lista wszystkich zmiennych powłoki. Taka sama lista jest wyświetlana, kiedy uruchomisz polecenie set (patrz rozdział 10.) bez żadnych argumentów.

Wyświetlanie listy atrybutów zmiennych

Jeżeli używasz wbudowanego polecenia declare z opcjami, ale bez żadnych nazw zmiennych spełniających rolę argumentów, polecenie to wyświetla na ekranie listę tych zmiennych powłoki, które mają ustawione atrybuty odpowiadające liście opcji podanej w wierszu polecenia. Na przykład polecenie declare -r wyświetli listę wszystkich zmiennych, które mają ustawiony atrybut tylko do odczytu. Taką samą listę zmiennych możesz uzyskać, uruchamiając polecenie readonly bez żadnych argumentów. Po wykonaniu deklaracji przedstawionych na poprzednim przykładzie wyniki będą następujące: $ declare -r declare -r BASHOPTS="checkwinsize:cmdhist:expand_aliases: ... " declare -ir BASHPID declare -ar BASH_VERSINFO='([0]="4" [1]="2" [2]="24" [3]="1" ... ' declare -ir EUID="500" declare -ir PPID="1936"

322  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) declare declare declare declare

-r SHELLOPTS="braceexpand:emacs:hashall:histexpand: ... " -ir UID="500" -r person2="dawid" -rx person3="helena"

Pierwszych siedem pozycji listy reprezentuje zmienne środowiskowe, które są automatycznie deklarowane jako zmienne tylko do odczytu. Warto zauważyć, że niektóre z tych zmiennych są deklarowane jako liczby całkowite typu integer (opcja -i). Użycie opcji -a wskazuje, że zmienna BASH_VERSINFO jest zmienną tablicową. Wartość poszczególnych elementów tablicy jest wyświetlana po prawej stronie znaku równości. Domyślnie wartości zmiennych są zapisywane jako łańcuchy znaków. Kiedy wykonujesz obliczenia na takich wartościach zmiennych, powłoka dokonuje konwersji wartości zmiennych na odpowiednie liczby, przeprowadza obliczenia i następnie dokonuje powrotnej konwersji na łańcuchy znaków. Zmienne, które zostały zadeklarowane jako liczby całkowite typu integer, są przechowywane od razu w postaci liczbowej. Aby nadać zmiennej atrybut liczby całkowitej, powinieneś użyć następującego polecenia:

Zmienne typu integer

$ declare -i COUNT

Polecenia declare możesz użyć do wyświetlenia zmiennych typu integer: $ declare -i declare -ir BASHPID declare -i COUNT declare -ir EUID="1000" declare -i HISTCMD declare -i LINENO declare -i MAILCHECK="60" declare -i OPTIND="1" ...

ZMIENNE ŚRODOWISKOWE Zmienne środowiskowe (ang. keyword variables) są albo dziedziczone, albo deklarowane oraz inicjowane przez powłokę podczas jej uruchamiania. Zmiennym środowiskowym możesz przypisywać wartości z poziomu wiersza poleceń konsoli albo pliku startowego. Zazwyczaj będziesz chciał, aby takie zmienne były dostępne dla wszystkich powłok, które będziesz uruchamiał, łącznie z Twoją powłoką logowania.

ZMIENNA HOME — TWÓJ KATALOG DOMOWY Domyślnie po zalogowaniu bieżącym katalogiem roboczym jest Twój katalog domowy, który jest tworzony podczas tworzenia i konfiguracji Twojego konta użytkownika. W systemach Linux nazwa katalogu domowego jest przechowywana w pliku /etc/passwd. Natomiast system OS X do przechowywania tego rodzaju informacji używa Open Directory (patrz dodatek D). $ grep mateusz /etc/passwd mateusz:x:500:500:Mateusz Zdobywca:/home/mateusz:/bin/bash

Kiedy logujesz się do systemu, powłoka dziedziczy ścieżkę do Twojego katalogu domowego i przypisuje ją do zmiennej HOME (W przypadku powłoki tcsh będzie to home). Kiedy wykonasz polecenie cd bez żadnych argumentów, powłoka zmieni bieżący katalog roboczy na katalog, którego nazwa przechowywana jest w zmiennej HOME. $ pwd /home/kuba/laptop $ echo $HOME /home/kuba $ cd $ pwd /home/kuba

Parametry i zmienne  323

Na powyższym przykładzie wyświetlona została wartość zmiennej HOME oraz przedstawiony efekt wykonania wbudowanego polecenia cd. Po wykonaniu polecenia cd bez żadnych argumentów ścieżka bieżącego katalogu roboczego jest taka sama jak ścieżka przechowywana w zmiennej HOME — jest to ścieżka do Twojego katalogu domowego. Powłoka używa wartości zmiennej HOME do rozwijania ścieżek, które do oznaczenia katalogu domowego użytkownika używają znaku tyldy ~ (patrz rozdział 4.). W przykładzie przedstawionym poniżej polecenie echo zostało użyte do wyświetlenia wartości podstawianej zamiast tego znaku. Następnie polecenie ls zostało użyte do wyświetlenia wszystkich plików znajdujących się w katalogu o nazwie laptop, będącym podkatalogiem katalogu domowego użytkownika kuba.

Znak tyldy (~)

$ echo ~ /home/kuba $ ls ~/laptop tester licznik raporty

ZMIENNA PATH — CZYLI GDZIE POWŁOKA SZUKA PROGRAMÓW Kiedy w wierszu polecenia zamiast prostej nazwy polecenia użyjesz względnej lub bezwzględnej ścieżki do pliku, powłoka będzie poszukiwała w danym katalogu pliku wykonywalnego o podanej nazwie. Jeżeli okaże się, że taki plik nie istnieje, powłoka wyświetli na ekranie komunikat informujący, że polecenie o podanej nazwie nie zostało odnalezione. Jeżeli plik o podanej nazwie istnieje, ale nie posiadasz prawa wykonania tego pliku (lub w przypadku skryptu powłoki nie posiadasz prawa odczytu takiego pliku), powłoka wyświetli na ekranie komunikat o braku dostępu do tego pliku. Jeżeli jako nazwy polecenia użyjesz prostej nazwy pliku, powłoka będzie poszukiwała takiego pliku w określonym zestawie katalogów (w Twojej ścieżce wyszukiwania). Powłoka będzie poszukiwała pliku o takiej nazwie jak podana nazwa polecenia, do którego posiadasz prawo wykonania (w przypadku skompilowanego programu) lub prawo odczytu i wykonania (w przypadku skryptu powłoki). Lista katalogów, które będą przeszukiwane, przechowywana jest w zmiennej PATH (w przypadku powłoki tcsh będzie to path). Domyślna wartość zmiennej PATH jest określana podczas kompilacji powłoki bash. Zawartość tej zmiennej nie jest ustawiana w plikach startowych, aczkolwiek z ich poziomu może być modyfikowana. W normalnych warunkach zmienna PATH zawiera listę kilku katalogów systemowych, w których przechowywane są podstawowe polecenia i narzędzia systemowe. Są to między innymi takie katalogi jak /bin, /usr/bin i inne katalogi w zależności od systemu lokalnego. Jeżeli próbujesz wykonać jakieś polecenie, a powłoka nie potrafi odnaleźć pliku wykonywalnego — a w przypadku skryptu powłoki pliku, do którego masz prawo odczytu — w katalogach określonych przez zawartość zmiennej PATH, na ekranie zostanie wyświetlony jeden z komunikatów o wystąpieniu błędów, o których wspominaliśmy niedawno. Zmienna PATH zawiera listę katalogów zapisanych w kolejności, w jakiej powłoka będzie przeszukiwała ich zawartość. Ścieżki poszczególnych katalogów muszą być oddzielone od siebie dwukropkami. Polecenie przedstawione poniżej ustawia wartość zmiennej PATH tak, aby powłoka rozpoczynała przeszukiwanie katalogów od ścieżki /usr/local/bin. Jeżeli poszukiwany plik nie zostanie odnaleziony w tym katalogu, powłoka rozpocznie wyszukiwanie w katalogu /bin, a następnie w katalogu /usr/bin. Jeżeli plik nadal nie zostanie odnaleziony, powłoka rozpocznie wyszukiwanie w katalogu ~/bin, będącym podkatalogiem katalogu domowego użytkownika. Na koniec powłoka przeszukuje zawartość katalogu domowego. Wyeksportowanie zmiennej PATH powoduje, że będzie ona dostępna dla wszystkich podpowłok:

Katalog roboczy

$ export PATH=/usr/local/bin:/bin:/usr/bin:~/bin:

Pusta wartość (NULL) w ciągu znaków oznacza bieżący katalog roboczy. W naszym przykładzie wartość NULL (czyli puste miejsce między znakiem dwukropka a końcem wiersza) pojawia się jako ostatni element ciągu znaków. Katalog bieżący może być reprezentowanych przez znak dwukropka znajdujący się na

324  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) początku wiersza (takie rozwiązanie zdecydowanie nie jest polecane ze względów bezpieczeństwa), na końcu wiersza (tak jak w naszym przykładzie) lub jako dwa znaki dwukropka obok siebie, w dowolnym innym miejscu ciągu znaków będących wartością tej zmiennej. Katalog roboczy może również być wprost reprezentowany w zmiennej PATH jako kropka (.). Ponieważ system Linux przechowuje w katalogach o nazwie bin (ang. binary) bardzo wiele plików, użytkownicy bardzo często umieszczają swoje pliki wykonywalne w swoich własnych katalogach ~/bin. Jeżeli na końcu zmiennej PATH umieścisz swój własny katalog bin, powłoka będzie przeglądała go za każdym razem, kiedy nie będzie w stanie odnaleźć poszukiwanego polecenia czy programu w pozostałych katalogach. Jeżeli chcesz dodać do zmiennej PATH nowe katalogi, możesz w poleceniu ustawiającym nową wartość zmiennej odwołać się do „starej” wartości zmiennej (pamiętaj o wskazówce dotyczącej bezpieczeństwa systemu). Polecenie przedstawione poniżej dodaje ścieżkę /usr/local/bin na początku zmiennej PATH i następnie na końcu zmiennej PATH dodaje podkatalog bin znajdujący się w katalogu domowym użytkownika (~/bin). $ PATH=/usr/local/bin:$PATH:~/bin

Wartość zmiennej PATH modyfikujesz w pliku ~/.bash_profile; więcej informacji na temat wymienionego pliku przedstawiono na początku rozdziału.

BEZPIECZEŃSTWO Zmienna PATH a bezpieczeństwo systemu Jeżeli względy bezpieczeństwa systemu są dla Ciebie istotnym zagadnieniem, to nie powinieneś umieszczać katalogu roboczego na początku zmiennej PATH. Jeżeli pracujesz jako użytkownik root, to nigdy nie powinieneś umieszczać katalogu roboczego w zmiennej PATH. Całkowite pomijanie katalogu roboczego w zmiennej PATH użytkownika root jest powszechnie stosowaną praktyką. W razie potrzeby możesz zawsze uruchomić żądany plik z katalogu roboczego, poprzedzając jego nazwę ścieżką ./, na przykład ./mójprogram. Umieszczenie bieżącego katalogu roboczego na początku listy katalogów w zmiennej PATH może przyczynić się do powstania luki w zabezpieczeniach systemu. Większość użytkowników używa polecenia ls jako pierwszego polecenia wykonywanego po wejściu do nowego katalogu. Jeżeli właściciel takiego katalogu umieści w nim plik wykonywalny o nazwie ls, a katalog roboczy będzie pierwszy na liście ścieżek zmiennej PATH, to użytkownik wykonujący polecenie ls zamiast polecenia systemowego uruchomi program o nazwie ls znajdujący się w bieżącym katalogu roboczym, co może przynieść zupełnie nieoczekiwane rezultaty.

ZMIENNA MAIL — CZYLI GDZIE PRZECHOWYWANA JEST TWOJA POCZTA Zmienna MAIL (w przypadku powłoki tcsh będzie to mail) zawiera ścieżkę do pliku, w którym przechowywana jest Twoja skrzynka pocztowa (ang. mailbox) — zazwyczaj jest to katalog /var/mail/, gdzie to nazwa Twojego konta użytkownika. Zmienną MAIL możesz wykorzystać do obserwacji dowolnego pliku lub katalogu — wystarczy przypisać jej nazwę pliku lub katalogu, który chcesz obserwować. Jeżeli zmienna MAIL jest ustawiona, a zmienna MAILPATH (patrz dalej) nie jest ustawiona, powłoka informuje Cię za każdym razem, kiedy w pliku określonym przez zmienną MAIL pojawia się nowa wiadomość poczty elektronicznej. W środowisku graficznym możesz usunąć zmienną MAIL, dzięki czemu powłoka nie będzie Ci wyświetlała w oknie emulatora terminala powiadomień o oczekujących wiadomościach (zakładając oczywiście, że korzystasz z graficznego klienta poczty elektronicznej). W większości systemów OS X nie są używane pliki lokalne dla poczty przychodzącej. Zamiast tego poczta jest zazwyczaj przechowywana w zdalnym serwerze poczty. Zmienna MAIL oraz inne zmienne powłoki powiązane z obsługą poczty nie mają więc znaczenia, o ile nie korzystasz z lokalnego serwera poczty.

Parametry i zmienne  325

Zmienna MAILPATH (niezdefiniowana w powłoce tcsh) zawiera listę ścieżek do plików oddzielonych od siebie dwukropkami. Jeżeli ta zmienna zostanie ustawiona, powłoka będzie Cię powiadamiała za każdym razem, kiedy któryś z tych plików zostanie zmodyfikowany (na przykład kiedy zostanie odebrana nowa wiadomość poczty elektronicznej). Po nazwie dowolnego pliku z listy możesz umieścić znak zapytania (?) i wybrany komunikat. Od tej chwili taki komunikat będzie zastępował domyślny komunikat you have mail i będzie wyświetlany za każdym razem, kiedy otrzymasz nową wiadomość. Zmienna MAILCHECK (niezdefiniowana w powłoce tcsh) określa interwał (w sekundach), z jakim powłoka będzie sprawdzała pliki lub katalogi wskazane przez zmienne MAIL i MAILPATH. Domyślnie powłoka dokonuje takiego sprawdzenia co 60 sekund. Jeżeli ustawisz wartość tej zmiennej na zero, powłoka będzie dokonywała sprawdzenia przed każdym wyświetleniem znaku zachęty.

ZMIENNA PS1 — PODSTAWOWY ZNAK ZACHĘTY Domyślnym znakiem zachęty powłoki Bourne Again Shell jest znak dolara ($). Kiedy uruchomisz powłokę bash na prawach użytkownika root, powłoka bash zazwyczaj zmieni znak zachęty na #. Zmienna PS1 (w powłoce tcsh to zmienna prompt, zobacz rozdział 9.) przechowuje ciąg znaków tworzący znak zachęty, za pomocą którego powłoka daje Ci do zrozumienia, że oczekuje na wpisanie kolejnego polecenia. Kiedy zmieniasz wartość zmiennej PS1, automatycznie zmieniasz wygląd znaku zachęty. W każdej chwili możesz zmienić wartość zmiennej PS1, a tym samym zmodyfikować wygląd znaku zachęty wyświetlanego przez powłokę. Na przykład wykonanie polecenia przedstawionego poniżej: $ PS1="[\u@\h \W \!]$ "

powoduje wyświetlenie znaku zachęty o następującej postaci: [użytkownik@host katalog zdarzenie]$

użytkownik katalog to nazwa

to nazwa konta użytkownika, host to nazwa komputera (do pierwszej kropki), bazowa katalogu roboczego, a zdarzenie to numer zdarzenia (patrz nieco dalej w rozdziale) związanego z wykonaniem bieżącego polecenia (numer ostatnio wykonanego polecenia w historii poleceń).

gdzie

Jeżeli pracujesz w więcej niż jednym systemie, to włączenie nazwy systemu do znaku zachęty może być bardzo dobrym rozwiązaniem. W pierwszym przykładzie poniżej dokonujemy zmiany domyślnego znaku zachęty na nazwę systemu lokalnego (nazwę hosta), po której następuje spacja i znak dolara (lub jeżeli użytkownik pracuje na prawach użytkownika root, znak #). W drugim przykładzie zmieniamy znak zachęty na bieżący czas, po którym wyświetlana jest nazwa konta użytkownika. W trzecim przykładzie zmieniamy znak zachęty na używany w naszej książce (znak # dla użytkowników pracujących na prawach użytkownika root oraz $ dla pozostałych użytkowników): $ PS1='\h \$ ' helios $ $ PS1='\@ \u $ ' 09:44 kuba $ $ PS1='\$ ' $

W tabeli 8.4 przedstawiamy zestawienie wybranych symboli, których możesz użyć podczas tworzenia znaku zachęty (modyfikacji wartości zmiennej PS1). Odpowiednie symbole dla powłoki tcsh przedstawiono w rozdziale 9. Aby wyświetlić pełną listę znaków specjalnych, których możesz użyć podczas tworzenia znaku zachęty, powinieneś otworzyć stronę podręcznika man polecenia bash i wyszukać sekcję ZACHĘTA POWŁOKI (aby to zrobić, wpisz polecenie /ZACHĘTA POWŁOKI, naciśnij klawisz Enter, a następnie dwukrotnie klawisz n).

326  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Tabela 8.4. Symbole, których możesz użyć w zmiennej PS1 Symbol

Wyświetlanie w znaku zachęty

\$

# dla użytkowników pracujących na prawach użytkownika root; $ dla pozostałych użytkowników.

\w

Ścieżka do katalogu roboczego.

\W

Nazwa bazowa katalogu roboczego.

\!

Bieżący numer zdarzenia w historii poleceń (patrz nieco dalej rozdziale).

\d

Data w formacie dzień tygodnia, miesiąc dzień.

\h

Nazwa komputera, bez nazwy domeny.

\H

Pełna nazwa komputera (łącznie z nazwą domeny).

\u

Nazwa konta użytkownika.

\@

Bieżący czas w formacie 12-godzinnym (AM/PM).

\T

Bieżący czas w formacie 12-godzinnym HH:MM:SS.

\A

Bieżący czas w formacie 24-godzinnym HH:MM.

\t

Bieżący czas w formacie 24-godzinnym HH:MM:SS.

ZMIENNA PS2 — WTÓRNY ZNAK ZACHĘTY Zmienna PS2 (w powłoce tcsh to zmienna prompt2) przechowuje wtórny znak zachęty. W pierwszym wierszu przykładu przedstawionego poniżej ciąg znaków będący argumentem polecenia echo nie został zakończony znakiem cudzysłowu. W takiej sytuacji powłoka zakłada, że ten wiersz polecenia nie został zakończony, i wyświetla w drugim wierszu wtórny znak zachęty (>). Pojawienie się takiego znaku zachęty wskazuje, że powłoka oczekuje na kontynuację polecenia, którego wpisywanie rozpocząłeś w poprzednim wierszu. W naszym przykładzie powłoka oczekuje, aż wpiszesz znak cudzysłowu zamykający ciąg znaków. Dopiero wtedy rozpoczyna wykonywanie polecenia: $ echo "Ilustracja działania wtórnego znaku > zachęty" Ilustracja działania wtórnego znaku zachęty

W poniższym przykładzie zmiennej PS2 zostaje przypisana wartość Dane => i spacja. W wierszu polecenia who symbol potoku (|) oznacza, że polecenie będzie kontynuowane, a więc powłoka wyświetla wtórny znak zachęty. Polecenie grep dawid (po naciśnięciu klawisza Enter) uzupełnia polecenie, a narzędzie grep wyświetla dane wyjściowe. $ PS2="Dane => " > who | Dane => grep dawid dawid tty1 2012-05-01 10:37 (:0)

ZMIENNA PS3 — ZNAK ZACHĘTY MENU Zmienna PS3 (w powłoce tcsh to zmienna prompt3) przechowuje znak zachęty menu, który jest wyświetlany dla struktury sterującej select (patrz rozdział 10.). ZMIENNA PS4 — ZNAK ZACHĘTY TRYBU ŚLEDZENIA WYKONYWANIA POLECEŃ Zmienna PS4 (brak w powłoce tcsh) przechowuje wygląd znaku zachęty, który jest wyświetlany przez powłokę bash pracującą w trybie śledzenia wykonywania poleceń (patrz rozdział 10.).

Parametry i zmienne  327

ZMIENNA IFS — SEPARACJA PÓL WEJŚCIOWYCH (DZIELENIE NA SŁOWA) Niezdefiniowana w powłoce tcsh zmienna IFS (ang. Internal Field Separator) definiuje znaki, których możesz używać do oddzielania argumentów w wierszu polecenia. Domyślnie wartością zmiennej jest ciąg znaków . Niezależnie od wartości zmiennej IFS do oddzielania od siebie argumentów w wierszu polecenia możesz zawsze używać jednej lub kilku spacji lub tabulatorów (zakładając oczywiście, że nie są cytowane lub poprzedzone znakiem ucieczki). Znaki przypisane do zmiennej IFS mogą być również wykorzystywane do oddzielania pól, ale tylko wtedy, kiedy są rozwijane — taki rodzaj interpretacji wiersza poleceń jest nazywany dzieleniem słów (ang. word splitting). Więcej informacji na ten temat znajdziesz w dalszej części rozdziału.

OSTRZEŻENIE Zmieniając ustawienia zmiennej IFS, powinieneś zachować ostrożność Zmiana wartości zmiennej IFS pociąga za sobą całą gamę różnych efektów ubocznych, zatem decydując się na taki krok, powinieneś zachować szczególną ostrożność. Dobrym, przydatnym rozwiązaniem może być zapisanie oryginalnej wartości zmiennej IFS przed modyfikacją jej ustawień. Dzięki temu będziesz mógł w razie napotkania nieprzewidzianych efektów szybko odtworzyć jej oryginalną wartość. Innym rozwiązaniem może być uruchomienie przed rozpoczęciem eksperymentów nowej powłoki bash i przeprowadzanie zmian w tej powłoce — w ten sposób w razie problemów możesz po prostu zakończyć pracę tej powłoki poleceniem exit i powrócić do „starej” powłoki, w której zmienna IFS jest ustawiona w poprawny sposób. Przykład przedstawiony poniżej pokazuje, jaki wpływ może mieć zmiana ustawień zmiennej sposób interpretacji komend wpisywanych w wierszu poleceń: $ a=w:x:y:z $ cat $a cat: w:x:y:z: Nie ma takiego $ IFS=":" $ cat $a cat: w: Nie ma takiego pliku cat: x: Nie ma takiego pliku cat: y: Nie ma takiego pliku cat: z: Nie ma takiego pliku

IFS

na

pliku ani katalogu ani ani ani ani

katalogu katalogu katalogu katalogu

Przy pierwszym wywołaniu polecenia cat powłoka podstawia wartość zmiennej a, interpretując ciąg znaków w:x:y:z jako pojedyncze słowo, które zostaje użyte jako argument polecenia cat. Polecenie cat nie potrafi odnaleźć pliku o nazwie w:x:y:z i wyświetla na ekranie odpowiedni komunikat o wystąpieniu błędu. Kiedy zmiennej IFS zostaje nadana nowa wartość (:), podstawiając wartość zmiennej a, powłoka dzieli ją na cztery słowa, z których każde zostaje przesłane jako osobny argument do polecenia cat. W takiej sytuacji polecenie cat raportuje tym razem cztery osobne błędy, po jednym dla plików w, x, y oraz z. Dzielenie słów oparte na znaku dwukropka (:) odbywa się wyłącznie po podstawieniu wartości zmiennej a. Powłoka dzieli wszystkie podstawione słowa w wierszu poleceń zgodnie z listą znaków separujących przechowywanych w zmiennej IFS. Kiedy nie ma podstawienia, nie ma podziału — przyjrzyj się następującej sekwencji poleceń: $ IFS="p" $ export VAR

Choć zmienna IFS przyjmuje wartość p, to jednak litera p w nazwie polecenia stawiana, stąd słowo export nie jest dzielone.

export

nie jest pod-

W przykładzie przedstawionym poniżej wykorzystujemy podstawianie wartości zmiennej, próbując „utworzyć” polecenie export: $ IFS="p" $ aa=export $ echo $aa ex ort

328  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Tym razem podstawienie wartości zmiennej ma miejsce, stąd litera p w tokenie export jest interpretowana jako separator (co można stwierdzić po wynikach działania polecenia echo). Teraz kiedy spróbujesz użyć wartości zmiennej aa do wyeksportowania zmiennej VAR, powłoka interpretuje wiersz polecenia $aa VAR jako ex ort VAR, co w efekcie wygląda jak wiersz polecenia uruchamiający edytor ex z dwoma nazwami plików: ort oraz VAR. $ $aa VAR 2 pliki do edycji "ort" [Nowy plik] Wchodzę w tryb Ex. Wprowadź "visual", aby przejść do trybu Normal. :q E173: 1 więcej plik do edycji :q $

Jeżeli usuniesz zmienną IFS, jako separatorów pól będziesz mógł używać tylko znaków spacji i tabulatora. Jeżeli wartością zmiennej IFS jest null, powłoka bash nie będzie dzieliła słów.

WSKAZÓWKA Wielokrotne wystąpienia znaków separatora Choć powłoka traktuje sekwencje kilku kolejnych znaków spacji lub tabulatora jako pojedynczy separator, to jednak w przypadku innych znaków separatora każde wystąpienie takiego znaku jest traktowane jako osobny separator.

ZMIENNA CDPATH — ZWIĘKSZANIE ZASIĘGU POLECENIA CD Zmienna CDPATH (w powłoce tcsh to zmienna cdpath) pozwala na użycie prostej nazwy katalogu jako argumentu wbudowanego polecenia cd i zmianę katalogu roboczego na katalog inny niż podkatalog bieżącego katalogu roboczego. Jeżeli najczęściej pracujesz w kilku wybranych katalogach, to odpowiednie ustawienie tej zmiennej pozwoli Ci w ich obrębie na szybką zmianę katalogu roboczego, oszczędzając konieczności wpisywania pełnych, długich ścieżek będących argumentami dla polecenia cd. Kiedy zmienna CDPATH nie jest ustawiona i wywołujesz polecenie cd z prostą nazwą katalogu, polecenie cd poszukuje takiego katalogu tylko i wyłącznie pośród podkatalogów bieżącego katalogu roboczego. Jeżeli taki podkatalog nie istnieje, polecenie cd wyświetla odpowiedni komunikat o wystąpieniu błędu. Jeżeli jednak zmienna CDPATH jest ustawiona, polecenie cd poszukuje takiego katalogu pośród wszystkich katalogów wpisanych w zmiennej CDPATH. Jeżeli taki katalog zostanie znaleziony, to automatycznie staje się bieżącym katalogiem roboczym. Kiedy ustawisz zmienną CDPATH, możesz używać polecenia cd i krótkich nazw katalogów do zmiany katalogu roboczego na dowolny podkatalog któregokolwiek z katalogów wpisanych w zmiennej CDPATH. Zmienna CDPATH zawiera listę ścieżek do katalogów, oddzielonych od siebie dwukropkami (podobnie jak to miało miejsce w przypadku zmiennej PATH), i jest zazwyczaj ustawiania w pliku startowym ~/.bash_profile przy użyciu wiersza polecenia podobnego do tego przedstawionego poniżej: export CDPATH=$HOME:$HOME/literatura

Wykonanie takiego polecenia powoduje, że polecenie cd przeszukuje katalog domowy, katalog literatura i na koniec bieżący katalog roboczy. Jeżeli w zmiennej CDPATH nie umieścisz wprost katalogu roboczego, polecenie cd będzie przeszukiwało go tylko wtedy, kiedy poszukiwania we wszystkich innych katalogach wymienionych w zmiennej CDPATH zakończą się niepowodzeniem. Jeżeli chcesz, aby polecenie cd przeszukiwało najpierw bieżący katalog roboczy, powinieneś na początku zmiennej CDPATH umieścić dwukropek (:): export CDPATH=:$HOME:$HOME/literatura

Parametry i zmienne  329

Jeżeli argumentem polecenia cd jest cokolwiek innego niż prosta nazwa katalogu — na przykład ścieżka zawierająca znak ukośnika (/), powłoka na ogół nie bierze pod uwagę ścieżek przechowywanych w zmiennej CDPATH.

ZMIENNE ŚRODOWISKOWE — PODSUMOWANIE W tabeli 8.5 zamieszczamy listę wybranych zmiennych środowiskowych powłoki bash. Podsumowanie wybranych zmiennych środowiskowych powłoki tcsh znajdziesz w rozdziale 9. Tabela 8.5. Zmienne środowiskowe powłoki bash Zmienna

Wartość

BASH_ENV

Ścieżka do pliku startowego dla powłok nieinteraktywnych.

CDPATH

Ścieżka wyszukiwania dla polecenia cd.

COLUMNS

Szerokość ekranu wykorzystywana przez polecenie select.

HISTFILE

Ścieżka do pliku przechowującego historię poleceń (domyślnie ~/.bash_history).

HISTFILESIZE

Maksymalna liczba pozycji zapisywanych w pliku HISTFILE (domyślnie 1000-2000).

HISTSIZE

Maksymalna liczba poleceń zapisywana w historii poleceń (domyślnie 1000).

HOME

Ścieżka do katalogu domowego użytkownika; wykorzystywana jako domyślny argument polecenia cd podczas rozwijania ścieżek zawierających znak tyldy (~).

IFS

Wewnętrzny separator pól (ang. Internal Field Separator), używany do dzielenia słów.

INPUTRC

Ścieżka do pliku startowego biblioteki READLINE (domyślnie ~/.inputrc).

LANG

Zmienna przechowująca ustawienia językowe dla elementów, które nie zostały ustawione przez odpowiednie zmienne LC_*.

LC_

Grupa zmiennych przechowujących ustawienia językowe dla różnych elementów, w skład grupy wchodzą takie zmienne jak LC_COLLATE, LC_CTYPE, LC_MESSAGES czy LC_NUMERIC; aby wyświetlić pełną listę ustawień, powinieneś użyć polecenia locale.

LINES

Wysokość ekranu wykorzystywana przez polecenie select.

MAIL

Ścieżka do pliku przechowującego skrzynkę pocztową użytkownika.

MAILCHECK

Rozmiar interwału czasowego, z jakim powłoka bash sprawdza, czy użytkownik otrzymał nową wiadomość (domyślnie 60 sekund).

MAILPATH

Lista oddzielonych od siebie dwukropkami ścieżek do plików, które powłoka bash sprawdza pod kątem nowych wiadomości.

OLDPWD

Ścieżka do poprzedniego katalogu roboczego.

PATH

Lista oddzielonych od siebie dwukropkami ścieżek do katalogów, w których powłoka bash poszukuje poleceń.

PROMPT_COMMAND

Polecenie, które powłoka bash wykonuje przed wyświetleniem podstawowego znaku zachęty.

PS1

Zmienna przechowująca podstawowy znak zachęty.

PS2

Zmienna przechowująca wtórny znak zachęty.

PS3

Zmienna przechowująca znak zachęty dla menu polecenia select.

PS4

Zmienna przechowująca znak zachęty dla trybu śledzenia wykonywania poleceń.

PWD

Ścieżka do bieżącego katalogu roboczego.

REPLY

Przechowuje wiersz ze standardowego wejścia, odczytany poleceniem read; wykorzystywana przez polecenie select.

330  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

ZNAKI SPECJALNE W tabeli 8.6 zamieszczamy zestawienie znaków, które mają specjalne znaczenie dla powłok bash i tcsh. Tabela 8.6. Znaki specjalne powłoki Znak

Zastosowanie

Znak nowego wiersza, rozpoczyna wykonywanie polecenia.

;

Oddziela polecenia od siebie.

( )

Grupuje polecenia, które będą wykonywane przez podpowłoki, lub identyfikuje funkcje.

(( ))

Rozwija wyrażenia arytmetyczne.

&

Uruchamia polecenie w tle (na drugim planie).

|

Wysyła dane ze standardowego wyjścia poprzedzającego polecenia na standardowe wejście kolejnego polecenia.

|&

Operator sterujący, który wysyła standardowe wyjście i strumień błędów poprzedniego polecenia do standardowego wejścia następnego polecenia.

>

Przekierowanie standardowego wyjścia.

>>

Dołączanie danych ze standardowego wyjścia.


&1 & }

W kolejnym przykładzie tworzona jest prosta funkcja, która wyświetla datę, nagłówek i listę użytkowników, którzy są zalogowani do systemu. Nasza funkcja wykonuje takie same polecenia jak skrypt whoson, który omawialiśmy w sekcji „Tworzenie prostych skryptów powłoki” w nieco wcześniejszej części rozdziału. W tym przykładzie kod funkcji zostaje wprowadzony bezpośrednio z klawiatury. Znaki (>) są wyświetlane przez powłokę automatycznie, jako wtórny znak zachęty (PS2); nie wpisuj ich. $ function whoson () > { > date > echo "Lista aktualnie zalogowanych użytkowników:" > who > } $ whoson wto, 9 sie 2011 15:44:58 CET Lista aktualnie zalogowanych użytkowników: hls console 2011-08-08 08:59 (:0) kuba pts/4 2011-08-08 09:33 (0.0) dawid pts/7 2011-08-08 09:23 (kiwi)

Wbudowane polecenie local może być używane jedynie w funkcji. Powoduje ono, że argumenty są lokalne w danej funkcji i jej funkcjach potomnych. Bez polecenia local zmienne zadeklarowane w funkcji byłyby dostępne także dla powłoki, w której dana funkcja została wywołana. Przedstawiona poniżej funkcja pokazuje użycie polecenia local:

Zmienne lokalne funkcji

$ demo () { > x=4 > local y=8 > echo "demo: $x $y" > } $ demo demo: 4 8 $ echo $x 4 $ echo $y $

Wprowadzona z klawiatury funkcja demo() posiada zadeklarowane dwie zmienne x i y, które wyświetlają przypisane im wartości. Zmienna x została zadeklarowana w zwykły sposób, natomiast y z użyciem słowa kluczowego local. Po wywołaniu funkcji powłoka, w której dana funkcja została wywołana, ma dostęp do zmiennej x, ale nie zna zmiennej y. Więcej przykładów zmiennych lokalnych funkcji przedstawiono w rozdziale 10.

360  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Polecenie export -f umieszcza wskazaną funkcję w środowisku, a tym samym udostępnia ją procesom potomnym.

Eksport funkcji

Jeżeli chcesz, aby funkcja whoson była dostępna bez konieczności wprowadzania jej od nowa po każdym zalogowaniu się do systemu, powinieneś umieścić jej definicję w pliku startowym ~/.bash_profile. Następnie możesz uruchomić ten plik startowy poleceniem (.), aby wprowadzone zmiany od razu odniosły efekt:

Funkcje w plikach startowych

$ cat ~/.bash_profile export TERM=vt100 stty kill '^u' whoson () { date echo " Lista aktualnie zalogowanych użytkowników:" who } $ . ~/.bash_profile

Podczas wywoływania funkcji możesz używać argumentów. Wewnątrz funkcji argumenty wywołania są dostępne jako parametry pozycyjne (ang. positional parameters). Przykład zamieszczony poniżej przedstawia funkcję arg1, która zostaje wprowadzona z klawiatury: $ arg1 ( ) { echo "$1" ; } $ arg1 pierwszy_argument pierwszy_argument

Inny przykład funkcji (funkcja switch) znajdziesz w sekcji „Konfiguracja plików startowych” we wcześniejszej części tego rozdziału.

INFORMACJE DODATKOWE Funkcja, której kod przedstawiamy poniżej, pozwala na eksportowanie zmiennych przy użyciu składni stosowanej w powłoce tcsh. Wbudowane polecenie env wyświetla listę wszystkich zmiennych środowiskowych wraz z wartościami i sprawdza, czy funkcja setenv działa poprawnie: $ cat .bash_profile ... # setenv - uszczęśliwia użytkowników powłoki tcsh function setenv() { if [ $# -eq 2 ] then eval $1=$2 export $1 else echo "Składnia: setenv NAZWA WARTOŚĆ" 1>&2 fi } $ . ~/.bash_profile $ setenv TCL_LIBRARY /usr/local/lib/tcl $ env | grep TCL_LIBRARY TCL_LIBRARY=/usr/local/lib/tcl

Parametr specjalny $# przechowuje wartość reprezentującą liczbę argumentów, z jaką dane polecenie zostało wywołane. Nasza funkcja używa wbudowanego polecenia eval do wymuszenia na powłoce bash dwukrotnego przetwarzania polecenia $1=$2. Ponieważ $1=$2 rozpoczyna się od znaku dolara ($), powłoka traktuje cały ciąg znaków jako pojedynczy token — polecenie. W przypadku zwykłego podstawienia ciąg znaków TCL_LIBRARY=/usr/local/lib/tcl staje się nazwą polecenia, co skutkowałoby powstaniem błędu. Po zastosowaniu polecenia eval drugie przetwarzanie dzieli ciąg znaków zgodnie z oczekiwaniami na trzy osobne tokeny i dzięki temu następuje prawidłowe przypisanie zmiennych. Więcej informacji na temat polecenia eval znajdziesz w rozdziale 10. Polecenie eval

Sterowanie powłoką bash — opcje  361

STEROWANIE POWŁOKĄ BASH — OPCJE W tej sekcji wyjaśnimy, w jaki sposób możesz sterować opcjami powłoki bash z wiersza poleceń oraz jak używać poleceń set oraz shopt. Powłoka używa flag do wskazania ustawionych opcji oraz rozszerza $- na listę ustawionych flag. Więcej informacji na ten temat znajdziesz w rozdziale 10.

OPCJE WYWOŁANIA POLECENIA BASH W wierszu poleceń możesz używać dwóch rodzajów opcji — krótkich i długich. Opcje krótkie składają się ze znaku myślnika, po którym następuje pojedyncza litera. Opcje długie składają się z dwóch myślników, po których następuje ciąg znaków. W wierszu polecenia wywołującego powłokę bash długie opcje muszą zostać umieszczone przed opcjami krótkimi. W tabeli 8.12 zamieszczamy zestawienie kilku najczęściej używanych opcji powłoki. Tabela 8.12. Opcje wiersza polecenia Opcja

Opis

Składnia

Pomoc

Wyświetla informacje o sposobie użycia polecenia.

--help

Bez edycji

Uniemożliwia użytkownikom używanie biblioteki Readline (patrz nieco wcześniej w rozdziale) do edytowania wiersza polecenia powłoki interaktywnej.

--noediting

Bez profilu

Wyłącza odczytywanie następujących plików startowych (patrz we wcześniejszej części rozdziału): /etc/profile, ~/.bash_profile, ~/.bash_login oraz ~/.profile.

--noprofile

Bez rc

Wyłącza odczytywanie pliku startowego ~/.bashrc (patrz we wcześniejszej części rozdziału). Jeżeli powłoka jest wywoływana jako sh, to ta opcja jest ustawiana pomyślnie.

--norc

POSIX

Uruchamia powłokę bash w trybie POSIX.

--posix

Wersja

Wyświetla informacje o wersji powłoki bash i kończy pracę.

--version

Login

Powoduje, że powłoka bash działa tak, jakby to była powłoka logowania.

-l (mała litera „l”)

shopt

Uruchamia powłokę z wybraną opcją shopt (patrz nieco dalej w rozdziale). Opcja -O (wielka litera „O”) włącza tę opcję, +O wyłącza ją.

[±]O [opt]

Koniec opcji

W wierszu poleceń sygnalizuje koniec opcji. Kolejne tokeny są traktowane jak argumenty, nawet jeżeli rozpoczynają się od myślnika.

--

OPCJE POWŁOKI Zachowaniem powłoki Bourne Again Shell możesz również sterować poprzez włączanie lub wyłączanie różnych opcji. Poszczególne opcje można włączać lub wyłączać za pomocą różnych metod. Jedna grupa opcji powłoki jest sterowana za pośrednictwem wbudowanego polecenia set, inna grupa używa do tego celu polecenia shopt. Wiele opcji powłoki możesz również kontrolować bezpośrednio z wiersza poleceń, z którego wywołujesz polecenie bash.

WSKAZÓWKA Opcje polecenia, opcje powłoki czy zmienne? Aby uniknąć nieporozumień w stosowanej terminologii, w tej książce do określenia różnych zachowań powłoki, którymi możesz sterować, będziemy używali określenia opcja powłoki. Na stronach podręcznika info polecenia bash do nazywania takich elementów używane są określenia takie jak „opcje” czy „wartości zmiennych sterujących zachowaniem powłoki”. W jeszcze innych źródłach możesz spotkać się z użyciem określenia atrybuty.

362  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

POLECENIE SET ±O — WŁĄCZANIE I WYŁĄCZANIE OPCJI POWŁOKI Za pomocą wbudowanego polecenia set z opcjami -o lub +o możesz włączać, wyłączać lub wyświetlać niektóre opcje powłoki bash (w powłoce tcsh to polecenie działa nieco inaczej). Na przykład polecenie przedstawione poniżej włącza opcję noclobber (patrz rozdział 5.): $ set -o noclobber

W razie potrzeby możesz tę opcję wyłączyć (ustawienie domyślne) za pomocą następującego polecenia: $ set +o noclobber

Polecenie set -o wywołane bez listy opcji powoduje wyświetlenie na ekranie listy wszystkich opcji powłoki sterowanych poleceniem set oraz ich stanu (włączona lub wyłączona). Polecenie set +o bez listy opcji wyświetla tę samą listę opcji, ale w formacie, którego możesz użyć jako danych wejściowych dla powłoki. W tabeli 8.13 przedstawiamy zestawienie listy opcji powłoki bash. W tabeli nie wymieniono opcji -i, ponieważ nie można jej ustawić. Powłoka ustawia tę opcję, gdy zostanie wywołana jako powłoka interaktywna. Więcej informacji na temat używania polecenia set znajdziesz w rozdziale 10. Tabela 8.13. Opcje powłoki Bourne Again Shell Składnia alternatywna

Opcja

Opis

Składnia

allexport

Automatycznie eksportuje wszystkie zmienne i funkcje, które zostaną utworzone lub zmodyfikowane po wykonaniu tego polecenia; opcja domyślnie wyłączona.

set -o allexport

set -a

braceexpand

Powoduje, że powłoka bash wykorzystuje mechanizm rozwijania zawartości nawiasów klamrowych (patrz nieco dalej w rozdziale); opcja domyślnie włączona.

set -o braceexpand

set -B

cdspell

Automatycznie koryguje błędy pisowni w nazwach katalogów wykorzystywanych jako argumenty polecenia cd; domyślnie wyłączona.

shopt -s cdspell

cmdhist

Zapisuje wszystkie wiersze polecenia wielowierszowego w tym samym rekordzie w pliku historii, w razie potrzeby dodając w odpowiednich miejscach średniki; opcja domyślnie włączona.

shopt -s cmdhist

dotglob

Powoduje, że powłoka bash podczas podstawiania wieloznacznych (patrz rozdział 5.) odwołań do plików uwzględnia pliki, których nazwy rozpoczynają się od znaku kropki (.). Domyślnie taka kropka nie jest uwzględniana, stąd musisz ręcznie wpisywać nazwy plików . oraz .. i nie możesz używać nazw za pomocą wieloznacznych odwołań do plików. Opcja domyślnie wyłączona.

shopt -s dotglob

emacs

Wybiera edytowanie wiersza poleceń w trybie emacs (patrz nieco wcześniej w rozdziale); domyślnie włączona.

set -o emacs

errexit

Powoduje, że powłoka bash kończy działanie, kiedy wykonanie potoku (patrz rozdział 5.), którym może być proste polecenie (patrz rozdział 5.), ale nie struktura sterująca kończy się niepowodzeniem; opcja domyślnie wyłączona.

set -o errexit

set -e

Sterowanie powłoką bash — opcje  363

Tabela 8.13. Opcje powłoki Bourne Again Shell — ciąg dalszy Składnia alternatywna

Opcja

Opis

Składnia

execfail

Powoduje, że skrypt powłoki kontynuuje działanie, kiedy nie może odnaleźć pliku będącego argumentem polecenia exec. Domyślnie w takiej sytuacji skrypt kończy działanie. Opcja domyślnie wyłączona.

shopt -s execfail

expand_aliases

Powoduje podstawianie aliasów (patrz nieco wcześniej w rozdziale). Domyślnie ta opcja jest włączona dla powłok interaktywnych i wyłączona dla powłok nieinteraktywnych.

shopt -s expand_aliases

hashall

Powoduje, że powłoka bash zapamiętuje miejsca, w których odnalazła polecenia, korzystając ze zmiennej PATH (patrz nieco wcześniej w rozdziale); opcja domyślnie włączona.

set -o hashall

histappend

Powoduje, że po zakończeniu działania powłoka bash dołącza historię poleceń do pliku, którego nazwa przechowywana jest w zmiennej HISTFILE (patrz nieco wcześniej w rozdziale); opcja domyślnie wyłączona, powłoka bash domyślnie nadpisuje ten plik.

shopt -s histappend

histexpand

Włącza mechanizm historii poleceń, który domyślnie używa znaków wykrzyknika (patrz nieco wcześniej w rozdziale). Aby wyłączyć podstawianie poleceń z historii, powinieneś wyłączyć tę opcję; opcja jest domyślnie włączona.

set -o histexpand

history

Włącza historię poleceń (patrz nieco wcześniej w rozdziale); opcja domyślnie włączona.

set -o history

huponexit

Powoduje, że kiedy interaktywna powłoka logowania kończy działanie, powłoka bash wysyła sygnał SIGHUP do wszystkich zadań; opcja domyślnie wyłączona.

shopt - s huponexit

ignoreeof

Powoduje, że powłoka bash przed zakończeniem działania musi odebrać co najmniej 10 znaków EOF. Bardzo użyteczne w przypadku połączeń typu dial-up na liniach z dużą ilością zakłóceń; opcja domyślnie wyłączona.

set -o ignoreeof

monitor

Włącza mechanizm sterowania zadaniami (patrz nieco wcześniej w rozdziale); opcja domyślnie włączona.

set -o monitor

nocaseglob

Powoduje, że wieloznaczne odwołania do plików (patrz rozdział 5.) nie zwracają uwagi na pisownię małych i wielkich liter; opcja domyślnie wyłączona.

shopt -s nocaseglob

noclobber

Pomaga uniknąć przypadkowego nadpisania plików (patrz rozdział 5.); opcja domyślnie wyłączona.

set -o noclobber

set -C

noglob

Wyłącza mechanizm rozwijania ścieżek (patrz rozdział 5.); domyślnie opcja wyłączona.

set -o noglob

set -f

set -h

set -H

set -m

364  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Tabela 8.13. Opcje powłoki Bourne Again Shell — ciąg dalszy Opcja

Opis

Składnia

Składnia alternatywna

notify

Przy włączonym mechanizmie sterowania zadaniami (patrz nieco wcześniej w rozdziale) powoduje, że komunikaty o zakończeniu działania procesu drugoplanowego są natychmiast wyświetlane; opcja domyślnie wyłączona, powłoka bash domyślnie czeka z wyświetleniem takiego komunikatu aż do momentu tuż przed wyświetleniem kolejnego znaku zachęty.

set -o notify

set -b

nounset

Podczas próby odwołania się do nieustawionej zmiennej powoduje wyświetlenie komunikatu o błędzie (i w przypadku powłoki nieinterakcyjnej zakończenie działania skryptu); opcja domyślnie jest wyłączona, domyślnie powłoka bash wyświetli w takiej sytuacji pustą wartość zmiennej.

set -o nounset

set -u

nullglob

Powoduje, że powłoka bash rozwija wieloznaczne odwołania do plików (patrz rozdział 5.), które nie przyniosły rezultatów, do postaci pustego ciągu znaków; opcja domyślnie wyłączona, domyślnie powłoka bash przekazuje takie odwołania do plików bez rozwijania.

shopt -s nullglob

pipefail

Wartością kodu wyjścia potoku będzie kod wyjścia ostatniego (najbardziej wysuniętego na prawo) prostego polecenia, którego działanie zakończyło się niepowodzeniem (czyli zwrócona została wartość inna niż zero) w danym potoku. Jeżeli wszystkie polecenia zostały wykonane z powodzeniem, kod wyjścia będzie miał wartość zero. Opcja domyślnie wyłączona, kod wyjścia ostatniego polecenia w potoku powłoka bash przypisuje kodowi wyjścia danego potoku).

set -o pipefail

posix

Uruchamia powłokę bash w trybie POSIX; opcja domyślnie wyłączona.

set -o posix

verbose

Wyświetla wiersz polecenia po jego odczytaniu przez powłokę; opcja domyślnie wyłączona. Zobacz także opis opcji xtrace.

set -o verbose

vi

Wybiera edytowanie wiersza poleceń w trybie vi (patrz nieco wcześniej w rozdziale); opcja domyślnie włączona.

set -o vi

xpg_echo

Powoduje, że wbudowane polecenie echo dokonuje podstawienia (interpretacji) sekwencji znaków ucieczki (z zastosowaniem lewego ukośnika) bez potrzeby używania opcji -e; domyślnie opcja wyłączona (patrz rozdział 10.).

shopt -s xpg_echo

xtrace

Włącza tryb śledzenia wykonywania poleceń powłoki (ang. shell debugging). Wyświetla wartość zmiennej PS4 (patrz nieco wcześniej w rozdziale) po każdym wierszu danych wejściowych wczytanym przez powłokę oraz rozszerza ją (patrz rozdział 10.). Opcja domyślnie wyłączona. Zobacz także opis opcji verbose.

set -o xtrace

set -v

set -x

Przetwarzanie wiersza poleceń  365

POLECENIE SHOPT — WŁĄCZANIE I WYŁĄCZANIE OPCJI POWŁOKI Wbudowane polecenie shopt (ang. shell option) pozwala na włączanie, wyłączanie i wyświetlanie listy opcji powłoki bash, które są sterowane za pomocą tego polecenia. Na przykład polecenie przedstawione poniżej powoduje, że powłoka bash podczas podstawiania wieloznacznych odwołań do plików uwzględnia pliki, których nazwy rozpoczynają się od znaku kropki (opcja -s oznacza set): $ shopt -s dotglob

Domyślnie taka opcja jest włączona. Aby ją wyłączyć, powinieneś wykonać polecenie przedstawione poniżej (opcja -u oznacza unset): $ shopt -u dotglob

Aby wyświetlić bieżący stan wybranej opcji, powinieneś użyć jej nazwy jako jedynego argumentu polecenia shopt: $ shopt dotglob dotglob off

Jeżeli wywołasz polecenie shopt bez żadnych argumentów, na ekranie wyświetlona zostanie lista wszystkich opcji sterowanych za pomocą tego polecenia oraz ich stan. Wykonanie polecenia shopt z opcją -s powoduje wyświetlenie wszystkich opcji sterowanych za pomocą tego polecenia, które są w danej chwili ustawione lub włączone. Wykonanie polecenia shopt z opcją -u powoduje wyświetlenie wszystkich opcji sterowanych za pomocą tego polecenia, które w danej chwili nie są ustawione lub są wyłączone. Lista opcji sterowanych poleceniem shopt została przedstawiona w tabeli 8.13.

WSKAZÓWKA Ustawianie opcji sterowanych przez set ±o za pomocą polecenia shopt W razie potrzeby możesz używać polecenia shopt do włączania lub wyłączania opcji powłoki, które są domyślnie sterowane za pomocą polecenia set ±o. Aby to zrobić, powinieneś używać normalnej składni polecenia shopt z opcjami -s oraz -u i dodać do tego zmienną-o. Na przykład polecenie przedstawione poniżej włącza opcję noclobber: $ shopt -o -s noclobber

PRZETWARZANIE WIERSZA POLECEŃ Niezależnie od tego, czy pracujesz w sesji interaktywnej, czy wykonujesz skrypt powłoki, bash musi przed rozpoczęciem przetwarzania odczytać wiersz polecenia — powłoka bash przed uruchomieniem jakiegokolwiek polecenia musi najpierw odczytać przynajmniej jeden wiersz polecenia. Niektóre wbudowane polecenia powłoki bash, takie jak if czy case, jak również funkcje i cytowane ciągi znaków mogą zajmować wiele wierszy. Kiedy bash rozpoznaje polecenie, które składa się z więcej niż jednego wiersza, przed rozpoczęciem przetwarzania odczytuje całe polecenie. W sesjach interaktywnych powłoka bash wyświetla wtórny znak zachęty (określony przez zmienną PS2, domyślnie jest to znak > (patrz nieco wcześniej w rozdziale) na początku każdego kolejnego wiersza będącego kontynuacją polecenia wielowierszowego. Dzieje się tak aż do momentu, kiedy powłoka rozpozna koniec polecenia: $ echo -ef | > grep emacs dawid 26880 24579 1 14:42 pts/10 00:00:00 emacs notes dawid 26890 24579 0 14:42 pts/10 00:00:00 grep emacs $ function hello () { > echo Jak się masz? > } $

366  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Więcej informacji na ten temat znajdziesz w rozdziale 10. Po odczytaniu całego wiersza polecenia powłoka bash przeprowadza podstawienie ewentualnych poleceń z historii oraz podstawienie aliasów (o ile takie zostały użyte).

PODSTAWIANIE POLECEŃ Z HISTORII W sekcji „Ponowne wykonywanie i modyfikacja poleceń” we wcześniejszej części tego rozdziału omawialiśmy przykłady poleceń, których możesz używać do modyfikacji i ponownego uruchomienia poleceń z listy historii poleceń. Podstawianie poleceń z historii jest to proces, którego powłoka bash używa do zamiany polecenia z historii na wykonywalny wiersz polecenia. Na przykład: kiedy wpiszesz polecenie !!, mechanizm podstawienia poleceń z historii zamieni je na polecenie, które zostało wykonane jako poprzednie. W powłokach interaktywnych mechanizm podstawiania poleceń z historii jest włączony domyślnie; aby go wyłączyć, powinieneś wykonać polecenie set +o histexpand. Mechanizm podstawiania poleceń z historii nie ma zastosowania do powłok nieinterakcyjnych (skryptów powłoki).

PODSTAWIANIE ALIASÓW Aliasy opisane wcześniej w rozdziale podstawiają ciąg znaków zamiast pierwszego słowa prostego polecenia. Domyślnie podstawianie aliasów jest włączone dla powłok interaktywnych i wyłączone dla powłok nieinteraktywnych. Aby wyłączyć podstawianie aliasów, powinieneś wykonać polecenie shopt -u expand_aliases.

PRZETWARZANIE I SKANOWANIE WIERSZA POLECENIA Po zakończeniu przetwarzania poleceń z historii i aliasów powłoka bash jeszcze nie wykonuje polecenia. Jednym z pierwszych zadań, które jeszcze muszą zostać wykonane, jest przetwarzanie i podział ciągu znaków reprezentującego wiersz poleceń na elementy składowe (tokeny). Po podzieleniu tokenów, ale jeszcze przed uruchomieniem polecenia, powłoka skanuje tokeny i dokonuje rozwinięcia wiersza polecenia (ang. command-line expansion).

ROZWIJANIE WIERSZA POLECENIA Zarówno powłoki interaktywne, jak i nieinteraktywne przed przekazaniem wiersza polecenia do wywoływanego programu dokonują rozwinięcia wiersza polecenia. Oczywiście możesz używać powłoki, nie posiadając żadnej wiedzy na temat rozwijania wiersza polecenia, ale z drugiej strony, wiedząc, o co chodzi, możesz znacznie efektywniej wykorzystywać możliwości, jakie powłoka daje Ci do dyspozycji. W tej sekcji omówimy mechanizm rozwijania wiersza polecenia, w jaki wyposażona jest powłoka Bourne Again Shell. Rozwijanie wiersza polecenia powłoki TC Shell przedstawiono w rozdziale 9. Powłoka Bourne Again Shell skanuje każdy token pod kątem różnych rodzajów rozwinięć i podstawień w kolejności przedstawionej poniżej. Większość tych procesów dokonuje zamiany słowa na pojedyncze inne słowo. Jedynie rozwijanie zawartości nawiasów klamrowych, dzielenie na słowa i rozwijanie ścieżek może zamienić szereg słów na polecenie (z wyjątkiem podstawiania zmiennej $@ — patrz rozdział 10.). 1. Rozwijanie zawartości nawiasów klamrowych (patrz poniżej). 2. Rozwijanie znaku tyldy. 3. Podstawianie parametrów i zmiennych. 4. Rozwijanie wyrażeń arytmetycznych. 5. Podstawianie poleceń. 6. Dzielenie na słowa. 7. Rozwijanie ścieżek. 8. Podstawianie procesów. 9. Usuwanie znaków cytowania.

Przetwarzanie wiersza poleceń  367

KOLEJNOŚĆ ROZWIJANIA Kolejność, w jakiej powłoka dokonuje rozwijania wiersza polecenia, ma bezpośredni wpływ na interpretację poleceń. Na przykład: jeżeli ustawisz zmienną na wartość, która wygląda jak instrukcja do wykonania przekierowania strumienia danych ze standardowego wyjścia, a następnie wprowadzisz polecenie, które wykorzystuje wartość tej zmiennej do wykonania przekierowania, możesz oczekiwać, że powłoka bash dokona przekierowania wyjścia. $ SENDIT="> /tmp/saveit" $ echo xxx $SENDIT xxx > /tmp/saveit $ cat /tmp/saveit cat: /tmp/saveit: Nie ma takiego pliku ani katalogu

W rzeczywistości powłoka nie przekierowuje wyjścia — powłoka rozpoznaje przekierowania wejścia i wyjścia przed rozpoczęciem przetwarzania zmiennych. Po rozpoczęciu wykonywania wiersza polecenia w naszym przykładzie powłoka sprawdza go pod kątem przekierowań, nie znajduje żadnych i rozpoczyna przetwarzanie zmiennej SENDIT. Po zastąpieniu nazwy zmiennej jej wartością, >/tmp/saveit, powłoka bash przekazuje argumenty do polecenia echo, które kopiuje je na swoje standardowe wyjście. Plik /tmp/saveit nie zostaje w takiej sytuacji utworzony.

WSKAZÓWKA Znaki cytowania mogą zmienić sposób rozwijania wiersza polecenia Apostrofy i znaki cudzysłowu powodują, że podczas rozwijania wiersza polecenia powłoka zachowuje się inaczej. Użycie cudzysłowu pozwala na przeprowadzenie rozwijania parametrów i zmiennych, ale wyłącza pozostałe rodzaje rozwinięć. Użycie apostrofu wyłącza wszystkie rodzaje rozwinięć.

ROZWIJANIE ZAWARTOŚCI NAWIASÓW KLAMROWYCH Mechanizm rozwijania zawartości nawiasów klamrowych, który wywodzi się z oryginalnej powłoki C Shell (csh), udostępnia wygodny sposób na podawanie nazw plików w sytuacji, kiedy rozwijanie ścieżek nie ma zastosowania. Choć rozwijanie zawartości nawiasów klamrowych jest niemal zawsze stosowane do określania nazw plików, to jednak mechanizm ten może być użyty do generowania innych ciągów znaków — jest to możliwe dzięki temu, że powłoka nie dokonuje próby dopasowania zawartości nawiasów klamrowych do nazw istniejących plików. Mechanizm rozwijania zawartości nawiasów klamrowych jest włączony domyślnie zarówno dla powłok interaktywnych, jak i nieinteraktywnych. W razie potrzeby możesz go wyłączyć, wykonując polecenie set +o braceexpand. Powłoka wykorzystuje również nawiasy klamrowe do izolowania nazw zmiennych (patrz nieco wcześniej w rozdziale). Przykład przedstawiony poniżej doskonale ilustruje sposób działania mechanizmu rozwijania zawartości nawiasów klamrowych. Polecenie ls nie wyświetla żadnych danych, ponieważ w bieżącym katalogu roboczym nie ma żadnych plików. Wbudowane polecenie echo wyświetla ciąg znaków, który powłoka generuje po rozwinięciu zawartości nawiasów klamrowych. $ ls $ echo plik_{jeden,dwa,trzy}.txt plik_jeden.txt plik_dwa.txt plik_trzy.txt

Powłoka rozwija znajdujące się wewnątrz nawiasów klamrowych ciągi znaków oddzielonych od siebie przecinkami do postaci listy ciągów znaków oddzielonych od siebie znakami spacji. Do każdego ciągu znaków z listy dołączany jest prefiks plik_, nazywany również przedrostkiem, oraz sufiks .txt, nazywany również przyrostkiem. Zarówno prefiks, jak i sufiks są opcjonalne. Podczas rozwijania zachowywana jest kolejność występowania ciągów znaków w nawiasach klamrowych (od lewej do prawej). Aby powłoka traktowała nawiasy klamrowe w specjalny sposób i dokonała rozwinięcia ich zawartości, wewnątrz musi się znajdować co najmniej jeden przecinek oraz nie mogą się znajdować żadne białe znaki, które nie są cytowane. Rozwinięcia nawiasów klamrowych mogą być zagnieżdżane.

368  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Rozwijanie zawartości nawiasów klamrowych jest bardzo użyteczne zwłaszcza w sytuacji, kiedy mamy do czynienia z długim prefiksem lub sufiksem. Polecenie przedstawione poniżej kopiuje cztery pliki — main.c, f1.c, f2.c oraz tmp.c — z katalogu /usr/local/src/C do bieżącego katalogu roboczego: $ cp /usr/local/src/C/{main,f1,f2,tmp}.c .

Mechanizmu rozwijania zawartości nawiasów klamrowych możesz również użyć do tworzenia katalogów z powiązanymi nazwami: $ ls -F plik1 plik2 plik3 $ mkdir vrs{A,B,C,D,E} $ ls -F plik1 plik2 plik3 vrsA/ vrsB/ vrsC/ vrsD/ vrsE/

Opcja -F powoduje, że polecenie ls na końcu nazwy każdego katalogu dodaje znak ukośnika (/), a na końcu nazwy każdego pliku wykonywalnego dodaje gwiazdkę (*). Jeżeli do określania nazw katalogów próbowałeś zamiast rozwijania nawiasów klamrowych użyć wieloznacznych odwołań do plików, osiągnięte rezultaty będą inne (i nie takie, jak oczekiwałeś): $ rmdir vrs* $ mkdir vrs[A-E] $ ls -F plik1 plik2 plik3 vrs[A-E]/

Wieloznaczne odwołania do plików dopasowują się do nazw istniejących plików. Ponieważ w poprzednim przykładzie nie zostały odnalezione żadne pliki pasujące do wzorca vrs[A-E], powłoka bash przekazała odwołanie wieloznaczne do polecenia mkdir, które utworzyło katalog o takiej nazwie. Zastosowanie nawiasów kwadratowych w wieloznacznych odwołaniach do plików zostało omówione w rozdziale 5. W nowszych wersjach powłoki bash wyrażenia nawiasów klamrowych mogą zawierać sekwencje pozwalające na generowanie sekwencji znaków. Do wygenerowania sekwencji cyfr lub znaków można użyć poniższej składni:

Sekwencja wyrażenia

{n1..n2[..incr]}

gdzie n1 i n2 to liczby bądź pojedyncze litery, natomiast incr oznacza liczbę. Przedstawiona powyżej składnia działa w powłoce bash w wersji 4.0 lub nowszej. Wersję powłoki możesz sprawdzić, wydając polecenie echo $BASH_VERSION. Opcja incr nie działa w systemie OS X. Jeżeli podasz nieprawidłowe argumenty, powłoka bash wyświetli argumenty w standardowym wyjściu. Poniżej przedstawiono kilka przykładów użycia omówionej składni: $ echo {4..8} 4 5 6 7 8 $ echo {8..16..2} 8 10 12 14 16 $ echo {a..m..3} a d g j m $ echo {a..m..b} {a..m..b} $ echo {2..m} {2..m}

W rozdziale 10. przedstawiono sposób użycia zmiennych do ustalenia wartości używanych przez sekwencję wyrażenia. Także w rozdziale 10. poznasz przykład, w którym sekwencja wyrażenia została wykorzystana do określenia wartości kroku w pętli for...in. Starsze wersje powłoki bash nie obsługują sekwencji wyrażeń. Wprawdzie można wykorzystać narzędzie seq do otrzymania podobnej funkcjonalności, ale wymienione narzędzie nie działa z literami i wyświetla komunikat błędu po otrzymaniu niepoprawnych argumentów. Narzędzie seq stosuje poniższą składnię:

seq

seq n1 [incr] n2

Przetwarzanie wiersza poleceń  369

Opcja -s powoduje, że narzędzie seq używa wskazanego znaku do rozdzielenia danych wyjściowych. Poniżej przedstawiono kilka przykładów użycia narzędzia seq: $ seq 4 8 4 5 6 7 8 $ seq -s\ 8 2 16 8 10 12 14 16 $ seq a d seq: błędny argument zmiennoprzecinkowy: a Napisz 'seq --help' dla uzyskania informacji.

ROZWIJANIE ZNAKU TYLDY W rozdziale 4. przedstawiliśmy skróconą notację pozwalającą na szybkie odwoływanie się do Twojego katalogu domowego lub katalogu domowego innego użytkownika. W tej sekcji bardziej szczegółowo omówimy zasady rozwijania znaku tyldy (ang. tilde expansion). Tylda (~) jest znakiem specjalnym, który pojawia się na początku tokena w wierszu polecenia. Kiedy powłoka bash znajdzie znak tyldy na tej pozycji, przeszuka ciąg znaków aż do pierwszego znaku ukośnika (/) lub jeżeli ukośnik nie zostanie odnaleziony — do końca słowa, a także sprawdzi, czy nie jest to nazwa konta użytkownika. Jeżeli potencjalna nazwa użytkownika jest pustym ciągiem znaków (czyli inaczej mówiąc, jeżeli tylda występuje jako samodzielne słowo lub jeżeli bezpośrednio po niej znajduje się znak ukośnika), powłoka zamiast tyldy podstawia zawartość zmiennej HOME. Kolejny przykład, przedstawiony poniżej, ilustruje takie rozwinięcie, gdzie ostatnie polecenie kopiuje plik o nazwie list z katalogu domowego użytkownika kuba do bieżącego katalogu roboczego. $ echo $HOME /home/kuba $ echo ~ /home/kuba $ echo ~/list /home/kuba/list $ cp ~/list .

Jeżeli ciąg znaków następujący bezpośrednio po znaku tyldy reprezentuje poprawną nazwę konta użytkownika, powłoka zastępuje znak tyldy i nazwę konta pełną ścieżką do katalogu domowego tego użytkownika. Jeżeli ciąg znaków po tyldzie nie jest pusty, ale nie jest też nazwą konta użytkownika, powłoka nie dokonuje żadnego podstawienia: $ echo ~dawid /home/dawid $ echo ~root /root $ echo ~xx ~xx

Znaki tyldy są również wykorzystywane przy operacjach ze stosem nazw katalogów (patrz nieco wcześniej w rozdziale). Oprócz tego token ~+ jest synonimem zmiennej PWD (przechowuje nazwę bieżącego katalogu roboczego), a token ~- jest synonimem zmiennej OLDPWD (przechowuje nazwę poprzedniego katalogu roboczego).

ROZWIJANIE PARAMETRÓW I ZMIENNYCH Występujący w wierszu polecenia znak $, po którym nie następują nawiasy okrągłe, powoduje rozpoczęcie rozwijania parametrów lub zmiennych. Określenie parametry obejmuje w tym przypadku zarówno parametry wiersza polecenia (parametry pozycyjne, patrz rozdział 10.), jak i parametry specjalne (patrz rozdział 10.). Zmienne obejmują zarówno zmienne utworzone przez użytkownika (patrz nieco wcześniej w rozdziale), jak i zmienne środowiskowe powłoki (patrz nieco wcześniej w rozdziale). Takiego podziału nie znajdziesz jednak na stronach podręczników man i info polecenia bash.

370  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Powłoka nie rozwija parametrów ani zmiennych, które zostały ujęte w apostrofy, ani takich, gdzie wiodący znak $ jest cytowany (na przykład poprzedzony znakiem lewego ukośnika lub ujęty w apostrofy). Powłoka nie rozwija również parametrów ani zmiennych, które zostaną ujęte w cudzysłowy.

ROZWIJANIE WYRAŻEŃ ARYTMETYCZNYCH Powłoka dokonuje rozwijania wyrażeń arytmetycznych poprzez obliczanie wyrażenia i zastępowanie go jego wynikiem. W rozdziale 9. znajdziesz informacje na temat rozwijania wyrażeń w powłoce tcsh. W powłoce bash rozwijanie wyrażeń arytmetycznych wymaga użycia następującej składni: $((wyrażenie))

Powłoka oblicza wyrażenie i zastępuje ciąg znaków $((wyrażenie)) wynikiem obliczeń. Użyta składnia jest podobna do składni wykorzystywanej przy podstawianiu poleceń [$(...)]i realizuje podobne zadanie. Wyrażenia $((wyrażenie)) możesz użyć w wierszu polecenia jako argumentu wywoływanego polecenia lub zamiast dowolnej wartości numerycznej. Zasady tworzenia wyrażenia są takie same jak w języku C; możesz korzystać ze wszystkich standardowych operatorów arytmetycznych tego języka (patrz tabela 10.8 w rozdziale 10.). Obliczenia arytmetyczne w powłoce bash są przeprowadzane przy użyciu liczb całkowitych typu integer. Jeżeli nie używasz zmiennych typu integer lub po prostu liczb całkowitych, powłoka w celu dokonania obliczeń musi najpierw zamienić wartości reprezentowane w postaci ciągów znaków na liczby całkowite. Nazw zmiennych znajdujących się wewnątrz wyrażenia nie musisz poprzedzać znakiem dolara ($). W kolejnym przykładzie polecenie read (patrz rozdział 10.) przypisuje odpowiedź użytkownika do zmiennej wiek i następnie za pomocą odpowiedniego wyrażenia arytmetycznego obliczamy liczbę lat, jakie pozostały do osiągnięcia wieku 100 lat: $ cat sprawdź_wiek #!/bin/bash read -p "Ile masz lat? " wiek echo "O rany, już za $((100-wiek)) lat będziesz miał 100 lat na karku!" $ ./sprawdź_wiek Ile masz lat? 55 O rany, już za 45 lat będziesz miał 100 lat na karku!

Nie musisz ujmować wyrażenia w znaki cudzysłowu, ponieważ powłoka bash nie przeprowadza na nim rozwijania ścieżek. Dzięki takiemu rozwiązaniu możesz w wyrażeniach arytmetycznych bez problemów używać znaku gwiazdki (*) jako operatora mnożenia, tak jak to zostało przedstawione na przykładzie poniżej: $ echo W roku nieprzestępnym mamy $((60*60*24*365)) sekund. W roku nieprzestępnym mamy 31536000 sekund.

W kolejnym przykładzie używamy poleceń wc i cut, rozwijania wyrażeń arytmetycznych oraz podstawiania poleceń do obliczenia liczby stron niezbędnych do wydrukowania pliku raport.txt. Polecenie wc (ang. word count) uruchomione z opcją -l zwraca liczbę wierszy tekstu w pliku. Liczba wierszy jest wyświetlana w pierwszych czterech kolumnach (pierwsze cztery znaki) wyników działania polecenia. Po liczbie wierszy wyświetlana jest spacja i nazwa pliku. Polecenie cut (patrz część VI książki) z opcjami -c1-4 powoduje wyodrębnienie pierwszych czterech kolumn (znaków) wyników. $ wc -l raport.txt 351 raport.txt $ wc -l raport.txt | cut -c1-4 351

Znak dolara i pojedyncze nawiasy okrągłe nakazują powłoce wykonanie podstawienia polecenia; znak dolara i podwójne nawiasy okrągłe wskazują wyrażenie arytmetyczne, które zostanie rozwinięte: $ echo $(( $(wc -l raport.txt | cut -c1-4)/66 + 1)) 6

Przetwarzanie wiersza poleceń  371

W powyższym przykładzie standardowe wyjście polecenia wc jest przesyłane za pośrednictwem potoku na standardowe wejście polecenia cut. Ze względu na podstawianie poleceń wyniki działania obu poleceń zastępują polecenia znajdujące się pomiędzy $( a odpowiadającym mu nawiasem zamykającym ). Liczba będąca wynikiem takiej operacji jest następnie dzielona przez 66, czyli liczbę wierszy na stronie i na koniec do wyniku dodawana jest liczba 1 (ponieważ operacje na liczbach całkowitych powodują odrzucenie reszty z dzielenia).

WSKAZÓWKA Mniej znaków dolara ($) Kiedy wewnątrz wyrażenia $((...)) używasz zmiennych, umieszczanie wiodącego znaku dolara ($) przed odwołaniami do nazw zmiennych jest opcjonalne. Takie rozwiązanie pozwala na stosowanie znaków odstępu między operatorami, co znacznie zwiększa przejrzystość wyrażeń. $ x=23 y=37 $ echo $((2*$x + 3*$y)) 157 $ echo $((2*x + 3*y)) 157

Innym sposobem na uzyskanie takiego samego rezultatu bez korzystania z polecenia cut jest przekierowanie standardowego wejścia do polecenia wc tak, że polecenie zamiast pobierać dane z pliku o nazwie wskazanej w wierszu poleceń, pobiera dane bezpośrednio ze standardowego wejścia. Dzięki takiemu przekierowaniu polecenie wc nie wyświetla na ekranie nazwy pliku: $ wc -l < raport.txt 351

Powszechnie stosowaną praktyką jest przypisywanie wyników rozwijania wyrażeń arytmetycznych do zmiennej: $ numpages=$(( $(wc -l < raport.txt)/66 + 1))

Wbudowane polecenie let (niedostępne w powłoce tcsh) oblicza wyrażenia arytmetycznie dokładnie w taki sam sposób, jak to ma miejsce przy użyciu składni $((...)). Polecenie przedstawione poniżej jest pełnym, funkcjonalnym odpowiednikiem polecenia z poprzedniego przykładu:

Wbudowane polecenie let

$ let "numpages=$(wc -l < raport.txt)/66 + 1"

Użycie znaków cudzysłowu powoduje, że spacje (zarówno te widoczne w wierszu polecenia, jak i te będące wynikiem podstawienia) nie dzielą całego wyrażenia na szereg kolejnych argumentów polecenia let. Wartość ostatniego wyrażenia determinuje kod wyjścia polecenia let. Jeżeli wartość ostatniego wyrażenia wynosi 0, polecenie let kończy pracę z kodem wyjścia równym 1, w przeciwnym wypadku polecenie kończy pracę z kodem wyjścia równym 0. Polecenie let może przyjmować wiele argumentów definiowanych w wierszu polecenia: $ let a=5+3 b=7+2 $ echo $a $b 8 9

Kiedy podczas obliczania wyrażeń arytmetycznych za pomocą polecenia let lub $((...)) odwołujesz się do zmiennych, powłoka nie wymaga, aby nazwy zmiennych w wyrażeniach były poprzedzane wiodącym znakiem dolara ($). Niezależnie jednak od tego warto w takich sytuacjach stosować znaki dolara ze względu na spójność zapisu, ponieważ w większości innych przypadków nazwa zmiennej musi być poprzedzona tym znakiem.

372  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

PODSTAWIANIE POLECEŃ Mechanizm podstawiania poleceń powoduje zamianę danego polecenia na wyniki jego działania. Preferowana składnia takiego polecenia w powłoce bash jest następująca: $(polecenie)

Pracując z powłoką bash, możesz również korzystać ze starej, ale nadal akceptowanej wersji składni: `polecenie`

Powłoka uruchamia polecenie w osobnej podpowłoce i zastępuje polecenie razem z otaczającymi je znakami wynikami działania pobranymi ze standardowego wyjścia polecenia. Standardowy strumień błędów polecenia nie ulega zmianie. W przykładzie przedstawionym poniżej powłoka wykonuje polecenie pwd i podstawia zamiast polecenia wyniki jego działania. Następnie powłoka przekazuje wyniki działania polecenia, które stały się już w tej chwili argumentami, do polecenia echo, które wyświetla je na ekranie. $ echo $(pwd) /home/kuba

Skrypt przedstawiony w kolejnym przykładzie przypisuje standardowe wyjścia wbudowanego polecenia pwd do zmiennej where i wyświetla na ekranie komunikat zawierający wartość tej zmiennej: $ cat where where=$(pwd) echo "Używasz katalogu o nazwie $where." $ ./where Używasz katalogu o nazwie /home/dawid.

Choć przykład ten ilustruje sposób przypisywania wyjścia polecenia do zmiennej, to jednak nie jest realistyczny. Wyniki działania polecenia pwd możesz wyświetlić bezpośrednio bez używania zmiennej: $ cat where2 echo "Używasz katalogu o nazwie $(pwd)." $ ./where2 Używasz katalogu o nazwie /home/dawid.

Następne polecenie używa polecenia find do odszukania plików o nazwie README w bieżącym katalogu roboczym i jego podkatalogach. Lista plików będąca wynikiem działania polecenia find staje się listą argumentów polecenia ls: $ ls -l $(find . -name README -print)

Polecenie przedstawione poniżej realizuje dokładnie takie samo zadanie jak poprzednie, z tym że zostało zapisane w starej składni `polecenie`: $ ls -l ‘find . -name README -print‘

Jedną z zalet nowej składni jest to, że pozwala na uniknięcie stosowania dosyć tajemniczych reguł obsługi tokenów, cytowania i znaków ucieczki, które były prawdziwą zmorą „starej” wersji. Kolejną zaletą nowej składni jest to, że kolejne polecenia mogą być zagnieżdżane, czego nie można było zrobić w starej wersji. Na przykład: możesz utworzyć pełną listę wszystkich plików README, których rozmiary przekraczają rozmiar pliku ./README, przy użyciu następującego polecenia: $ ls -l $(find . -name README -size +$(echo $(cat ./README | wc -c)c ) -print )

Aby przekonać się, w jaki sposób powłoka rozwija polecenie, spróbuj uruchomić je po uprzednim wykonaniu polecenia set -x. Jeżeli plik README nie istnieje, polecenie wyświetli po prostu wyniki działania ls -l. Więcej szczegółowych informacji na temat skryptów wykorzystujących podstawienia poleceń znajdziesz w rozdziale 10.

Przetwarzanie wiersza poleceń  373

WSKAZÓWKA $(( kontra $( Ciąg symboli $(( tworzy jeden token, który jest wykorzystywany do rozwijania wyrażeń arytmetycznych, a nie do podstawiania poleceń. Z tego względu musisz dodać spację pomiędzy $( a kolejnym nawiasem (, jeżeli chcesz skorzystać z wywołania podpowłoki wewnątrz $().

PODZIAŁ NA SŁOWA Wyniki rozwijania parametrów i zmiennych, podstawiania poleceń i rozwijania wyrażeń arytmetycznych są dobrymi kandydatami do przeprowadzenia podziału na słowa. Używając poszczególnych znaków zmiennej IFS jako separatorów, powłoka bash dzieli takich „kandydatów” na słowa lub tokeny. Jeżeli zmienna IFS nie jest ustawiona, powłoka bash używa wartości domyślnych (spacje, tabulatory i znaki nowego wiersza). Jeżeli zmienna IFS jest pusta, powłoka bash nie dokonuje podziału na słowa.

ROZWIJANIE ŚCIEŻEK Rozwijanie ścieżek (patrz rozdział 5.), nazywane również generowaniem nazw plików, jest procesem interpretacji wieloznacznych odwołań do plików i podstawiania listy odpowiednich nazw plików. Jeżeli opcja noglob (patrz nieco wcześniej w rozdziale) nie jest włączona, powłoka przeprowadza rozwijanie ścieżek za każdym razem, kiedy napotka wieloznaczne odwołanie do pliku, czyli token zawierający niecytowane znaki *, ?, [ lub ]. Jeżeli powłoka bash nie będzie w stanie zlokalizować żadnego pliku, który będzie pasował do podanego wzorca, taki token zawierający wieloznaczne odwołanie do pliku pozostanie niezmieniony. Powłoka nie usunie takiego tokenu ani nie zamieni go na pusty ciąg znaków — zamiast tego po prostu przekaże go w pierwotnej formie do wywoływanego programu (chyba że włączona jest opcja nullglob, patrz nieco wcześniej w rozdziale). Z kolei powłoka TC Shell powoduje wygenerowanie komunikatu błędu. W pierwszym poleceniu echo na przykładzie zamieszczonym poniżej powłoka pomyślnie dokonuje rozwinięcia wieloznacznego odwołania do plików tmp* i przekazuje trzy tokeny (tmp1, tmp2 i tmp3) do polecenia echo. Wbudowane polecenie echo wyświetla te trzy nazwy plików tak, jak zostały przekazane przez powłokę. Po usunięciu tych trzech plików tmp* za pomocą polecenia rm powłoka podczas próby rozwinięcia odwołania wieloznacznego nie znajdzie żadnych pasujących do wzorca plików i po prostu przekaże niezmienione odwołanie do polecenia echo, które wyświetli na ekranie ciąg znaków otrzymany jako argument wywołania. $ ls tmp1 tmp2 tmp3 $ echo tmp* tmp1 tmp2 tmp3 $ rm tmp* $ echo tmp* tmp*

Domyślnie to samo polecenie w powłoce TC Shell powoduje wyświetlenie komunikatu błędu: $ echo tmp* echo: Brak dopasowania

Kropka, która rozpoczyna nazwę ścieżki lub która następuje po znaku ukośnika (/) w nazwie ścieżki, musi być podana wprost (o ile nie jest włączona opcja dotglob, patrz nieco wcześniej w rozdziale). Włączenie opcji nocaseglob (patrz nieco wcześniej w rozdziale) powoduje, że podczas rozwijania wieloznacznych odwołań do plików powłoka będzie dopasowywała nazwy plików bez zwracania uwagi na pisownię małych i wielkich liter.

374  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) Ujęcie argumentu w znaki cudzysłowu powoduje, że powłoka zawiesza rozwijanie ścieżek oraz wszystkie inne rozwinięcia z wyjątkiem rozwijania parametrów i zmiennych. Ujęcie argumentu w apostrofy całkowicie wyłącza mechanizm rozwijania. W przykładzie przedstawionym poniżej drugie polecenie echo przedstawia zmienną $max umieszczoną pomiędzy znakami cudzysłowu, co pozwala na przeprowadzenie rozwijania parametrów i zmiennych. W rezultacie powłoka podstawia zamiast tej zmiennej jej wartość: sonar. W trzecim poleceniu echo takie rozwinięcie już nie ma miejsca, bo zmienna została umieszczona pomiędzy apostrofami. Ponieważ ani znaki cudzysłowu, ani apostrofy nie pozwalają na rozwijanie ścieżek, dwa ostatnie polecenia wyświetlają nierozwinięty argument tmp*.

Znaki cudzysłowu

$ echo tmp* $max tmp1 tmp2 tmp3 sonar $ echo "tmp* $max" tmp* sonar $ echo 'tmp* $max' tmp* $max

Powłoka dokonuje rozróżnienia pomiędzy wartością zmiennej a odwołaniem do zmiennej i nie rozwija wieloznacznych odwołań do plików, jeżeli występują w wartościach zmiennych. W konsekwencji możesz przypisać zmiennej wartość, która będzie zawierała znaki specjalne, takie jak na przykład gwiazdka (*). W katalogu roboczym w kolejnym przykładzie znajdują się trzy pliki, których nazwy rozpoczynają się od ciągu znaków raport. Jeżeli przypiszesz wartość raport* do zmiennej var, powłoka nie dokona rozwinięcia wieloznacznego odwołania do plików, ponieważ znajduje się ono w wartości zmiennej (w poleceniu nadającym zmiennej wartość). Ciąg znaków raport* nie jest ujęty w znaki cudzysłowu; sam kontekst polecenia zapobiega dokonaniu rozwinięcia takiego odwołania przez powłokę. Po dokonaniu przypisania wbudowane polecenie set (z niewielką pomocą polecenia grep) pokazuje, że wartość zmiennej var to ciąg znaków raport*.

Poziomy rozwijania

$ ls raport* raport1 raport2 raport3 $ var=raport* $ set | grep var var='raport*' $ echo '$var' $var $ echo "$var" raport* $ echo $var raport1 raport2 raport3

Trzy kolejne polecenia echo ilustrują działanie trzech kolejnych poziomów rozwinięcia. Kiedy odwołanie do zmiennej $var jest ujęte w apostrofy, powłoka nie dokonuje żadnego rozwinięcia i przekazuje ciąg znaków $var do polecenia echo, które po prostu wyświetla go na ekranie. W przypadku drugiego polecenia, gdzie odwołanie jest ujęte w znaki cudzysłowu, powłoka dokonuje tylko rozwinięcia zmiennych i podstawia zamiast nazwy zmiennej var (i wiodącego znaku dolara) jej wartość. Rozwijanie ścieżek nie jest przeprowadzane, ponieważ zapobiega temu użycie znaków cudzysłowu. W ostatnim poleceniu powłoka nie jest limitowana znakami cytowania, stąd przed przekazaniem argumentów do polecenia echo wykonuje rozwinięcie i podstawienie zmiennych i następnie rozwinięcie ścieżek.

PODSTAWIANIE PROCESÓW Specjalną cechą powłoki Bourne Again Shell jest zdolność do zamiany argumentów będących nazwami plików na procesy. Użycie argumentu o składni (polecenie) jest zamieniany na nazwę potoku, z którego dane są przesyłane na standardowe wejście polecenia.

Podsumowanie rozdziału  375

W przykładzie przedstawionym poniżej polecenie sort (patrz część VI książki) zostaje wywołane z opcją -m (ta opcja działa poprawnie tylko w sytuacji, kiedy pliki wejściowe zostały już uprzednio posortowane) w celu połączenia dwóch list słów w jedną, wspólną listę. Każde słowo z listy jest generowane przez potok, który pobiera słowa spełniające wzorzec wyszukiwania z pliku i sortuje słowa na liście. $ sort -m -f > $file echo -n "Podaj nazwisko osoby lub nazwę grupy: " read name echo "$name" >> $file echo >> $file cat >> $file echo "----------------------------------------------------" >> $file echo >> $file

a) Co musisz zrobić z tym skryptem, aby można go było uruchomić? b) Dlaczego skrypt korzysta z wbudowanego polecenia read, kiedy pobiera dane z terminala, a następnie używa polecenia cat?

378  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH) 6. Załóżmy, że w Twoim systemie istnieją katalogi /home/dawid/grants/biblios oraz /home/dawid/biblios. Podaj nazwę katalogu roboczego, w jakim znajdzie się użytkownik po wykonaniu poszczególnych sekwencji poleceń przedstawionych poniżej. Za każdym razem wyjaśnij, co się wydarzyło. a) $ pwd /home/dawid/grants $ CDPATH=$(pwd) $ cd $ cd biblios

b) $ pwd /home/dawid/grants $ CDPATH=$(pwd) $ cd $HOME/biblios

7. Podaj dwa sposoby na sprawdzenie identyfikatora PID Twojej powłoki logowania. 8. Wykonaj następujące polecenie: $ sleep 30 | cat /etc/services

Czy polecenie sleep wyświetla jakieś informacje będące wynikiem jego działania? Skąd pobierane są dane na wejściu polecenia cat? Co musi się wydarzyć, zanim powłoka wyświetli znak zachęty?

ĆWICZENIA ZAAWANSOWANE 9. Napisz sekwencję poleceń lub skrypt, który będzie pokazywał, że rozwijanie zmiennych zachodzi przed rozwijaniem ścieżek. 10. Napisz skrypt powłoki wyświetlający nazwę powłoki, z której został wywołany. 11. Wyjaśnij zachowanie następującego skryptu powłoki: $ cat quote_demo twoliner="To jest wiersz numer 1. To jest wiersz numer 2." echo "$twoliner" echo $twoliner

a) Ile argumentów „widzi” każde z poleceń echo zamieszczonych w tym skrypcie? Uzasadnij odpowiedź. b) Zmodyfikuj zmienną środowiskową IFS tak, aby wyniki działania drugiego polecenia echo były takie same jak pierwszego polecenia. 12. Dodaj do znaku zachęty kod wyjścia poprzedniego polecenia, tak aby jego zachowanie było zbliżone do przedstawionego na poniższym przykładzie: $ [0] ls xxx ls: xxx: Nie ma takiego pliku ani katalogu $ [1]

13. Polecenie dirname traktuje swoje argumenty jako ścieżki i przesyła na standardowe wyjście prefiks ścieżki, czyli wszystkie elementy składowe ścieżki z wyjątkiem ostatniego: $ dirname a/b/c/d a/b/c

Jeżeli argumentem wywołania polecenia dirname będzie prosta nazwa pliku (bez znaków /), to wynikiem działania tego polecenia będzie kropka (.): $ dirname simple .

Zaimplementuj polecenie dirname jako funkcję powłoki. Upewnij się, że funkcja zachowuje się poprawnie w przypadku otrzymania takich argumentów jak /.

Ćwiczenia zaawansowane  379

14. Zaimplementuj w postaci funkcji powłoki narzędzie o nazwie basename, które będzie wyświetlało ostatni element ścieżki przekazanej jako argument wywołania. Jeśli na przykład argumentem wywołania polecenia basename będzie ścieżka a/b/c/d, to wynikiem działania tego polecenia będzie d: $ basename a/b/c/d d

15. Polecenie basename systemu Linux posiada opcjonalny, drugi argument. Jeżeli wywołasz to polecenie ze składnią basename ścieżka sufiks, polecenie basename usunie ze ścieżki będącej argumentem wywołania zarówno podany sufiks, jak i prefiks: $ basename src/shellfiles/prog.bash .bash prog $ basename src/shellfiles/prog.bash .c prog.bash

Dodaj taki mechanizm do funkcji, którą napisałeś w ćwiczeniu 14.

380  ROZDZIAŁ 8. POWŁOKA BOURNE AGAIN SHELL (BASH)

9 Powłoka TC Shell (tcsh)

W TYM ROZDZIALE: Skrypty powłoki Uruchamianie i zamykanie powłoki TC Shell Funkcje wspólne powłok Bourne Again Shell i TC Shell Przekierowanie standardowego strumienia błędów Uzupełnianie słów Edycja w wierszu poleceń powłoki Zmienne Odczyt danych wejściowych użytkownika Struktury sterujące Wbudowane polecenia powłoki

CELE ROZDZIAŁU Po przeczytaniu tego rozdziału będziesz potrafił:  Identyfikować pliki startowe powłoki tcsh.  Wyjaśnić działanie zmiennych history, histfile i savehist.  Utworzyć alias używający argumentu wiersza poleceń powłoki.  Przekierowywać standardowy strumień błędów i standardowe wyjście skryptu do dwóch różnych plików.  Skonfigurować i używać funkcji uzupełniania nazw plików, poleceń i zmiennych.  Poprawiać błędy w wierszu poleceń powłoki.  Wyjaśnić działanie wbudowanego polecenia @ podczas pracy ze zmiennymi liczbowymi.  Wyjaśnić działanie zmiennej noclobber.  Używać struktury if do sprawdzania stanu pliku.  Opisać osiem wbudowanych poleceń powłoki.

382  ROZDZIAŁ 9. POWŁOKA TC SHELL (TCSH) Powłoka TC Shell (tcsh) pełni taką samą funkcję jak Bourne Again Shell i inne powłoki — zapewnia interfejs pomiędzy użytkownikiem i systemem operacyjnym Linux. Powłoka TC Shell to interaktywny interpreter wiersza poleceń oraz wysokiego poziomu język programowania. Wprawdzie w danej chwili możesz używać tylko jednej powłoki, ale zwykle będziesz miał możliwość wygodnego przełączania się pomiędzy nimi, gdy wystąpi potrzeba. W rzeczywistości w poszczególnych oknach możesz mieć uruchomione różne powłoki. Materiał przedstawiony w rozdziałach 8. i 10. dotyczy powłok zarówno bash, jak i tcsh, więc zapoznanie się z nimi dostarczy Ci przydanych informacji pomocnych w opanowaniu materiału przedstawionego w bieżącym rozdziale. W tym rozdziale omówiono funkcje tcsh, które zostały zaimplementowane inaczej lub po prostu nie znajdują się w powłoce bash. Strona domowa powłoki tcsh to http://www.tcsh.org/. TC Shell jest rozbudowaną wersją powłoki C Shell (csh) opracowaną w Berkeley dla systemu UNIX. Litera T w nazwie TC Shell pochodzi od nazw systemów operacyjnych TENEX i TOPS-20, które zainspirowały twórców powłoki do zaimplementowania uzupełniania słów oraz innych funkcji. W powłoce tcsh znajduje się wiele funkcji niedostępnych w csh, między innymi uzupełnianie nazw plików i użytkowników, edycja poleceń oraz poprawianie błędów pisowni. Podobnie jak w przypadku csh powłokę tcsh można dostosować do własnych potrzeb, aby stała się bardziej tolerancyjna na błędy popełniane przez użytkownika i łatwiejsza w użyciu. Dzięki ustawieniu odpowiednich zmiennych powłoka może ostrzegać przed przypadkowym wylogowaniem lub nadpisaniem pliku. Wiele popularnych funkcji oryginalnej powłoki C Shell jest teraz dostępnych zarówno w powłoce bash, jak i tcsh. Wprawdzie pewne funkcje powłoki tcsh są dostępne także w powłoce bash, ale różnice występują w składni niektórych poleceń. Na przykład polecenie przypisania w powłoce tcsh ma następującą składnię:

Polecenie przypisania

set zmienna = wartość

Spacje wokół znaku równości są niedozwolone w powłoce bash, ale można je stosować w tcsh (choć nie są wymagane). Zgodnie z konwencją zmienne tcsh są zapisywane małymi literami, nie wielkimi (można jednak używać liter o dowolnej wielkości). Jeżeli odwołasz się do niezdefiniowanej zmiennej (lub tej, której nie została przypisana wartość), to tcsh — w przeciwieństwie do powłoki bash — wygeneruje komunikat błędu. Wreszcie domyślny znak zachęty w tcsh jest przedstawiany w postaci znaku większości (>), choć bardzo często będzie to także pojedynczy znak dolara ($) wraz ze spacją. Przykłady przedstawione w tym rozdziale używają znaku zachęty w postaci tcsh $, aby można było uniknąć pomylenia go ze znakiem zachęty powłoki bash.

WSKAZÓWKA Nie używaj tcsh jako języka programowania Jeżeli masz doświadczenie w pracy z systemem UNIX oraz powłoką C lub TC Shell, prawdopodobnie będziesz chciał używać tcsh jako powłoki logowania. Możesz się jednak przekonać, że TC Shell nie jest tak dobrym językiem programowania jak bash. Jeśli chcesz poznać tylko jeden język programowania powłoki, wybierz bash. Powłoki Bourne Again Shell i dash (patrz rozdział 8.) będąca podzbiorem bash są powszechnie używane w systemie Linux do tworzenia wielu skryptów przeznaczonych do administracji systemem.

SKRYPTY POWŁOKI Powłoka TC Shell może uruchamiać pliki zawierające polecenia tcsh, podobnie jak Bourne Again Shell może wykonywać pliki z poleceniami bash. Wprawdzie koncepcja tworzenia i wykonywania skryptów w obu wymienionych powłokach jest podobna, ale metody deklarowania zmiennych i przypisywania im wartości, a także składnia struktur sterujących są inne. Możesz uruchamiać skrypty bash i tcsh, używając dowolnej z wymienionych powłok jako interpretera poleceń. Istnieją różne metody wskazania powłoki wykonującej skrypt. Więcej informacji na ten temat znajdziesz w sekcji „Znaki #! definiują typ powłoki” w rozdziale 8.

Uruchamianie i zamykanie powłoki TC Shell  383

Jeżeli pierwszym znakiem skryptu jest #, a następny jest inny niż !, powłoka TC Shell wykona dany skrypt za pomocą tcsh. Natomiast jeśli pierwszy znak skryptu jest inny niż #, powłoka tcsh wywoła sh (dowiązanie do dash lub bash) w celu wykonania skryptu.

WSKAZÓWKA Polecenie echo — pozbycie się znaku nowego wiersza Wbudowane polecenie echo powłoki tcsh akceptuje opcje -n i \c, które powodują pozbycie się znaku nowego wiersza normalnie umieszczanego na końcu wiersza. Natomiast wbudowane polecenie echo powłoki bash akceptuje jedynie opcję -n (więcej informacji na ten temat znajdziesz w rozdziale 10., w sekcji „Polecenie read — pobieranie danych wpisywanych przez użytkownika”).

WSKAZÓWKA Zachowanie powłoki Jeśli podczas pracy z interaktywną powłoką TC Shell uruchomisz skrypt, w którym pierwszym znakiem nie jest #, i wywołasz skrypt bezpośrednio (bez poprzedzenia jego nazwy poleceniem tcsh), powłoka użyje polecenia sh (dowiązanie do dash lub bash) w celu wykonania skryptu. Przedstawiony poniżej skrypt został przygotowany do uruchomienia w powłoce tcsh, ale po wywołaniu z poziomu wiersza poleceń powłoki tcsh został wykonany przez bash. Wbudowane polecenie set działa inaczej w powłokach bash i tcsh. Dlatego też poniższy skrypt spowoduje wyświetlenie znaku zachęty, ale nie będzie czekał na wprowadzenie danych przez użytkownika: tcsh $ cat user_in echo -n "Podaj dane wejściowe: " set input_line = "$&2" echo "cat >$i >. Więcej szczegółowych informacji na temat zapisywania i odczytywania danych z procesów znajdziesz w sekcji „Przykłady” w dalszej części tego rozdziału. Funkcja print pozwala na zapisywanie danych do pliku lub procesu. Składnia polecenia print jest następująca:

Zapisywanie danych do pliku

print [nazwa_uchwytu] "tekst"

gdzie nazwa_uchwytu to nazwa uchwytu, której użyłeś w poleceniu open, a tekst to informacja, którą chcesz zapisać. Jak już wcześniej wspominaliśmy, jako nazwy uchwytu możesz użyć również nazw uchwytów domyślnych, STDOUT lub STDERR. Nazwę uchwytu musisz w poleceniu print podawać zawsze

534  ROZDZIAŁ 11. PERL — SKRYPTOWY JĘZYK PROGRAMOWANIA — wyjątkiem są sytuacje, kiedy chcesz wysłać dane na standardowe wyjście programu. Po nazwie uchwytu nie powinieneś wstawiać przecinka; nie powinieneś również umieszczać argumentów polecenia print w nawiasach, ponieważ w obu sytuacjach może to spowodować niepoprawną pracę polecenia. Wyrażenie przedstawione poniżej powoduje odczytanie jednego wiersza tekstu, łącznie ze znakiem NEWLINE (\n) z pliku lub procesu powiązanego z uchwytem nazwa_uchwytu:

Odczytywanie danych z pliku

Takie wyrażenie jest zazwyczaj używane w poleceniach takich jak: $line = ;

które odczytuje jeden wiersz danych z pliku lub procesu reprezentowanego przez uchwyt IN i zapisuje go w zmiennej $line. Aby ułatwić odczytywanie danych z pliku, którego nazwa została podana jako argument wywołania w wierszu polecenia, lub ze standardowego wejścia, Perl udostępnia tzw. magiczny uchwyt pliku (ang. magic file handle); właśnie tego uchwytu będziemy używać w zdecydowanej większości przykładów prezentowanych w tym rozdziale. Zgodnie z tym poprzedni wiersz programu możemy zapisać w następujący sposób:

Magiczny uchwyt pliku ()

$line = ;

Taki uchwyt pliku powoduje, że program napisany w języku Perl działa jak wiele innych narzędzi używanych w systemie Linux: jeżeli program jest wywołany bez żadnych argumentów, odczytuje dane ze standardowego wejścia; jeżeli argumentami wywołania są nazwy plików, program odczytuje dane z podanych plików. Więcej szczegółowych informacji na ten temat znajdziesz w rozdziale 5. (patrz przykłady z poleceniem cat). Polecenie print znajdujące się w pierwszym wierszu kolejnego przykładu zawiera opcjonalną nazwę uchwytu STDOUT; w kolejnym poleceniu print nazwa tego uchwytu została pominięta, a ostatnie polecenie print używa uchwytu STRERR, który powoduje, że dane wysyłane za pomocą polecenia print przekazywane są do standardowego strumienia błędów. Pierwsze polecenie print prosi użytkownika o wpisanie z klawiatury jakiegoś tekstu. Ciąg znaków wysyłany tym poleceniem na ekran jest zakończony spacją, a nie znakiem nowego wiersza (NEWLINE), dzięki czemu użytkownik może wpisać odpowiedź w tym samym wierszu, w którym pojawił się znak zachęty. Drugi wiersz używa „magicznego” uchwytu pliku do odczytania wiersza danych ze standardowego wejścia, który następnie zapamiętywany jest w zmiennej $userline. Ponieważ używamy „magicznego” uchwytu pliku, to jeżeli program file1.pl zostanie wywołany z argumentem w postaci nazwy pliku, dane będą odczytywane z tego pliku (a nie ze standardowego wejścia). W wierszu polecenia wywołującym program file1.pl użyty został token 2> (patrz sekcja „Deskryptory plików” w rozdziale 5.) do przekierowania standardowego strumienia błędów do pliku file1.err (wyniki działania trzeciego polecenia print). $ cat file1.pl print STDOUT "Wpisz jakiś tekst: "; $userline = ; print "1>>>$userline$userline $biggest; } return ($biggest); } $ perl subroutine5.pl Wartość maksymalna: 64

WYRAŻENIA REGULARNE Dodatek A definiuje oraz szczegółowo opisuje wyrażenia regularne, których możesz używać podczas pracy z wieloma narzędziami systemu Linux. Cały materiał omawiany w dodatku A odnosi się również do języka Perl, z wyjątkiem kilku wyraźnie oznaczonych fragmentów. Oprócz mechanizmów opisanych w dodatku A Perl oferuje kilka innych mechanizmów związanych z wyrażeniami regularnymi, które pozwalają na wykonywanie bardzo złożonych operacji przetwarzania tekstu. W tej sekcji omówimy pokrótce niektóre rodzaje wyrażeń regularnych, które bardziej szczegółowo zostały omówione w dodatku A, oraz opiszemy dodatkowe cechy wyrażeń regularnych dostępnych w języku Perl. Omówimy tu również składnię, jaką Perl wykorzystuje do pracy z wyrażeniami regularnymi.

SKŁADNIA I OPERATOR =~ Użycie opcji -l powoduje, że Perl używa polecenia chomp do każdego wiersza danych wejściowych i dodaje znak \n na końcu każdego wiersza wysyłanego na wyjście programu. Przykłady omawiane w tej sekcji używają opcji -l oraz -e (którą omawialiśmy nieco wcześniej w tym rozdziale). Ponieważ program musi być podany w wierszu polecenia jako pojedynczy argument, w przykładach kod programu jest ujęty w apostrofy. Powłoka rozpoznaje znaki cytowania i nie przekazuje ich do interpretera języka Perl.

Opcja -l

WSKAZÓWKA Używanie innych opcji łącznie z opcją -e Kiedy łącznie z opcją -e używasz innych opcji, kod programu musi być dołączony w wierszu polecenia od razu po opcji -e. Podobnie jak w przypadku wielu innych poleceń Perl pozwala na łączenie wielu jednoliterowych opcji w ciąg znaków poprzedzony myślnikiem; jeżeli opcja -e należy do takiego ciągu opcji, musi występować na ostatniej pozycji listy opcji; inaczej mówiąc, możesz użyć wywołania perl -l -e lub perl -le, ale nie perl -e -l ani perl -el. Domyślnie Perl ogranicza wyrażenia regularne znakami prawego ukośnika (/). Pierwszy program przedstawiony poniżej używa operatora =~ do wyszukiwania wzorca ge w ciągu znaków aged. W uproszczeniu możesz przyjąć, że operator =~ oznacza zawiera. Używając innej terminologii, można powiedzieć, że operator =~ określa, czy wyrażenie regularne ge (wzorzec) pasuje do ciągu znaków aged. Wyrażenie regularne użyte w tym przykładzie nie zawiera żadnych znaków specjalnych, a ciąg znaków ge jest po prostu częścią ciągu znaków aged; stąd wyrażenie umieszczone w nawiasach jest prawdziwe i Perl wykonuje polecenie print.

Prawy ukośnik jest domyślnym separatorem

Wyrażenia regularne  541

$ perl -le 'if ("aged" =~ /ge/) {print "prawda";}' prawda

Taki sam rezultat możesz osiągnąć, używając postfiksowej składni polecenia if: $ perl -le 'print "prawda" if "aged" =~ /ge/' prawda

Operator !~ działa odwrotnie do operatora =~. Wyrażenie przedstawione w kolejnym przykładzie jest prawdziwe, ponieważ wyrażenie regularne xy (wzorzec) nie jest częścią ciągu znaków aged:

Operator !~

$ perl -le 'print "prawda" if ("aged" !~ /xy/)' prawda

Jak to zostało wyjaśnione w dodatku A, kropka w wyrażeniach regularnych zastępuje dowolny znak, zatem wyrażenie regularne a..d pasuje do ciągu znaków aged: $ perl -le 'print "prawda" if ("aged" =~ /a..d/)' prawda

Do przechowywania wyrażeń regularnych możesz używać zmiennych. Wyrażenie regularne możesz definiować przy użyciu następującej składni: qr/string/

gdzie string reprezentuje wyrażenie regularne. W kolejnym przykładzie wykorzystujemy powyższą składnię do przypisania wyrażenia regularnego /a..d/ (łącznie z separatorami) do zmiennej $re i następnie używamy tej zmiennej jako wyrażenia regularnego: $ perl -le '$re = qr/a..d/; print "prawda" if ("aged" =~ $re)' prawda

Jeżeli chcesz umieścić znak separatora w samym wyrażeniu regularnym, musisz go cytować. W wyrażeniu regularnym w kolejnym przykładzie pojawia się znak domyślnego separatora, czyli prawy ukośnik (/). Aby uniknąć tego, że Perl będzie interpretował znak / w ścieżce /usr jako koniec wyrażenia regularnego, znak / w tej części wyrażenia jest cytowany za pomocą poprzedzającego go znaku lewego ukośnika (\). Więcej szczegółowych informacji na temat cytowania znaków w wyrażeniach regularnych znajdziesz w dodatku A. $ perl -le 'print "prawda" if ("/usr/doc" =~ /\/usr/)' prawda

Cytowanie wielu znaków w wyrażeniu regularnym przez poprzedzanie ich znakiem lewego ukośnika może łatwo spowodować, że skomplikowane wyrażenie regularne stanie się jeszcze bardziej złożone i trudniejsze do analizy. Aby tego uniknąć, możesz poprzedzić wyrażenie regularne znakiem m i parą znaków, takich jak { }, spełniających rolę separatorów. W przykładzie przedstawionym poniżej znak ^ przywiązuje wyrażenie regularne do początku wiersza (patrz dodatek A): $ perl -le 'print "prawda" if ("/usr/doc" =~ m{^/usr})' prawda

Tej samej składni możesz użyć podczas przypisywania wyrażenia regularnego do zmiennej: $ perl -le '$pn = qr{^/usr}; print "prawda" if ("/usr/doc" =~ $pn)' prawda

Perl wykorzystuje składnię przedstawioną w kolejnym przykładzie do podstawiania ciągów znaków, które pasują do danego wyrażenia regularnego. Składnia takiego wyrażenia jest taka sama jak w przypadku edytora vim czy polecenia sed. W drugim wierszu naszego przykładu komenda s znajdująca się przed wyrażeniem regularnym powoduje, że Perl podstawia ciąg znaków znajdujący się pomiędzy drugim i trzecim ukośnikiem (w naszym przypadku jest to słowo najgorsze) zamiast ciągu znaków pasujących do wyrażenia regularnego podanego między pierwszym i drugim ukośnikiem (najlepsze). Taka konstrukcja domyślnie przyjmuje, że podstawienie dokonywane jest w ciągu znaków znajdujących się z lewej strony operatora =~.

Przypisywanie i zamiana ciągów znaków

542  ROZDZIAŁ 11. PERL — SKRYPTOWY JĘZYK PROGRAMOWANIA $ cat re10a.pl $stg = "To jest najlepsze!"; $stg =~ s/najlepsze/najgorsze/; print "$stg\n"; $ perl re10a.pl To jest najgorsze!

W tabeli 11.3 przedstawiono zestawienie wybranych znaków, nazywanych metaznakami, które w wyrażeniach regularnych języka Perl mają specjalne znaczenie. Więcej szczegółowych informacji na ten temat znajdziesz po wykonaniu polecenia perldoc perlre. Tabela 11.3. Niektóre metaznaki używane w wyrażeniach regularnych w języku Perl Znak

Znaczenie

^ (daszek)

Przywiązuje wyrażenie regularne do początku wiersza (patrz dodatek A).

$ (dolar)

Przywiązuje wyrażenie regularne do końca wiersza (patrz dodatek A).

(...)

Grupuje wyrażenia regularne (patrz nieco dalej w rozdziale).

. (kropka)

Zastępuje dowolny znak z wyjątkiem NEWLINE (\n) — patrz dodatek A.

\\

Zastępuje lewy ukośnik.

\b

Zakotwiczenie wyrażenia w słowie.

\B

Zakotwiczenie wyrażenia poza słowem.

\d

Pojedyncza cyfra z zakresu od 0 do 9 ([0-9]).

\D

Dowolny znak oprócz cyfry ([^0-9] lub [^\d]).

\s

Pojedynczy biały znak (spacja, tabulator, nowy wiersz, powrót karetki, wysunięcie strony).

\S

Pojedynczy znak, bez białych znaków (inaczej [^\s]).

\w

Dowolny „znak słowa” (dowolna litera lub cyfra; [a-zA-Z0-9]).

\W

Dowolny znak niebędący „znakiem słowa” ([^\w]).

DOPASOWANIA ZACHŁANNE Domyślnie Perl wykonuje tzw. dopasowania zachłanne (ang. greedy matching), co oznacza, że wyrażenia regularne starają się odnaleźć najdłuższy pasujący ciąg znaków. W przykładzie przedstawionym poniżej wyrażenie regularne /{.*} / dopasowuje ciąg znaków rozpoczynający się otwierającym nawiasem klamrowym, po którym następuje dowolny ciąg znaków, nawias zamykający i spacja ({usuń mnie} występują dwie pary {usuń mnie}). Perl podstawia zamiast niego pusty ciąg znaków (//). $ cat 5ha.pl $string = "W tym wierszu {usuń mnie} występują dwie pary {zachowaj mnie} nawiasów klamrowych."; $string =~ s/{.*} //; print "$string\n"; $ perl 5ha.pl W tym wierszu nawiasów klamrowych.

W kolejnym przykładzie przedstawimy klasyczny sposób na dopasowanie krótszych ciągów znaków ujętych w nawiasy klamrowe, które poznałeś w poprzednim przykładzie. Taki typ dopasowania jest nazywany dopasowaniem niezachłannym (ang. nongreedy matching) lub dopasowaniem oszczędnym (ang. parsimonious matching). W tym przypadku wyrażenie regularne dopasuje:

Dopasowania niezachłanne (oszczędne)

1. Otwierający nawias klamrowy, po którym następuje… 2. … znak należący do klasy znaków, zawierającej wszystkie znaki z wyjątkiem klamrowego nawiasu zamykającego ([^}]), po którym następuje…

Wyrażenia regularne  543

3. … zero lub więcej wystąpień poprzedniego znaku (*), po których następuje… 4. … zamykający nawias klamrowy, po którym następuje… 5. … spacja. (Daszek na początku definicji klasy znaków oznacza, że klasa zawiera dowolne znaki z wyjątkiem podanych w definicji klasy, stąd klasa [^}] pasuje do każdego znaku, który nie jest zamykającym nawiasem klamrowym). $ cat re5b.pl $string = "W tym wierszu {usuń mnie} występują dwie pary {zachowaj mnie} nawiasów klamrowych."; $string =~ s/{[^}]*} //; print "$string\n"; $ perl re5b.pl W tym wierszu występują dwie pary {zachowaj mnie} nawiasów klamrowych.

Perl udostępnia pewien skrót zapisu, który pozwala na zdefiniowanie oszczędnego dopasowania. W przykładzie przedstawionym poniżej znak zapytania w wyrażeniu {.*?} powoduje, że wyrażenie regularne stara się dopasować najkrótszy możliwy ciąg znaków, który rozpoczyna się od otwierającego nawiasu klamrowego, po którym następuje dowolny ciąg znaków zakończony zamykającym nawiasem klamrowym. $ cat re5c.pl $string = "W tym wierszu {usuń mnie} występują dwie pary {zachowaj mnie} nawiasów klamrowych."; $string =~ s/{.*?} //; print "$string\n"; $ perl re5c.pl W tym wierszu występują dwie pary {zachowaj mnie} nawiasów klamrowych.

OZNACZANIE WYRAŻEŃ Jak to zostało szczegółowo opisane w dodatku A, fragmenty wyrażeń regularnych możesz oznaczać (ang. bracketing expressions) za pomocą nawiasów i następnie przywoływać takie grupy w zastępujących ciągach znaków. Większość narzędzi systemu Linux do oznaczania wyrażeń regularnych używa cytowanych nawiasów okrągłych [na przykład \( oraz \)]. W wyrażeniach regularnych języka Perl nawiasy okrągłe są znakami specjalnymi. Perl pomija znaki lewego ukośnika i do oznaczania wyrażeń regularnych używa niecytowanych nawiasów okrągłych; cytowania nawiasów musisz użyć tylko wtedy, kiedy chcesz użyć nawiasu jako zwykłego znaku w wyrażeniu regularnym. W wyrażeniu regularnym w kolejnym przykładzie nawiasy okrągłe (bez cytowania) zostały użyte do oznaczenia części wyrażenia. Następnie fragment ciągu znaków pasujący do oznaczonego wyrażenia został przypisany do zmiennej, która przechowywała oryginalny, przeszukiwany ciąg znaków. Najpierw program przypisuje ciąg znaków Mam na imię Adam do zmiennej $stg. Kolejne polecenie poszukuje w tej zmiennej ciągu znaków pasującego do wyrażenia regularnego /Mam na imię (.*)/. Część wyrażenia regularnego ujęta w nawiasy dopasowuje ciąg znaków Adam; zmienna $1 w ciągu zastępującym pasuje do pierwszej (i w naszym przypadku jedynej) części wyrażenia regularnego oznaczonej nawiasami. Wynikiem takiej operacji jest zastąpienie ciągu znaków przechowywanego w zmiennej $stg przez ciąg znaków Adam. $ cat re11.pl $stg = "Mam na imię Adam"; $stg =~ s/Mam na imię (.*)/$1/; print "Dopasowanie: $stg\n"; $ perl re11.pl Dopasowanie: Adam

544  ROZDZIAŁ 11. PERL — SKRYPTOWY JĘZYK PROGRAMOWANIA Kolejny przykład wykorzystuje wyrażenia regularne do przeprowadzenia analizy ciągu znaków pod kątem występowania określonych liczb. Dwie zmienne zostają zainicjowane do przechowywania ciągu znaków zawierającego dwie liczby. Trzeci wiersz programu używa wyrażenia regularnego do wyizolowania pierwszej liczby z ciągu znaków. Token \D* zastępuje dowolny ciąg znaków składający się z zera lub więcej znaków niezawierających cyfr; metaznak \D zastępuje dowolny, pojedynczy znak niebędący cyfrą. Kończący znak gwiazdki powoduje, że ta część wyrażenia regularnego przeprowadza dopasowanie zachłanne, które nie obejmuje cyfr (dopasowuje ciąg znaków What is). Oznaczone wyrażenie regularne \d+ dopasowuje ciąg znaków składający się z jednej lub więcej cyfr. Nawiasy nie mają żadnego wpływu na wynik dopasowania; ich zadaniem jest jedynie umożliwienie dopasowania zmiennej $1 w ciągu zastępującym do ciągu znaków dopasowanego przez oznaczone wyrażenie regularne. Finalny token .* dopasowuje resztę ciągu znaków. Ten wiersz przypisuje wartość pierwszej liczby odnalezionej w ciągu znaków do zmiennej $string. Kolejny wiersz jest podobny, ale przypisuje drugą liczbę z ciągu znaków do zmiennej $string2. Polecenie print wyświetla liczby i wynik odejmowania drugiej liczby od pierwszej. $ cat re8.pl $string = "What is 488 minus 78?"; $string2 = $string; $string =~ s/\D*(\d+).*/$1/; $string2 =~ s/\D*\d+\D*(\d+).*/$1/; print "$string\n"; print "$string2\n"; print $string - $string2, "\n"; $ perl re8.pl 488 78 410

Kilka kolejnych przykładów prezentuje niektóre pułapki, na jakie możesz się natknąć, używając w wyrażeniach regularnych niecytowanych nawiasów w sytuacji, kiedy nie miałeś zamiaru oznaczać fragmentu wyrażenia. Pierwszy z tych programów próbuje dopasować nawiasy w ciągu znaków przy użyciu wyrażenia regularnego z niecytowanymi nawiasami, ale ta próba kończy się niepowodzeniem. Wyrażenie regularne ag(e dopasowuje taki sam ciąg znaków jak wyrażenie regularne age, ponieważ nawias jest znakiem specjalnym; z tego powodu takie wyrażenie regularne nie dopasuje ciągu znaków ag(ed). $ perl -le 'if ("ag(ed)" =~ /ag(ed)/) {print "prawda";} else {print "fałsz";}' fałsz

Wyrażenie regularne w kolejnym przykładzie cytuje nawiasy, poprzedzając je znakami lewego ukośnika, co powoduje, że Perl traktuje je jako zwykłe znaki. W takiej sytuacji dopasowanie jest pomyślne. $ perl -le 'if ("ag(ed)" =~ /ag\(ed\)/) {print "prawda";} else {print "fałsz";}' prawda

W następnym przykładzie Perl odnajduje niezamknięty nawias w wyrażeniu regularnym: $ perl -le 'if ("ag(ed)" =~ /ag(e/) {print "prawda";} else {print "fałsz";}' Unmatched ( in regex; marked by =, ponieważ porównywane ze sobą są dwie liczby; porównanie tekstowe wymagałoby użycia operatora porównywania ciągów ge. Polecenie print wysyła wartość identyfikatora UID oraz powiązaną z nim nazwę konta użytkownika do pliku reprezentowanego przez uchwyt $sortout. Polecenie open tworzące ten uchwyt używa potoku, który wysyła dane na wejście polecenia sort –n. Ponieważ polecenie sort (patrz rozdział 3.) nie wysyła na wyjście żadnych danych dopóty, dopóki nie zakończy otrzymywania danych na wejściu, program split3.pl nie wyświetla na ekranie żadnych informacji, dopóki nie zostanie zamknięty uchwyt $sortout, co ma miejsce po zakończeniu odczytywania danych z pliku passwd. $ cat split3.pl #!/usr/bin/perl -w open ($pass, "/etc/passwd"); open ($sortout, "| sort -n"); while ($user = ) { @row = split (/:/, $user); if ($row[2] >= 100) { print $sortout "$row[2] $row[0]\n"; } } close ($pass); close ($sortout); $ ./split3.pl 100 libuuid 101 syslog 102 klog 103 avahi-autoipd 104 pulse ...

Następny przykład zlicza i wyświetla na ekranie argumenty, z którymi został wywołany, wykorzystując do tego celu zmienną @ARGV (patrz we wcześniejszej części rozdziału). Pętla foreach przetwarza kolejne elementy tablicy @ARGV, która przechowuje argumenty wywołania podane w wierszu polecenia. Operator preinkrementacji ++ zwiększa wartość zmiennej $count przed jej wyświetleniem. $ cat 10.pl #!/usr/bin/perl -w $count = 0; $num = @ARGV; print "W wierszu polecenia podałeś $num argumentów:\n"; foreach $arg (@ARGV) { print ++$count, ". $arg\n"; } $ ./10.pl jabłko gruszka banan arbuz mango W wierszu polecenia podałeś 5 argumentów: 1. jabłko 2. gruszka 3. banan 4. arbuz 5. mango

550  ROZDZIAŁ 11. PERL — SKRYPTOWY JĘZYK PROGRAMOWANIA

PODSUMOWANIE ROZDZIAŁU Perl jest językiem programowania, który został utworzony w roku 1987 przez Larry’ego Walla. Od tego czasu Perl przeszedł gwałtowny rozwój, zwiększając swoją funkcjonalność, i obecnie jest bardzo popularnym językiem programowania, wykorzystywanym do przetwarzania tekstów, wykonywania zadań związanych z zarządzaniem systemem, tworzenia oprogramowania systemowego i narzędzi ogólnego przeznaczenia. Jedną z największych zalet języka Perl jest ogromna, licząca tysiące pakietów biblioteka modułów, z których znaczna część jest dostępna w repozytorium CPAN. Narzędzie perldoc pozwala na wyszukiwanie i wyświetlanie dokumentacji języka Perl oraz na tworzenie dokumentacji programów napisanych w języku Perl poprzez osadzenie jej bezpośrednio w kodzie programu przy użyciu specjalnych znaczników pod (ang. plain old documentation). Perl udostępnia trzy rodzaje zmiennych: zmienne skalarne (zmienne pojedyncze, których nazwy rozpoczynają się od znaku $), zmienne tablicowe (zmienne mnogie, których nazwy rozpoczynają się od znaku @) oraz tablice asocjacyjne (zmienne mnogie typu hash, których nazwy rozpoczynają się od znaku %). Zarówno zmienne tablicowe, jak i tablice asocjacyjne przechowują listy elementów, z tym że zawartość zmiennych tablicowych jest uporządkowana według określonej kolejności. Standardowe polecenia kontrolujące przepływ sterowania w programie pozwalają na zmianę kolejności poleceń wykonywanych przez program napisany w języku Perl. Programy w języku Perl mogą wykorzystywać procedury zawierające zmienne lokalne dla danej procedury (zmienne leksykalne). Wyrażenia regularne są jedną z najmocniejszych stron języka Perl. Oprócz możliwości dostępnych w wielu innych narzędziach systemu Linux Perl oferuje rozbudowane mechanizmy wyrażeń regularnych, które pozwalają na wykonywanie złożonych zadań przetwarzania tekstów.

ĆWICZENIA 1. Wymień dwa sposoby włączenia mechanizmu wyświetlania ostrzeżeń w języku Perl. 2. Czym różnią się od siebie zmienne tablicowe i tablice asocjacyjne? 3. W każdym z poniższych przykładów kiedy użyłbyś tablicy asocjacyjnej, a kiedy zmiennej tablicowej? a) Zliczanie adresów IP występujących w pliku dziennika. b) Generowanie listy użytkowników, którzy przekroczyli dopuszczalny limit przydziału pamięci dyskowej (lista będzie następnie użyta do utworzenia raportu). 4. Napisz wyrażenie regularne, które dopasuje ciąg podany w cudzysłowie w następującym zdaniu: Adam powiedział: „Podaj mi ten klucz”, ale go nie usłyszałem. 5. Napisz wyrażenie regularne, które będzie wyszukiwało wszystkie adresy IP występujące w pliku dziennika. 6. Bardzo często w plikach konfiguracyjnych znajduje się wiele komentarzy zawierających między innymi oznaczone jako komentarz domyślne dyrektywy konfiguracyjne. Napisz program, który będzie usuwał komentarze z takich plików konfiguracyjnych.

Ćwiczenia zaawansowane  551

ĆWICZENIA ZAAWANSOWANE 7. Napisz program, który będzie usuwał pliki *~ oraz *.ico z podanej hierarchii katalogów (wskazówka: użyj modułu File::Find). 8. Podaj przykład błędu w programie, dla którego interpreter języka Perl nie wyświetli żadnego ostrzeżenia. 9. Napisz program w języku Perl, który podaje liczbę plików znajdujących się w katalogu roboczym oraz liczbę bajtów w każdej grupie plików, reprezentowanej przez rozszerzenie nazwy. 10. Opisz różnice pomiędzy cytowaniem ciągów znaków przy użyciu apostrofów i znaków cudzysłowu. 11. Napisz program, który skopiuje wszystkie pliki z rozszerzeniem *.ico znajdujące się w podanej hierarchii katalogów do podkatalogu icons zlokalizowanego w Twoim katalogu domowym (wskazówka: użyj modułów File::Find oraz File::Copy). 12. Napisz program, który będzie analizował dzienniki serwera Apache i wyświetlał liczbę bajtów przesłanych dla każdej ze ścieżek. Żądania dostępu zakończone niepowodzeniem powinny być ignorowane. Jeżeli w strukturze witryny znajduje się więcej niż 10 ścieżek, wyświetl tylko pierwsze dziesięć. Poniżej zamieszczono przykładowy wiersz z dziennika serwera Apache. Dwie liczby po nagłówku HTTP/1.1 reprezentują kod odpowiedzi serwera oraz liczbę przesłanych bajtów. Kod 200 oznacza, że żądanie zakończyło się sukcesem. Jeżeli zamiast liczby przesłanych bajtów pojawia się znak -, oznacza to, że żadne dane nie zostały przesłane. __DATA__ 92.50.103.52 - - [19/Aug/2008:08:26:43 -0400] "GET /perl/automated-testing/next_active.gif HTTP/1.1" 200 980 "http://example.com/perl/automated-testing/navigation_bar.htm" "Mozilla/5.0 (X11; U; Linux x86_64; en-US; rv:1.8.1.6) Gecko/20061201 Firefox/3.0.0.6 (Fedora); Blazer/4.0"

552  ROZDZIAŁ 11. PERL — SKRYPTOWY JĘZYK PROGRAMOWANIA

12 Język programowania Python

W TYM ROZDZIALE: Wywołanie Pythona Listy Słowniki Struktury sterujące Odczyt i zapis do pliku Pickle Wyrażenia regularne Definiowanie funkcji Używanie bibliotek Funkcje lambda Listy składane

CELE ROZDZIAŁU Po przeczytaniu tego rozdziału będziesz potrafił:  Wydawać polecenia, używając interaktywnej konsoli Pythona.  Tworzyć i uruchamiać programy Pythona przechowywane w plikach.  Zademonstrować, jak utworzyć listę oraz jak dodawać i usuwać elementy listy.  Opisać słownik i podać przykłady jego wykorzystania.  Opisać trzy struktury sterujące Pythona.  Utworzyć program Pythona, który wykonuje iterację przez listą lub słownik.  Odczytywać i zapisywać dane w pliku.  Zademonstrować przetwarzanie wyjątku.  Zachować obiekt za pomocą pickle().  Utworzyć w Pythonie program korzystający z wyrażeń regularnych.  Zdefiniować funkcję i używać jej w programie.

554  ROZDZIAŁ 12. JĘZYK PROGRAMOWANIA PYTHON

WPROWADZENIE Python to przyjazny i elastyczny język programowania, który jest szeroko stosowany, począwszy od projektów typu open source aż po produkty firm wymienianych na liście Fortune 500. Python jest językiem interpretowanym — w trakcie uruchamiania programu przekształca jego kod na kod bajtowy, który następnie wykonuje w wirtualnej maszynie Pythona. Stanowi więc przeciwieństwo języka C, który jest kompilowany. Różnica pomiędzy językami C i Python polega na tym, że kompilator C kompiluje kod źródłowy C na kod maszynowy przystosowany dla konkretnej architektury. Programy Pythona nie są kompilowane, możesz je uruchamiać w dokładnie taki sam sposób jak skrypt powłoki bash lub języka Perl. Ponieważ programy Pythona nie są kompilowane, to można je przenosić pomiędzy różnymi systemami operacyjnymi i architekturami. Innymi słowy, ten sam program Pythona będzie działał w dowolnym systemie, w którym istnieje wirtualna maszyna Pythona. Python oferuje możliwość programowania zorientowanego obiektowo (ang. Object-Oriented Programming, OOP), choć nie jest to wymagane do używania języka. Bez problemów można używać Pythona, nie mając żadnej lub jedynie minimalną wiedzę na temat programowania zorientowanego obiektowo. W tym rozdziale nie będzie poruszany temat OOP, a jedynie wyjaśnimy najważniejsze funkcje Pythona.

Zorientowany obiektowo

Python jest standardowo dostarczany wraz z setkami gotowych narzędzi logicznie pogrupowanych w biblioteki. Wspomniane biblioteki są dostępne dla programów Pythona, ale nie są wczytywane do pamięci w chwili uruchamiania programu, ponieważ spowodowałoby to znaczne wydłużenie czasu uruchamiania programów Pythona. Zamiast tego całe biblioteki (lub jedynie poszczególne komponenty) są wczytywane do pamięci, gdy będą potrzebne do działania programu.

Biblioteki

Python jest dostępny w dwóch podstawowych wersjach: 2.x i 3.x. W tym rozdziale koncentrujemy się na wersji 2.x, ponieważ ogromna ilość dostępnego obecnie kodu została utworzona właśnie w wersji 2.x języka Python. Przedstawione poniżej polecenia pokazują, że w systemie są zainstalowane dwie wersje Pythona, a polecenie python powoduje uruchomienie Pythona 2.7.3.

Wersje

$ whereis python python: /usr/bin/python /usr/bin/python2.7 /etc/python2.6 /etc/python ... $ ls -l $(which python) lrwxrwxrwx 1 root root 9 Apr 17 10:20 /usr/bin/python -> python2.7 $ python -V Python 2.7.3

WYWOŁYWANIE PYTHONA W tej sekcji omówimy sposoby, na jakie można uruchamiać programy Pythona. Większość przykładów w rozdziale wykorzystuje interaktywną powłokę Pythona, ponieważ można jej używać do usuwania błędów i wykonywania po jednym wierszu kodu i natychmiast widzi się wyniki jego działania. Wprawdzie powłoka Pythona jest użyteczna podczas testowania, ale nie będzie wygodnym rozwiązaniem do tworzenia dłuższych, bardziej skomplikowanych programów. Uruchomienie interaktywnej powłoki Pythona następuje po wywołaniu narzędzia python (podobnie jak uruchamiasz powłokę bash za pomocą polecenia bash). Podstawowy znak zachęty Pythona to >>>. Kiedy Python wymaga podania większej ilości danych wejściowych dla polecenia, wtedy wyświetla drugorzędny znak zachęty (...).

Interaktywna powłoka

$ python Python 2.7.3 (default, Apr 20 2012, 22:39:59) [GCC 4.6.3] on linux2 Type "help", "copyright", "credits" or "license" for more information. >>>

Wprowadzenie  555

Jeżeli używasz interaktywnej powłoki Pythona, polecenia języka możesz wydawać poprzez ich wpisanie, a następnie naciśnięcie klawisza Enter. >>> print 'Dzień dobry!' Dzień dobry!

WSKAZÓWKA Wyświetlanie danych wyjściowych W interaktywnej powłoce Pythona wyświetlane są dane wyjściowe wszystkich poleceń, które nie mają akcji. Dane wyjściowe są podobne do wygenerowanych przez polecenie print, choć niekoniecznie będą dokładnie takie same. Przedstawione poniżej przykłady pokazują dane wyjściowe wyświetlone poprzez wywołanie polecenia print oraz bez użycia wymienionego polecenia: >>> print 'Dzień dobry!' Dzień dobry! >>> 'Dzień dobry!' 'Dzień dobry!' >>> print 2 + 2 4 >>> 2 + 2 4

W Pythonie dane wyjściowe zmiennej mogą być wyświetlone po prostu przez podanie jej nazwy: >>> x = 'Witaj' >>> x 'Witaj'

Przedstawiony powyżej sposób wyświetlania danych wyjściowych nie działa aż do chwili uruchomienia interaktywnej powłoki Pythona. (Python nie stosuje przedstawionego powyżej sposobu wyświetlania danych podczas wykonywania programów zapisanych w plikach). Większość programów Pythona jest zapisywana w plikach tekstowych. Wprawdzie nie jest to wymagane, ale zwykle taki plik ma rozszerzenie .py. Za pomocą polecenia chmod (omówione w części VI książki) możesz plikowi programu Pythona nadać uprawnienia do uruchamiania. Jak wyjaśniono w rozdziale 8., znaki #! na początku pierwszego wiersza pliku nakazują powłoce przekazanie pozostałej części pliku do /usr/bin/python w celu wykonania.

Plik programu

$ chmod 755 gm.py $ cat gm.py #!/usr/bin/python print 'Dzień dobry!' $ ./gm.py Dzień dobry!

Program Pythona można również uruchomić poprzez podanie nazwy pliku programu jako argumentu lub standardowego wejścia polecenia python. $ python gm.py Dzień dobry! $ python < gm.py Dzień dobry! $ cat gm.py | python Dzień dobry! $ echo "print 'Dzień dobry! '" | python Dzień dobry!

Ponieważ wykrzyknik i umieszczony tuż za nim znak inny niż spacja powłoka interpretuje jako numer zdarzenia (patrz rozdział 8.), ostatnie z powyższych poleceń zawiera spację po znaku wykrzyknika.

556  ROZDZIAŁ 12. JĘZYK PROGRAMOWANIA PYTHON Używając opcji -c polecenia python, można uruchomić program z poziomu wiersza poleceń powłoki. W poniższym przykładzie i kolejnych znaki cudzysłowu uniemożliwiają powłoce usunięcie apostrofów z polecenia przed jego przekazaniem Pythonowi.

Wiersz poleceń powłoki

$ python -c "print 'Dzień dobry! '" Dzień dobry!

WSKAZÓWKA Znaki cudzysłowu i apostrofy pełnią taką samą funkcję W języku Python znaków cudzysłowu i apostrofów możesz używać wymiennie, a także jednych do cytowania drugich. Kiedy Python ma wyświetlić ciąg tekstowy ujęty w cudzysłów, całość zostaje opakowana apostrofami. >>> a = "hi" >>> a 'hi' >>> print "'hi'" 'hi' >>> print '"hi"' "hi"

WIĘCEJ INFORMACJI Lokalnie

Na stronach podręcznika systemowego wyświetlanych po wydaniu poleceń man python i man

pydoc.

Z poziomu interaktywnej powłoki Pythona możesz wydać polecenie help() i tym samym użyć funkcji pomocy w Pythonie. Po wywołaniu wymienionej funkcji następuje wyświetlenie informacji, które pomogą Ci w otrzymaniu pomocy. Alternatywne rozwiązanie polega na wydaniu polecenia help('obiekt'), gdzie obiekt oznacza nazwę utworzonego obiektu, nazwę struktury danych lub modułu, na przykład list bądź pickle.

Interaktywna powłoka Pythona

Strona domowa Pythona: http://www.python.org/ Dokumentacja: http://www.python.org/doc/ Indeks PEP (ang. Python Enhancement Proposals): http://www.python.org/dev/peps/ Przewodnik stylu PEP 8 dla kodu tworzonego w Pythonie: http://www.python.org/dev/peps/pep-0008/ PyPI (ang. Python Package Index): https://pypi.python.org/pypi

Internet

ZAPIS DO STANDARDOWEGO WYJŚCIA I ODCZYT ZE STANDARDOWEGO WEJŚCIA Python bardzo ułatwia zapis do standardowego wyjścia oraz odczyt ze standardowego wejścia. Zarówno wejście, jak i wyjście powłoka (na przykład bash) domyślnie łączy z terminalem. Funkcja raw_input() zapisuje dane w standardowym wyjściu i odczytuje dane ze standardowego wejścia. Wartością zwrotną wymienionej funkcji jest odczytany ciąg tekstowy pozbawiony znajdujących się na końcu znaków kontrolnych (Return i nowy wiersz lub tylko nowego wiersza).

Funkcja raw_input()

W przedstawionym poniżej przykładzie funkcja raw_input() wyświetla swój argument (Podaj imię:) i czeka na działanie użytkownika. Kiedy użytkownik wprowadzi dane i naciśnie klawisz Enter, wartość zwróconą przez funkcję raw_input() (czyli wprowadzony przez użytkownika ciąg tekstowy) Python przypisze zmiennej my_in. W poleceniu print znak + powoduje połączenie ciągów tekstowych znajdujących się po obu stronach operatora. W omawianym przykładzie polecenie print powoduje więc wyświetlenie słowa Witaj, następnie wartości zmiennej my_in i wykrzyknika.

Polecenie print

>>> my_in = raw_input ('Podaj imię: ') Podaj imię: Neo >>> print 'Witaj, ' + my_in + '!' Witaj, Neo!

Wprowadzenie  557

FUNKCJE I METODY Podobnie jak w większ