<chapter id="shell-chapter"><title>De &unix; Shell</title>

<blockquote><simpara><phrase>
Het is tamelijk eenvoudig onder het UNIX-besturingssysteem bestanden 
aan te maken. Daarom hebben gebruikers de neiging talloze bestanden aan te maken
waarbij ze van grote hoeveelheden diskruimte gebruik maken. Er wordt
beweerd dat de message-of-the-day die gebruikers aangeeft hun bestanden
op te schonen de enige standaard van alle UNIX-systemen is.
System V.2 administrator's guide
</phrase></simpara></blockquote>

<sect1><title>&unix;-opdrachten</title>
<para>
Wanneer je voor het eerst op een &unix;-systeem inlogt, wordt je
op iets gepresenteerd dat er ongeveer zo uitziet:
</para>

<para>
<screen>
<prompt>/home/larry#</prompt>
</screen>
</para>

<para>
Dat "iets" wordt een prompt genoemd. Zoals de naam al
aangeeft, geeft het je de prompt (spoort het je aan) om een opdracht in te
voeren. Iedere &unix;-opdracht bestaat uit een reeks letters, nummers en 
tekens.<indexterm><primary>teken</primary></indexterm>
Er zijn echter geen spaties. Een aantal geldige &unix;-opdrachten is 
<command>mail</command>, <command>cat</command> en 
<filename>CMU_is_Nummer-5</filename>. Een aantal tekens is niet
toegestaan, we zullen hier later op ingaan. &unix; is tevens
hoofdlettergevoelig. Dit betekent dat <command>cat</command> en
<command>Cat</command> verschillende opdrachten zijn. 
<footnote><para>Hoofdlettergevoeligheid is een zeer
persoonlijk iets.</para></footnote> Een aantal besturingssystemen, 
zoals OS/2<indexterm><primary>OS/2</primary></indexterm> of
Windows NT<indexterm><primary>Windows NT</primary></indexterm> is 
letterkast behoudend, maar niet hoofdlettergevoelig.
In de praktijk maakt &unix; zelden gebruik van een verschillende letterkast.
Een situatie waarbij <command>cat</command> en <command>Cat</command>
verschillende opdrachten zijn, is zeer ongebruikelijk.
</para>

<para>
De prompt wordt door een speciaal programma, genaamd de shell, 
getoond. Shells accepteren opdrachten en voeren deze uit. Ze kunnen ook 
in hun eigen taal worden geprogrammeerd, en programma's geschreven in 
die taal worden "shell-scripts" genoemd.
<indexterm><primary>shell</primary><secondary>programmering</secondary></indexterm><indexterm><primary>shell</primary><secondary>script</secondary></indexterm>
</para>

<para>
Er zijn onder &unix; twee belangrijke typen shells: Bourne shells en C
shells. Bourne shells zijn benoemd naar hun uitvinder, Steven
Bourne.<indexterm><primary>Bourne, Steve R.</primary></indexterm> 
Steven Bourne schreef de oorspronkelijke &unix;-shell 
<application>sh</application> <indexterm><primary>sh</primary></indexterm>, 
en de meeste shells eindigen sindsdien op de letters 
<application>sh</application> om aan te geven dat 
het uitbreidingen zijn  op het oorspronkelijke idee. Er zijn veel 
implementaties van deze shell, en al die specifieke shellprogramma's 
worden Bourne shells genoemd. Een ander klasse shell, C-shells (oorspronkelijk
ge&iuml;mplementeerd door Bill Joy
<indexterm><primary>Joy, Bill</primary></indexterm>), is ook algemeen in het
gebruik. Volgens traditie, werden Bourne shells gebruikt voor shellscripts en
compabiliteit met de oorspronkelijke <application>sh</application> terwijl 
C-shells werden gebruikt voor interactief gebruik.
(C shells hadden het voordeel dat ze betere interactieve features
bezaten maar wat moeilijkere programmeerfeatures.)
</para>

<para>
Linux wordt geleverd met een Bourne shell genaamd <application>bash</application><indexterm><primary>bash</primary></indexterm>
geschreven door de Free Software Foundation.
<indexterm><primary>Free Software Foundation</primary></indexterm> 
<application>bash</application> staat voor <emphasis>B</emphasis>ourne 
<emphasis>A</emphasis>gain <emphasis>Sh</emphasis>ell, een van de
slechte woordspelingen in &unix;. Het is een "geavanceerde" Bourne shell:
het bevat de standaardprogrammeerfeatures aangetroffen in alle
Bourne shells met veel interactieve features over het algemeen
aangetroffen in C-shells. <application>bash</application> is onder 
Linux de standaardshell.
</para>

<para>
Wanneer je voor het eerst inlogt, wordt de prompt door 
<application>bash</application> getoond, en ben je je eerste &unix;-programma
aan het uitvoeren, de <application>bash</application>-shell. Zolang je bent
ingelogd, zal de <application>bash</application>-shell continue actief zijn.
</para>

<sect2><title>Een typische &unix;-opdracht</title>
<para>
De eerste opdracht die je moet kennen is <command>cat</command>.
<indexterm><primary>cat</primary></indexterm>
Voor gebruik typ je <command>cat</command> en dan op <keycap>return</keycap>:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>cat</userinput>
</screen>
</para>

<para>
Als de cursor nu op een eigen regel staat, heb je het goed gedaan. Er
zijn diverse variaties mogelijk op de in te tikken opdracht, waarvan
de een wel en de ander niet het beoogde resultaat op zal leveren.

<itemizedlist>
<listitem><para>
Heb je de opdracht <command>cat</command> niet juist gespeld, dan krijg
je te zien:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput> ct</userinput>
<computeroutput>ct: command not found</computeroutput>
<prompt>/home/larry#</prompt>
</screen>
</para>

<para>
Dus de shell informeert je dat het een programma met de naam
"<literal>ct</literal>" niet kon vinden en geeft je een nieuwe prompt 
om mee te werken. Onthoud daarom dat &unix; hoofdlettergevoelig is: 
<literal>CAT</literal> is een spelfout.
</para></listitem>
<listitem><para>
Het zou ook kunnen dat je witruimte voor de opdracht hebt geplaatst, zoals
in:<footnote><para>De `  '  geeft aan dat de gebruiker een spatie
intikte.</para></footnote>
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>    cat     </userinput>
</screen>
</para>

<para>
Dit produceert het juiste resultaat en voert het programma <application>cat</application> uit.

</para></listitem>
<listitem><para>
Je zou ook de return in kunnen drukken op een lege regel. Ga je gang.
Er gebeurt absoluut niks.
</para></listitem>
</itemizedlist>

Ik veronderstel dat je je nu in <command>cat</command>
<indexterm><primary>cat</primary></indexterm> bevindt.  
Hoopvol vraag je je af wat het doet. Nee, het is geen spel.
<command>cat</command> is een handig utility dat in eerste instantie 
helemaal niet nuttig lijkt. Probeer iets in te tikken en druk dan op de 
return-toets. Je zou het volgende te zien moeten krijgen:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>cat</userinput>
<userinput>Help! Ik zit vast in een Linux programma!</userinput>
<computeroutput>Help! Ik zit vast in een Linux programma!</computeroutput>
</screen>
</para>

<para>
(De benadrukte tekst geeft aan wat ik in <command>cat</command> intikte.) Wat
<command>cat</command> lijkt te doen is de tekst direct naar je terugkaatsen. 
Dit kan soms handig zijn, maar dat is het nu niet. Dus laten we het programma
afsluiten en verdergaan met opdrachten die duidelijkere voordelen hebben.
</para>

<para>
Veel &unix;-opdrachten worden afgesloten door het intikken<footnote><para>Houd 
de toets met het label "Ctrl" ingedrukt en druk dan de "d" in, en 
laat beiden dan los.</para></footnote> van &eof; 
&eof; is het end-of-file teken, of in 't kort EOF.
<indexterm><primary>end-of-file</primary></indexterm>
Als alternatief staat het voor end-of-text
<indexterm><primary>end-of-file</primary></indexterm>, afhankelijk
van het boek dat je leest. Ik zal er naar refereren als een end-of-file.
Het is een besturingsteken dat &unix;-programma's (of een ander programma) 
aangeeft dat je klaar bent met het invoeren van gegevens.
Wanneer <command>cat</command> ziet dat je verder niets anders typt, 
sluit het af.
</para>

<para>
Probeer ook eens het programma <command>sort</command>.
<indexterm><primary>sort</primary></indexterm> Zoals de naam 
ervan al aangeeft is het een sorteerprogramma. Als je een paar regels 
intikt, en dan &eof;, dan zal het deze regels gesorteerd weergeven. 
Deze typen programma's worden <literal>filters</literal>
<indexterm><primary>filter</primary></indexterm> genoemd, omdat ze 
tekst accepteren als invoer, het filteren, en de tekst vervolgens iets 
gewijzigd uitvoeren. Zowel <command>cat</command> als <command>sort</command>
zijn ongebruikelijke filters. <command>cat</command> is ongebruikelijk omdat
het tekst inleest en <emphasis>geen</emphasis> wijzigingen op deze
tekst aanbrengt. <command>sort</command> is ongebruikelijk omdat het regels
inleest en niets als uitvoer geeft totdat het 't EOF teken tegenkomt.
Veel filters worden op een regel-per-regel basis uitgevoerd: ze zullen
een regel inlezen, wat berekeningen uitvoeren en een andere regel als
uitvoer geven.
</para>
</sect2>
</sect1>

<sect1 id="man-section"><title>Jezelf helpen</title>
<para>
<indexterm><primary>help</primary><secondary>online</secondary></indexterm>
De opdracht <command>man</command>
<indexterm><primary>man</primary></indexterm> geeft referentiepagina's weer
voor de opdracht<footnote><para><command>man</command> zal ook informatie 
weergeven over een systeemaanroep, een subroutine, een bestandsformaat, 
enzovoort. In de oorspronkelijke versie van &unix; toonde het exact dezelfde
informatie als die in de afgedrukte documentatie. Thans ben je waarschijnlijk 
alleen ge&iuml;nteresseerd in hulp over opdrachten.</para></footnote>
die je opgeeft. Bijvoorbeeld:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>man cat</userinput>
<computeroutput>
cat(1)                                                     cat(1)

NAAM
  cat - Aaneenschakelen of weergeven van bestanden

SYNTAX
  cat [-benstuvAET] [--number] [--number-nonblank] [--squeeze-blank]
  [--show-nonprinting] [--show-ends] [--show-tabs] [--show-all]
  [--help] [--version] [bestand...]

BESCHRIJVING
  In deze manpage wordt de GNU-versie van cat beschreven ...
</computeroutput>
</screen>
</para>

<para>
Er is ongeveer een gehele pagina met informatie over <command>cat</command>.
Probeer <command>man</command> nu uit.  Verwacht niet dat je de gegeven 
manpage al begrijpt.
Manpages veronderstellen gewoonlijk al heel wat kennis van &unix;. Kennis
die je wellicht nog niet hebt. Wanneer je de pagina hebt gelezen, zie
je wellicht een klein zwart blokje onderaan je scherm vergelijkbaar met
"<literal> --more--</literal>" of "<literal>Line 1</literal>".  Dit is de
more-prompt, en je zult het leren waarderen.
</para>

<para>
In plaats van de tekst van je scherm af te laten scrollen, stopt
<command>man</command> aan het einde van elke pagina, wacht het todat 
je besluit wat nu te doen. Druk op de <keycap>Spatiebalk</keycap> als 
je gewoon verder wilt gaan met de volgende pagina. Wanneer je de manpage 
wilt verlaten die je aan het lezen bent, druk je gewoon op de
<keycap>q</keycap>. Je keert terug naar de shellprompt en het wacht daar op je
totdat je weer een nieuwe opdracht invoert.
</para>

<para>
<command>man</command> kent tevens een trefwoordfunctie. Stel bijvoorbeeld dat je bent 
ge&iuml;nteresseerd in alle opdrachten die te maken hebben met Postscript, 
de printerbesturingstaal van Adobe. Typ <command>man -k ps</command>
of <command>man -k PostScript</command>.
Je krijgt daarmee een lijst van alle opdachten, systeemaanroepen en andere 
gedocumenteerde delen van &unix; te zien waarin het woord
"ps" (of "Postscript") in de naam of de beknopte beschrijving voorkomt.
Dit kan erg handig zijn als je op zoek bent naar een tool om iets voor
elkaar te krijgen, maar je weet de naam ervan niet, of dat het
zelfs ook maar bestaat!
</para>
</sect1>

<sect1><title>Informatie opslaan</title>
<para>
Filters zijn erg nuttig zodra je een ervaren gebruiker bent, maar
ze hebben een klein probleem. Hoe sla je de informatie op?
Er wordt beslist niet van je verwacht dat je elke keer dat je het programma
gebruikt alles weer opnieuw intikt. Natuurlijk niet.
&unix; voorziet in <emphasis>bestanden</emphasis> en 
<emphasis>directory's</emphasis>.
<indexterm><primary>directory</primary></indexterm>
</para>

<para>
Een directory is te vergelijken met een folder: het bevat stukken papier, 
of bestanden. Een grote folder kan zelfs andere folders bevatten, 
directory's kunnen zich binnen directory's bevinden. Onder &unix; wordt 
de verzameling directory's en bestanden een bestandssysteem genoemd.
<indexterm><primary>bestandssysteem</primary></indexterm>
In beginsel bestaat het bestandssysteem uit een directory, genaamd de
"root" directory.
<indexterm><primary>directory</primary><secondary>root</secondary></indexterm>
Binnen deze directory bevinden zich meer directory's, en binnen die 
directory's bevinden zich bestanden en nog meer directory's.
<footnote><para>Mogelijk is er een limiet aan hoe "diep" het bestandssysteem
kan gaan. (Ik heb deze limiet nog nooit bereikt, directory's kunnen makkelijk
10 niveaus diep zijn.)</para></footnote>
</para>

<para>
Elk bestand en iedere directory heeft een naam. Er is zowel een korte naam
aan toegekend welke gelijk kan zijn aan de naam van een ander bestand of andere
directory elders op het systeem, als een lange naam welke uniek is.
Een korte naam voor een bestand kan bijvoorbeeld <filename>joe</filename>
zijn, met als volledige naam <filename>/home/larry/joe</filename>. De 
volledige naam wordt gewoonlijk het <emphasis>directorypad</emphasis>
<indexterm><primary>directorypad</primary></indexterm>
genoemd. Het directorypad kan in een reeks directory's worden opgesplitst. 
Zo wordt bijvoorbeeld <filename>/home/larry/joe</filename> gelezen als:
</para>

<para>
<table frame="all"><title><filename>/home/larry/joe</filename></title>
<tgroup cols="2" align="left" colsep="1" rowsep="1">
<tbody>
<row>
 <entry align="center">/</entry>
 <entry>De eerste slash geeft de rootdirectory aan</entry>
</row>
<row>
 <entry>home/</entry>
 <entry>Dit duidt op de directory met de naam <literal>home</literal>.
  Het bevindt zich binnen de rootdirectory.
 </entry>
</row>
<row>
  <entry>larry/</entry>
  <entry>Dit is de directory <filename>larry</filename>, die zich
  binnen <filename>home</filename> bevindt.</entry>
</row>
<row>
  <entry>joe</entry>
  <entry><filename>joe</filename> komt in <filename>larry</filename>
  voor. Een pad zou kunnen verwijzen naar een directory of een bestandsnaam,
  dus dat geldt ook voor <filename>joe</filename>. Alle items 
  <emphasis>voor</emphasis> de korte naam moeten directory's zijn.</entry>
</row>
</tbody>
</tgroup>
</table>
</para>

<para>
Een makkelijke manier om dit te visualiseren is een boomdiagram.
Kijk voor een diagram van een typisch Linux-systeem naar
<xref linkend="standard-dirtree"/>.
Dit diagram is niet compleet, een volledig Linux systeem bestaat uit
meer dan 8000 bestanden!
en het toont slechts een paar van de standaarddirectory's.
Dus er kunnen wat directory's in het diagram zijn getekend die zich niet
op je systeem bevinden, en op je systeem bevinden zich vrijwel zeker
directory's die hier niet zijn weergegeven.
</para>

<figure id="standard-dirtree" float="0">
<title>Een typisch (ingekorte) Unix directorystructuur</title>
<graphic fileref="png-files/standard-dirtree.png"></graphic>
</figure>

<sect2><title>Directory's bekijken met <command>ls</command></title>
<para>
Nu je weet dat er bestanden en directory's bestaan, moet er een manier zijn
om ze te manipuleren. Die is er inderdaad. De opdracht <command>ls</command>
<indexterm><primary>ls</primary></indexterm>
is &eacute;&eacute;n van de belangrijkste. Het geeft een 
<emphasis>l</emphasis>ij<emphasis>s</emphasis>t met bestanden.
Probeer je <command>ls</command> als opdracht, dan zie je:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>ls</userinput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Dat klopt, je ziet niets. &unix; is met opzet beknopt: het geeft je niets,
zelfs geen "no files" als er geen bestanden zijn.
Dus het gebrek aan uitvoer was voor <command>ls</command> de manier 
om aan te geven dat het geen bestanden vond.
</para>

<para>
Maar ik zei zojuist dat er wel 8000 of meer bestanden zouden
kunnen zijn: waar zijn die dan? We hebben hier te maken met het concept
"huidige" directory. Aan je prompt kun je zien dat je huidige directory
<filename>/home/larry</filename> is, waarin zich geen bestanden bevinden.  
Probeer de rootdirectory, als je een bestandenlijst wilt van een actievere
directory:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt> <userinput>ls /</userinput>
<computeroutput>bin      etc      install  mnt      root     user     var
dev      home     lib      proc     tmp      usr      vmlinux</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
In bovenstaande opdracht "<command>ls</command>", is de directory 
"<command>/</command>" een parameter. Het eerste woord van de opdracht 
is de opdrachtnaam, en alles wat daarna komt is een parameter. Parameters 
passen gewoonlijk aan waarop het programma werkt---voor <command>ls</command>
geven de parameters aan van welke directory je een lijst wilt. Sommige 
opdrachten kennen speciale parameters genaamd opties of switches. 
Probeer eens:
</para>

<para>
<screen>
<prompt>/home/larry# ls -F / </prompt>
<computeroutput>bin/      etc/      install/  mnt/      root/     user/     var@
dev/      home/     lib/      proc/     tmp/      usr/      vmlinux</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
De <option>-F</option> is een optie. Een optie is een speciaal soort
parameter welke begint met een koppelteken en wijzigt hoe het programma
wordt uitgevoerd, maar niet waarop het programma wordt uitgevoerd.
Voor <command>ls</command>, is <option>-F</option> een optie waarmee 
je kunt zien welke items directory's zijn, welke de speciale bestanden, 
welke programma's zijn en welke de normale bestanden. Alles met een slash 
is een directory. We zullen later verder op de features van 
<command>ls</command> ingaan. Het is een wonderbaarlijk complex programma!
</para>

<para>
Er zijn hier nu twee lessen uit te leren. Ten eerste moet je leren wat
<command>ls</command> doet. Probeer een paar andere directory's die worden 
getoond in <xref linkend="standard-dirtree"/>, en kijk wat hierin staat. 
Natuurlijk zullen een aantal leeg zijn, en in sommige staan heel, veel 
bestanden. Ik raad je <command>ls</command> zowel met als zonder de 
optie <option>-F</option> uit te proberen. Bijvoorbeeld 
<command>ls /usr/local</command> geeft te zien:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>ls /usr/local</userinput>
<computeroutput>archives  bin       emacs     etc       ka9q      lib       tcl
</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
De tweede les is wat algemener. Veel &unix;-opdrachten zijn net als
<command>ls</command>. Ze hebben opties die gewoonlijk uit 
&eacute;&eacute;n teken bestaan
voorafgegaan door een streepje, en ze hebben parameters. In tegenstelling
tot <command>ls</command> <emphasis>vereisen</emphasis> sommige opdrachten
bepaalde parameters en/of opties. Om te laten zien hoe opdrachten er 
over het algemeen uitzien, maken we gebruik van de volgende vorm:

<cmdsynopsis>
<command>ls</command>
<arg>-aRF</arg>
<arg><replaceable>directory</replaceable></arg>
</cmdsynopsis>

Voortaan zal ik dergelijke opdrachtsjablonen gebruiken voordat ik een nieuwe
opdracht introduceer. Het eerste woord is de opdracht
(in dit geval <command>ls</command>). Volgend op de opdracht staan alle 
parameters. Optionele parameters staan tussen vierkante haken ("[" en "]").
Meta-variabelen worden <emphasis>benadrukt</emphasis>; dit zijn woorden die
de plaats innemen van feitelijke parameters.
(Hierboven zie je bijvoorbeeld <emphasis>directory</emphasis>, dat moet worden
vervangen door de naam van een echte directory.)
</para>

<para>
Een optie is een speciaal geval. Opties worden omsloten door vierkante haken,
maar je kunt elk daarvan nemen zonder ze allemaal te gebruiken. 
Als bijvoorbeeld bij een opdracht als <command>ls</command> drie
opties worden gegeven, dan heb je acht verschillende manieren om de opdracht
uit te voeren: met of zonder elk van de opties.
(Contrast <command>ls -R</command> met <command>ls -F</command>).
</para>
</sect2>

<sect2><title>De huidige directory en <command>cd</command></title>
<para>
<cmdsynopsis>
<command>pwd</command>
</cmdsynopsis>

Het gebruik van directory's zou omslachtig worden als je elke keer dat
je een directory wilde benaderen het volledige pad in zou moeten tikken.
In plaats daarvan kennen &unix;-shells een feature genaamd de
"huidige", "actieve",  of "werk" directory. In je huidige setup zal de 
directory naar alle waarschijnlijkheid in je prompt worden weergegeven: 
<filename>/home/larry</filename>. Probeer als dit niet zo is de opdracht 
<command>pwd</command>, voor <emphasis>p</emphasis>resent 
<emphasis>w</emphasis>orking <emphasis>d</emphasis>irectory. 
(Soms toont de prompt de naam van de machine. 
Dit is slechts alleen dan van nut in een netwerkomgeving met veel 
verschillende machines.)<indexterm><primary>pwd</primary></indexterm>
<indexterm><primary>directory</primary><secondary>huidige</secondary></indexterm><indexterm><primary>directory</primary><secondary>werk</secondary></indexterm>
</para>

<para>
<screen>
<prompt>mousehouse> </prompt><userinput>pwd</userinput>
<computeroutput>/home/larry</computeroutput>
<prompt>mousehouse> </prompt>
</screen>
</para>

<para>
<cmdsynopsis>
<command>cd</command> 
<arg><replaceable>directory</replaceable></arg>
</cmdsynopsis>
</para>

<para>
Zoals je kunt zien, geeft <command>pwd</command> aan wat je huidige 
directory<footnote><para>Je ziet beide termen in dit boek: huidige directory
of werkdirectory. Ik geef de voorkeur aan "huidige werkdirectory", alhoewel
de andere vorm soms zal worden gebruikt.</para></footnote> is; een zeer 
simpele opdracht. 
De meeste opdrachten zijn standaard van toepassing op de huidige directory.
De opdracht <command>ls</command> toont zonder parameters bijvoorbeeld
de inhoud van de huidige directory. We kunnen onze huidige directory 
wijzigen met <command>cd</command><indexterm><primary>cd</primary></indexterm>
Probeer bijvoorbeeld eens:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>cd /home</userinput>
<prompt>/home# </prompt><userinput>ls -F</userinput>
<computeroutput>larry/     sam/       shutdown/  steve/     user1/</computeroutput>
<prompt>/home# </prompt>
</screen>
</para>

<para>
Als je de optionele parameter <emphasis>directory</emphasis>
achterwege laat, keer je terug naar je homedirectory of oorspronkelijke
directory. Anders brengt <command>cd</command> je naar de opgegeven directory. 
Nog een voorbeeld:
</para>

<para>
<screen>
<prompt>/home# </prompt><userinput>cd</userinput>
<prompt>/home/larry# </prompt><userinput>cd /</userinput>
<prompt>/# </prompt><userinput>cd home</userinput>
<prompt>/home# </prompt><userinput>cd /usr</userinput>
<prompt>/usr# </prompt><userinput>cd local/bin</userinput>
<prompt>/usr/local/bin# </prompt>
</screen>
</para>

<para>
Zoals je kunt zien, kan <command>cd</command> overweg met absolute en 
met relatieve adressen. Een absoluut pad begint met een <filename>/</filename>
en specificeert alle directory's voorafgaand aan die je wilt. Een
relatief pad staat in relatie met je huidige directory. In
bovenstaand voorbeeld, voerde ik een relatieve verplaatsing uit naar
<filename>local/bin</filename> toen ik me bevond in <filename>/usr</filename>.
<filename>local</filename> is een directory
onder <filename>usr</filename> en <filename>bin</filename> is een 
directory onder <filename>local</filename>! 
(<command>cd home</command> was ook een relatieve directory wijziging.)
</para>

<para>
Er bestaan twee directory's die <emphasis>alleen</emphasis> voor 
relatieve padnamen worden gebruikt: "<filename>.</filename>" en
"<filename>..</filename>"
<indexterm><primary>directory</primary><secondary>huidige</secondary></indexterm><indexterm><primary>directory</primary><secondary>parent</secondary></indexterm>. 
De directory "<filename>.</filename>" verwijst naar de huidige directory en
"<filename>..</filename>" is de parent directory.
Dit zijn "shortcut" directory's.  Ze komen in <emphasis>elke</emphasis>
directory voor, maar passen niet echt in het "folder in een folder" concept.
Zelfs de rootdirectory heeft een parentdirectory, het is zijn eigen
parent!
</para>

<para>
Het bestand <filename>./chapter-1</filename> wordt in de huidige directory
het bestand met de naam <filename>chapter-1</filename> genoemd. Zo nu en dan
moet je de "<filename>./</filename>" voor een aantal opdrachten zetten, 
willen ze werken, alhoewel dit zeldzaam is. In de meeste gevallen zullen 
<filename>./chapter-1</filename> en <filename>chapter-1</filename>
identiek zijn.
</para>

<para>
De directory "<filename>..</filename>" is handig wanneer een stapje terug
moet worden gegaan in de directorystructuur:
</para>

<para>
<screen>
<prompt>/usr/local/bin# </prompt><userinput>cd ..</userinput>
<prompt>/usr/local# </prompt><userinput>ls -F</userinput>
<computeroutput>archives/  bin/       emacs@     etc/       ka9q/      lib/       tcl@</computeroutput>
<prompt>/usr/local# </prompt><userinput>ls -F ../src</userinput>
<computeroutput>cweb/      linux/     xmris/</computeroutput>
<prompt>/usr/local#</prompt>
</screen>
</para>

<para>
In dit voorbeeld ging ik naar de parentdirectory door gebruik te maken
van de opdracht <command>cd ..</command>, en gaf ik de opdracht voor het tonen
van een directorylisting van <command>/usr/src</command> vanuit 
<filename>/usr/local</filename> met <filename>../src</filename>. 
Als ik in <filename>/home/larry</filename> zou zijn geweest, zou het
typen van <filename>ls -F ../src</filename> me niet verder hebben geholpen!
</para>

<para>
De directory <filename>~</filename> is een alias voor je 
homedirectory:
<indexterm><primary>directory</primary><secondary>home</secondary></indexterm>
</para>

<para>
<screen>
<prompt>/usr/local# </prompt><userinput>ls -F ~/</userinput>
<prompt>/usr/local# </prompt>
</screen>
</para>

<para>
Je kunt in &eacute;&eacute;n oogopslag zien dat je niet in je 
homedirectory staat!  <filename>~</filename> krijgt meer betekenis zodra 
we meer leren over het manipuleren van bestanden.
</para>
</sect2>

<sect2><title>Directory's aanmaken en verwijderen</title>
<para>
<indexterm><primary>mkdir</primary></indexterm>
<indexterm><primary>directory</primary><secondary>aanmaken</secondary>
</indexterm>

<cmdsynopsis>
<command>mkdir</command>
<arg choice="plain"><replaceable>directory1</replaceable></arg>
<arg><replaceable>directory 2 ... directoryN</replaceable></arg>
</cmdsynopsis>

Het aanmaken van eigen directory's is uiterst simpel onder &unix; en
het kan een handig organisatiehulpmiddel zijn. Gebruik voor het aanmaken van een
nieuwe directory de opdracht <command>mkdir</command>.
Natuurlijk staat <command>mkdir</command> voor 
<emphasis>m</emphasis>a<emphasis>k</emphasis>e <emphasis>dir</emphasis>ectory.

Laten we met een klein voorbeeld bekijken hoe dit werkt:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>ls -F</userinput>
<prompt>/home/larry# </prompt><userinput>mkdir report-1993</userinput>
<prompt>/home/larry# </prompt><userinput>ls -F</userinput>
<computeroutput>report-1993/</computeroutput>
<prompt>/home/larry# </prompt><computeroutput>cd report-1993</computeroutput>
<prompt>/home/larry/report-1993# </prompt>
</screen>
</para>

<para>
<command>mkdir</command> accepteert meer dan &eacute;&eacute;n parameter, 
elke parameter interpreterend als een ander aan te maken directory. Je kunt 
zowel de volledige padnaam als een relatieve padnaam opgeven;
<filename>report-1993</filename> in bovenstaand voorbeeld is een relatieve 
padnaam.
</para>

<para>
<screen>
<prompt>/home/larry/report-1993# </prompt><userinput>mkdir /home/larry/report-1993/chap1 /report-1993/chap2</userinput>
<prompt>/home/larry/report-1993# </prompt><userinput>ls -F</userinput>
<computeroutput>chap1/  chap2/</computeroutput>
<prompt>/home/larry/report-1993# </prompt>
</screen>
</para>

<para>
<cmdsynopsis>
<command>rmdir</command>
<arg choice="plain">directory1</arg>
<arg><replaceable>directory2 ... directoryN</replaceable></arg>
</cmdsynopsis>

Het tegenovergestelde van <command>mkdir</command> is 
<command>rmdir</command> 
(<emphasis>r</emphasis>e<emphasis>m</emphasis>ove <emphasis>dir</emphasis>ectory.
<indexterm><primary>rmdir</primary></indexterm>.

Een voorbeeld van <command>rmdir</command> is:
</para>

<para>
<screen>
<prompt>/home/larry/report-1993# </prompt><userinput>rmdir chap1 chap3</userinput>
<computeroutput>rmdir: chap3: No such file or directory</computeroutput>
<prompt>/home/larry/report-1993# </prompt><userinput>ls -F</userinput>
<computeroutput>chap2/</computeroutput>
<prompt>/home/larry/report-1993# </prompt><userinput>cd ..</userinput>
<prompt>/home/larry# </prompt><userinput>rmdir report-1993</userinput>
<computeroutput>rmdir: report-1993: Directory not empty</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Zoals je kunt zien, zal <command>rmdir</command> weigeren een niet 
bestaande directory te verwijderen, evenmin een directory met inhoud. 
(Denk eraan, <filename>report-1993</filename> heeft een subdirectory 
<filename>chap2</filename>!) 
Wat zou er trouwens gebeuren als je je huidige directory probeert 
te verwijderen? Laten we hier eens achter proberen te komen:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>cd report-1993</userinput>
<prompt>/home/larry/report-1993# </prompt><userinput>ls -F</userinput>
<computeroutput>chap2/</computeroutput>
<prompt>/home/larry/report-1993# </prompt><userinput>rmdir chap2</userinput>
<prompt>/home/larry/report-1993# </prompt><userinput>rmdir .</userinput>
<computeroutput>rmdir: .: Operation not permitted</computeroutput>
<prompt>/home/larry/report-1993# </prompt>
</screen>
</para>

<para>
Een andere situatie die je zou kunnen overwegen is wat er gebeurt als
je probeert de parent van je huidige directory te verwijderen.
Het komt er op neer dat dit geen probleem is aangezien de parent van
je huidige directory niet leeg is, dus niet kan worden verwijderd!
</para>
</sect2>
</sect1>

<sect1><title>Informatie verplaatsen</title>
<para>
Al deze fantastische directory's zijn erg fraai, maar helpen niet echt
tenzij je ergens een plekje hebt om je data op te slaan.
De &unix; Goden erkenden dit probleem, en corrigeerden
dit door de gebruikers bestanden te geven.
</para>

<para>
In de volgende paar hoofdstukken zullen we meer leren over het aanmaken
en wijzigen van bestanden.
</para>

<para>
De primaire opdrachten voor het manipuleren van bestanden onder
&unix; zijn <command>cp</command>, <command>mv</command> en 
<command>rm</command>. Ze staan respectievelijk voor 
<emphasis>c</emphasis>o<emphasis>p</emphasis>y,
<emphasis>m</emphasis>o<emphasis>v</emphasis>e,
<emphasis>r</emphasis>e<emphasis>m</emphasis>ove,
</para>

<sect2><title>cp Als een monnik</title>
<para>

<cmdsynopsis>
<command>cp</command> 
<arg>-i</arg>
<arg choice="plain"><replaceable>bron</replaceable></arg>
<arg choice="plain"><replaceable>doel</replaceable></arg>
<sbr/>
<command>cp</command> 
<arg>-i</arg>
<arg choice="plain">
<replaceable>bestand1 bestand2 ... bestandN</replaceable>
</arg>
<arg choice="plain">
<replaceable>doeldirectory</replaceable> 
</arg>
</cmdsynopsis>

<footnote><para>Het sjaboon van <command>cp</command> bestaat uit twee
regels omdat de betekenis van de tweede parameter afhankelijk van het
aantal parameters anders kan zijn.</para></footnote>
Onder &unix; is <command>cp</command> een zeer handig utility, en het 
is uiterst krachtig. E&eacute;n persoon kan er in een seconde meer 
informatie mee kopi&euml;ren dan een monnik uit de viertiende eeuw in een 
jaar zou kunnen.
</para>

<para>
<caution>
<para>Wees voorzichtig met <command>cp</command> 
als je niet zoveel diskruimte hebt. Niemand wenst de melding "Disk full" te 
zien te krijgen bij het werken aan belangrijke bestanden.
Met <command>cp</command> kun je ook zonder dat je een waarschuwing krijgt 
bestaande bestanden overschrijven. Daar kom ik later nog op terug.</para>
</caution>
</para>

<para>
We zullen het eerst gaan hebben over de eerste regel van het opdrachtensjabloon.
</para>

<para>
De eerste parameter van <command>cp</command> is het te kopi&euml;ren 
bestand, de tweede is waar het naartoe te kopi&euml;ren. Je kunt het of 
kopi&euml;ren naar een bestand met een andere naam, of naar een andere 
directory. Laten we eens wat voorbeelden proberen:
</para>

<para>
<screen>
/home/larry# ls -F /etc/passwd
/etc/passwd
/home/larry# cp /etc/passwd .
/home/larry# ls -F
passwd
/home/larry# cp passwd frog
/home/larry# ls -F
frog  passwd
/home/larry#
</screen>
</para>

<para>
De eerste <command>cp</command> opdracht die ik uitvoerde nam het bestand 
<filename>/etc/passwd</filename>
<indexterm><primary>/etc/passwd</primary></indexterm>, waarin de namen 
van alle gebruikers op het &unix;-systeem met bijbehorende (versleutelde)
wachtwoorden staan, en kopieerde dit naar mijn homedirectory.
<command>cp</command> houdt het bronbestand intact, het verwijdert dit niet,
dus ik deed niets dat schade aan het systeem kon berokkenen.
Dus nu bestaan er twee kopie&euml;n van <filename>/etc/passwd</filename>
op mijn systeem, allebei met de naam <filename>passwd</filename>, maar
&eacute;&eacute;n daarvan staat in de directory <filename>/etc</filename>
en de ander in <filename>/home/larry</filename>.
</para>

<para>
Vervolgens cre&euml;erde ik met de opdracht <command>cp passwd frog</command>
een <emphasis>derde</emphasis> kopie van <filename>/etc/passwd</filename>.
De drie kopie&euml;n zijn nu: <filename>/etc/passwd</filename>,
<filename>/home/larry/passwd</filename> en 
<filename>/home/larry/frog</filename>. De inhoud van deze drie bestanden 
is hetzelfde, ook al zijn de namen niet eender.
</para>

<para>
<command>cp</command> kan bestanden naar directory's kopi&euml;ren als de eerste
parameter een bestand is en de tweede parameter een directory.
In dit geval blijft de korte naam van het bestand hetzelfde.
</para>

<para>
Je kunt met <command>cp</command> een bestand kopi&euml;ren en 
tegelijkertijd de naam van het bestand wijzigen als beide parameters 
bestandsnamen zijn. Hier schuilt een gevaar van <command>cp</command>.
Bij het intikken van <command>cp /etc/passwd /etc/group</command>,
maakt <command>cp</command> normaal gesproken een nieuw bestand
aan met een inhoud die identiek is aan dat van <filename>passwd</filename>
en het zou dit bestand de naam <filename>group</filename> geven.
Als het bestand <filename>/etc/group</filename> echter reeds bestond, dan zou 
<command>cp</command> het oude bestand
verwijderen zonder je de kans te geven het te bewaren! (Er wordt zelfs
geen melding afgedrukt je eraan herinnerend dat je een bestand
gaat verwijderen door eroverheen te kopi&euml;ren.)
Laten we eens een ander voorbeeld van <command>cp</command> bekijken:
</para>

<para>
<screen>
/home/larry# ls -F
frog  passwd
/home/larry# mkdir passwd_versie
/home/larry# cp frog passwd passwd_versie
/home/larry# ls -F
frog         passwd        passwd_versie/
/home/larry# ls -F passwd_versie
frog  passwd
/home/larry#
</screen>
</para>

<para>
Hoe gebruikte ik nu zojuist de opdracht <command>cp</command>? 
Klaarblijkelijk accepteert <command>cp</command>
<emphasis>meer</emphasis> dan twee parameters.
(Dit is de tweede regel in het opdrachtensjabloon). Wat de bovenstaande
opdracht deed is alle bestanden (<filename>frog</filename> en
<filename>passwd</filename>) kopi&euml;ren
en ze in de directory <filename>passwd_versie</filename> plaatsen. In feite accepteert
<command>cp</command> elk aantal parameters, en interpreteert het daarbij de eerste n-1 parameters als te kopi&euml;ren bestanden en de 
n<superscript>e</superscript> parameter
als de directory waarnaar te kopi&euml;ren.

<caution><para>Je kunt bestanden niet hernoemen wanneer je meerdere
bestanden tegelijkertijd kopieert---ze behouden altijd hun korte naam. Dit leidt
tot een interessante vraag. Wat als ik <command>cp frog passwd toad</command>
typ, waarbij zowel <filename>frog</filename> als <filename>passwd</filename>
al bestaan en <filename>toad</filename> geen 
directory is? Probeer het uit.</para></caution>

</para>
</sect2>

<sect2><title>rm</title>
<para>
<cmdsynopsis>
<command>rm</command>
<arg><replaceable>-i</replaceable></arg>
<arg choice="plain">
<replaceable>bestand1 bestand2 ... bestandN</replaceable>
</arg>
</cmdsynopsis>

Nu we hebben geleerd hoe met <command>cp</command>
<indexterm><primary>cp</primary></indexterm> miljoenen bestanden
aan te maken (en geloof me, je zult spoedig nieuwe manieren ontdekken om meer
bestanden aan te maken), kan het zinvol zijn te leren hoe ze te verwijderen. 
In feite is het heel simpel: de opdracht die je zoekt is 
<command>rm</command>, en het 
werkt precies zoals je zou verwachten:
elk bestand opgegeven als parameter van <command>rm</command> wordt verwijderd.
</para>

<para>
Bijvoorbeeld:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>ls -F</userinput>
<computeroutput>frog         passwd        passwd_versie/</computeroutput>
<prompt>/home/larry# </prompt><userinput>rm frog toad passwd</userinput>
<computeroutput>rm: toad: No such file or directory</computeroutput>
<prompt>/home/larry# </prompt><userinput>ls -F</userinput>
<computeroutput>passwd_versie/</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
Zoals je ziet is <command>rm</command> uiterst onvriendelijk. 
Er wordt je helemaal niet om een bevestiging gevraagd, en bovenal
zal het ook nog eens gegevens verwijderen als de gehele opdrachtregel 
niet juist was. Dit zou weleens heel gevaarlijk kunnen zijn.
Neem het verschil tussen deze twee opdrachten:
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>ls -F</userinput>
<computeroutput>toad  frog/</computeroutput>
<prompt>/home/larry# </prompt><userinput>ls -F frog</userinput>
<computeroutput>toad</computeroutput>
<prompt>/home/larry# </prompt><userinput>rm frog/toad</userinput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
en deze
</para>

<para>
<screen>
<prompt>/home/larry# </prompt><userinput>rm frog toad</userinput>
<computeroutput>rm: frog is a directory</computeroutput>
<prompt>/home/larry# </prompt><userinput>ls -F</userinput>
<computeroutput>frog/</computeroutput>
<prompt>/home/larry# </prompt>
</screen>
</para>

<para>
<caution>
<para>Zoals je kunt zien maakt <emphasis>&eacute;&eacute;n</emphasis> 
teken in de uitkomst van de opdracht een wereld van verschil. Het is van groot
belang dat je de opdrachtregel controleert voordat je met <keycap>return</keycap> de
opdracht bevestigt!</para></caution>
</para>
</sect2>


<sect2><title>mv</title>
<para>
<cmdsynopsis>
<command>mv</command>
<arg>-i</arg>
<arg choice="plain"><replaceable>oude-naam</replaceable></arg>
<arg choice="plain"><replaceable>nieuwe-naam</replaceable></arg>
<sbr/>
<command>mv</command>
<arg>-i</arg>
<arg choice="plain"><replaceable>bestand1 bestand2 ... bestandN</replaceable></arg> <arg choice="plain"><replaceable>nieuwe-directory</replaceable></arg>
</cmdsynopsis>

Tenslotte is de andere bestandsopdracht waar je bekend mee zou  moeten
zijn de opdracht <command>mv</command>. <command>mv</command>
lijkt erg veel op <command>cp</command>, behalve dat het 't oorspronkelijke 
bestand verwijdert na het te hebben gekopieerd. Het lijkt erg veel op het 
gecombineerd gebruiken van <command>cp</command> en <command>rm</command>.
Laten we eens kijken naar wat we ermee kunnen doen:
</para>

<para>
<screen>
/home/larry# cp /etc/passwd .
/home/larry# ls -F
passwd
/home/larry# mv passwd frog
/home/larry# ls -F
frog
/home/larry# mkdir report
/home/larry# mv frog report
/home/larry# ls -F
report/
/home/larry# ls -F report
frog
/home/larry#
</screen>
</para>

<para>
Zoals je kunt zien, zal <command>mv</command> een bestand hernoemen 
als de tweede parameter een bestand is. Als de tweede parameter een 
directory is, zal <command>mv</command> het bestand naar de nieuwe 
directory verplaatsen, de korte naam hetzelfde behoudend.
</para>

<caution><para>Wees zorgvuldig bij het gebruik van <command>mv</command>.
Het controleert niet of het bestand reeds voorkomt, en elk oud bestand
dat in de weg staat zal worden verwijderd.
Als ik bijvoorbeeld reeds een bestand met de naam 
<filename>frog</filename> in mijn directory <filename>report</filename>
heb, dan wordt met de opdracht <command>mv frog report</command>
het bestand <filename>~/report/frog</filename> verwijderd en 
wordt het vervangen door <filename>~/frog</filename>.
</para></caution>

<para>
In feite bestaat er een manier om te zorgen dat <command>rm</command>,
<command>cp</command> en <command>mv</command>
om bevestiging vragen alvorens bestanden te verwijderen.
Deze drie opdrachten accepteren allen de optie <option>-i</option>, wat 
maakt dat ze de gebruiker vragen om een bevestiging alvorens
een bestand wordt verwijderd. Als je gebruik maakt van een 
<emphasis>alias</emphasis>, dan kun je de shell automatisch een 
<command>rm -i</command> laten uitvoeren wanneer je zelf 
<command>rm</command> invoert. Je leert hierover later meer in 
de <xref linkend="aliasing-section"/>.
</para>
</sect2>
</sect1>
</chapter>
<!--
% Local Variables: 
% mode: latex
% TeX-master: "guide"
% End: 
-->