====== Werken op de Linux Commandoregel ======

**Inhoud:**\\

  - [[#Inleiding]]
  - [[#Een X Terminal ("xterm") openen/sluiten]]
  - [[#Een paar speciale toetsen]]
  - [[#Namen van Linux commando's]]
  - [[#Een Linux commandoregel bouwen]]
  - [[#Informatie over Linux commando's opvragen]]

===== 1. Inleiding =====

Als gebruiker van de Tux4u(r)/Penguin Suite kun je lekker werken in een mooie desktopomgeving (KDE Desktop), je bestanden beheren via een grafisch beheerprogramma en heel veel andere toepassingen opstarten en gebruiken, zoals bijvoorbeeld OpenOffice.org Writer. Allemaal zonder dat je ooit een echte Linux commandoregel hoeft in te typen!

Maar iedere gebruiker mag en kan wel degelijk "werken op de Linux commandoregel". Hieronder lees je hoe je dat moet doen en vooral ook waar je allemaal op moet letten. Hoezo? Omdat je systeem niet "denkt", maar **uitvoert**. Het zal jouw "opdracht" in logische stappen uitvoeren, heel **letterlijk**, zoals het vindt dat jij die opdracht bedoeld hebt.

Voorbeeld:\\  Stel dat jij had willen zeggen dat alle bestanden uit een map weggegooid mochten worden op een paar na, maar je systeem ziet de opdracht "gooi **alle** bestanden uit deze map weg", dan is het resultaat toch dat de map helemaal leeg is! En weg is weg, want er is op de commandoregel geen "prullenmand"!!\\  Jij hebt je vergist, maar het systeem merkt daar niets van: het vindt dat jij een goede commandoregel hebt weten in te typen, die prima uit te voeren was! Je kreeg daarom dus ook geen "foutmelding".

In Linux geldt: **geen bericht is goed bericht**. Daarmee wordt bedoeld: als je commandoregel probleemloos uitgevoerd kan worden, dan wordt daar geen melding over gegeven. Er wordt alleen iets gemeld als er WEL een probleem is bij het uitvoeren van je commandoregel. Dat noemen we een **foutmelding** ("error message"). Het is een mededeling in het Engels/Amerikaans, bedoeld om je op een probleem te wijzen. \\  Het is belangrijk om zo'n foutmelding goed te lezen. Het kan namelijk gebeuren dat jouw commandoregel bijna helemaal uitgevoerd kan worden op een klein stukje na. Je krijgt dan geen melding over alles wat met succes uitgevoerd kan worden (immers: "geen bericht is goed bericht"). Maar je krijgt wel een melding over dat kleine stukje waar het fout gaat. In zo'n geval is het erg verkeerd om de conclusie te trekken: ik kreeg een foutmelding, dus mijn commandoregel is helemaal niet uitgevoerd.

In het voorbeeld hierboven, dat met het weggooien van bestanden uit een map, zou je een foutmelding kunnen krijgen, die er ongeveer zo uitziet: "rm: cannot remove `werkstuk.html` permission denied". Dit betekent dat het weggooi-commando "rm" ("remove") tot de conclusie is gekomen dat hij het recht niet heeft ("permission denied") om het bestand "werkstuk.html" weg te gooien.\\  In het voorbeeld hierboven dacht het systeem dat jij **alle** bestanden uit de map wilde laten weggooien. Deze foutmelding betekent NIET dat er helemaal geen bestanden zijn weggegooid! De foutmelding betekent dat inderdaad alle bestanden zijn weggegooid op één na: werkstuk.html

Als je op de commandoregel gaat werken is het dus belangrijk dat je het volgende onthoudt:

  * **denkwerk**: jij doet het denkwerk vóórdat je een commandoregel intypt
  * **informatie**: als je twijfelt lees je eerst informatie over het betreffende commando (zie punt 6: man)
  * **check**: je checkt je commandoregel vóórdat je hem laat uitvoeren

===== 2. Een X Terminal ("xterm") openen/sluiten =====

Om in de KDE Desktop op de commandoregel te kunnen werken moet je eerst een zogenaamde X Terminal ("xterm") openen: een nieuw venster met een Linux commando-aanwijzer erin waarachter je je commando kunt intypen. Dit doe je vanuit het "K-menu", linksonderin je scherm.

  - **Een X terminal openen vanuit het K-menu:**\\ \\
    * Ga naar **Hulpmiddelen** en kies **Terminal Program (X Terminal)**
    * Andere manier: Ga naar **Debian**, kies eerst **XShells** en dan **XTerm**\\  Er wordt in je KDE Desktop een nieuw venster geopend met daarin een Linux commando-aanwijzer (een "prompt"): het teken "**$ **". \\  Achter die prompt kun je een commando intypen, want er staat nu een programma te wachten tot het jouw commandoregel mag lezen en interpreteren en uitvoeren. Zo'n programma noemen we een "**shell**". \\ \\
  - **Een X Terminal sluiten:**Als je klaar bent met je werk op de commandoregel sluit je de X Terminal.\\  Dat doe je door achter de prompt het commando "**exit**" in te typen.\\  Op het scherm ziet dat er zo uit: $ **exit**\\  Druk **1x** op de "**Enter**"-toets en het commando wordt uitgevoerd: de "shell" wordt netjes gestopt en het venster, de X Terminal, wordt gesloten.

===== 3. Een paar speciale toetsen =====

  * **Enter** (commando/commandoregel laten uitvoeren)\\  Een commando wordt pas gelezen, geïnterpreteerd en uitgevoerd als er aan het eind van de commandoregel op de "**Enter**"-toets gedrukt is. Met een druk op de "Enter"-toets geef je de shell het sein dat jij klaar bent en dat hij nu voor je aan het werk moet gaan. \\  Omdat fouten op de commandoregel heel vervelende gevolgen kunnen hebben, moet je je commandoregel dus checken vóórdat je op de "Enter"-toets drukt om hem te laten uitvoeren! \\ \\
  * **Backspace** (teken/tekens wissen)\\  Ontdek je een typefout en heb je nog niet op de "Enter"-toets gedrukt, dan kun je je typefout nog verbeteren. Daarvoor gebruik je de "**Backspace**"-toets: met elk stapje naar links wis je een teken uit! \\  De "**pijltjes**"-toetsen gebruik je NIET op de commandoregel. Ze werken alleen als de shell zo is ingericht dat hij daar goed mee kan omgaan. Je kunt er niet van uitgaan dat jouw shell inderdaad zo is ingericht. \\ \\
  * **Ctrl + c** (commandoregel NIET laten lezen/interpreteren/uitvoeren)\\  Heb je nog niet op "Enter" gedrukt en lijkt je commandoregel echt nergens op, dan wil je hem natuurlijk ook niet laten uitvoeren. In plaats van de regel met de "Backspace"-toets teken voor teken te wissen kun je dan beter de toetsencombinatie **Ctrl + c** gebruiken. Dat doe je zo: "**Ctrl**" indrukken, "**c**" ook indrukken en dan beide toetsen loslaten.\\  Je krijgt nu opnieuw de prompt te zien en je kunt weer een nieuwe commandoregel intypen. \\ \\
  * Nogmaals **Ctrl + c** (uitvoeren stoppen/onderbreken)
    - Heb je al op "Enter" gedrukt en zie je dan pas dat de commandoregel toch niet de juiste is, dan kun je het uitvoeren ervan meestal niet meer stoppen. Héél soms lukt het als je supersnel de toetsencombinatie **Ctrl + c** intoetst.\\  Als het lukt krijg je de prompt weer te zien en kun je opnieuw een commandoregel intypen. Zoniet, dan moet je helaas eerst wachten tot het (verkeerde) commando helemaal is uitgevoerd. \\ \\
    - De toetsencombinatie **Ctrl + c** kun je ook gebruiken als je al op de "Enter"-toets hebt gedrukt en je krijgt een nieuwe prompt te zien (het teken "**> **"), zonder dat je commando wordt uitgevoerd.\\  Hiermee wordt aangegeven dat je commandoregel niet af is. Vaak weet je dan niet wat je verder nog zou moeten intypen en wil je liever opnieuw beginnen. Na het indrukken van **Ctrl + c** krijg je de normale prompt (het teken "**$ **") weer te zien.

===== 4. Namen van Linux commando's =====

  * de naam van een commando is **1 woord**
  * het is een **Engels/Amerikaans** woord of een afkorting daarvan
  * de naam bestaat meestal uit alleen maar **kleine letters**\\  (de "Caps Lock" gebruik je dus niet!)
  * de naam van een commando is het **eerste** woord op de commandoregel

===== 5. Een Linux commandoregel bouwen =====

Een commandoregel begint altijd met de naam van een commando. Dat kan meteen ook het einde van de commandoregel zijn! Maar een commandoregel kan ook een stuk langer worden. We spreken dan van "**een commando met argumenten**".\\  Zo'n lange commandoregel kan alleen begrepen en uitgevoerd worden als er duidelijke scheidingstekens zijn tussen al die elementen. De afspraak is dat daarvoor de **spatie** wordt gebruikt; **1 spatie** is al voldoende.\\  Zodra een commandoregel langer is dan alleen de commandonaam moet je dus **een spatie** gebruiken tussen alle verschillende elementen.

Een commandoregel kan als volgt opgebouwd zijn:\\

  * **cmd**De kortste commandoregel bestaat alleen uit de naam van het commando.\\  Probeer de volgende drie commandoregels maar eens:<code>
$ date
$ whoami
$ ls
</code> Je hebt daarmee de volgende opdrachten laten uitvoeren:\\  "Geef datum en tijd", "Wie ben ik volgens jou?" en "Geef lijst met bestanden in deze map".\\  ("ls" is de afkorting van het Engelse woord "list")Als je een commando intypt dat echt niet bestaat of dat nergens gevonden kan worden, dan krijg je een foutmelding van de shell: "**command not found**".\\  Test dat maar eens met de volgende commandoregel:<code>
$ bliep
</code>
  * **cmd arg//1// [arg//2//] [arg//3//] ... [arg//n//]**Hiermee wordt bedoeld: een commando met 1 argument of, naar keuze, met 2, 3 of "tig" (aangeduid met "//n//") argumenten. De vierkante haken worden gebruikt om aan te geven dat een element op de commandoregel "optioneel" is, dat het naar keuze wel of niet op de commandoregel gebruikt kan worden. \\  Achter de commandonaam volgt eerst een spatie, dan het eerste argument, weer een spatie, dan (naar keuze) het tweede argument, enz. Dit gaat alleen goed als het betreffende commando weet wat het met een argument moet doen. Als het dat niet weet zal het een foutmelding geven.Het commando "ls" is een goed voorbeeld van een commando dat prima overweg kan met argumenten, maar dat moeten dan wel de correcte namen van bestaande bestanden of mappen zijn.\\  Probeer de volgende twee commandoregels maar eens:<code>
$ ls /tmp
$ ls /tmp Mijn_documenten
</code> De eerste commandoregel vraagt aan "ls" om de bestanden te laten zien, die in de map "/tmp" zitten. Deze map bestaat op elk Linux systeem. Hij zit vol met tijdelijke bestanden en mappen, die nodig zijn voor bepaalde toepassingen (de letters "tmp" zijn de afkorting van "temporary", tijdelijk). Het commando zal dus zeker uitgevoerd kunnen worden.\\  Als het toch fout ging, dan ben je vast de spatie achter de commandonaam vergeten! In dat geval kreeg je een foutmelding van de shell: "ls/tmp: command not found". Er is inderdaad geen commando met de naam "ls/tmp"!De tweede commandoregel vraagt naar een lijst met de inhoud van twee verschillende mappen. Deze commandoregel leidt tot een foutmelding als je de spatie tussen "/tmp" en "Mijn_documenten" bent vergeten. Als de spatie er wel staat, maar de map "Mijn_documenten" bestaat niet of heet anders, dan krijg je daarover een foutmelding, maar je krijgt WEL de inhoud van de map "/tmp" te zien. \\
  * **cmd -//optie(s)// [arg] [arg] ... [arg//n//]**Hiermee wordt bedoeld: een commando met als eerste argument een **optielijst** en daarna eventueel 1 of meerdere argumenten.\\  Veel commando's kunnen overweg met opties. Dit zijn letterafkortingen van Engelse/Amerikaanse woorden. Je geeft hiermee aan het commando de opdracht om z'n werk op een speciale manier uit te voeren.\\  Er zijn ook commando's, die helemaal niet met opties overweg kunnen; ze geven een foutmelding als je een optie hebt ingetypt.\\  Om opties te onderscheiden van "gewone" argumenten is de afspraak dat er vóór de optie(s) een speciaal teken wordt getypt. Daarvoor wordt meestal de **-** gebruikt (heel soms de **+**).\\  Opties mogen vaak met elkaar gecombineerd worden achter één zo'n "waarschuwingsteken".\\  Pas op: een commando kan opties hebben met hoofdletters en met kleine letters!Probeer de volgende drie commandoregels maar eens:<code>
$ ls -a
$ ls -al
$ ls -aF /tmp
</code> De eerste commandoregel vraagt om een lijst van **alle** bestanden in deze map.\\  De tweede commandoregel vraagt om een lijst met **uitgebreide informatie** ("long list") over **alle** bestanden in deze map.\\  De derde commandoregel vraagt om een lijst van **alle** bestanden in de map "/tmp", waarbij bovendien moet worden aangegeven of iets een speciaal soort bestand is (bv.: als het geen gewoon bestand is, maar een map, dan is het teken "/" achter de betreffende naam gezet).

Tip:\\  Soms levert een commandoregel erg veel informatie ("output"). De regels rollen dan snel over je scherm en je krijgt alleen de laatste regels te zien, net boven de prompt. Typ de commandoregel dan opnieuw in, maar voeg helemaal aan het eind ook nog het volgende toe: **| less**\\  Door het staande streepje ("pipe") en het commando "less" wordt alle informatie opgedeeld in schermpagina's, die je op je gemak kunt bekijken.\\  Probeer de volgende commandoregels maar eens:<code>
$ ls -l /etc
$ ls -l /etc | less
</code>

De map "/etc" zit boordevol bestanden.
Bij de eerste commandoregel vliegt de informatie over je scherm,
maar bij de tweede commandoregel wordt er gestopt zodra je scherm vol is!
Je kunt dit nu rustig lezen en als je klaar bent gebruik je een van de toetsen die hieronder bij punt 6 beschreven staan om een schermpagina naar beneden te gaan of om je prompt weer terug te krijgen.


===== 6. Informatie over Linux commando's opvragen =====

Als je van een commando wel de naam weet, maar je hebt geen idee hoe een commandoregel met dat commando eruit mag zien (wel/geen opties, wel/geen argumenten), dan kun je die informatie opvragen via het "online manual", het handboek dat op je systeem aanwezig is. Het commando dat je daarvoor gebruikt is "**man**", de afkorting van het woord "manual".

Voorbeeld: informatie opvragen over het commando "**man**"\\  $ **man man**\\

De volgende toetsen zijn handig om door zo'n pagina te wandelen:\\

  * **Spatiebalk** ga 1 schermpagina naar beneden
  * **b** ("back") ga 1 schermpagina terug naar boven
  * **Enter** ga 1 regel naar beneden
  * **/**//zoekwoord// zoek vanaf huidige positie naar beneden naar het opgegeven //zoekwoord//
  * **n** ("next") zoek verder naar beneden naar de volgende keer dat het //zoekwoord// voorkomt
  * **N** ga terug naar boven naar de voorgaande keer dat //zoekwoord// voorkwam
  * **q** verlaat het handboek



----

Copyright (c) 2006 Integrated Services\\
Author: Drs.M.Bonk; commandline_nl 2006-11-03\\
Update: 2011-03-31