# Een overzicht van de belangrijkste Linux-commando's

Net als de meeste moderne besturingssystemen biedt Linux u ook een **shell**, waarmee u uw systeem kunt bedienen met behulp van **opdrachtregelopdrachten**. Alle instellingen die u via de grafische gebruikersinterface (GUI) kunt instellen, kunnen ook via de shell worden uitgevoerd. We laten u de belangrijkste Linux-opdrachten zien en leggen hun functie en toepassing uit.

## Lijst met de 50 belangrijkste Linux-commando’s

<table>
  <thead>
    <tr>
      <th>Commando</th>
      <th>Beschrijving</th>
    </tr>
  </thead>
  <tbody>
    <tr>
      <td>sudo</td>
      <td>Programma’s uitvoeren met de rechten van een andere gebruiker</td>
    </tr>
    <tr>
      <td>ls</td>
      <td>De inhoud van een map weergeven</td>
    </tr>
    <tr>
      <td>cd</td>
      <td>Navigeren in de mappenstructuur</td>
    </tr>
    <tr>
      <td>touch</td>
      <td>Nieuw bestand aanmaken</td>
    </tr>
    <tr>
      <td>mkdir</td>
      <td>Nieuwe map aanmaken</td>
    </tr>
    <tr>
      <td>rm</td>
      <td>Bestand verwijderen</td>
    </tr>
    <tr>
      <td>rmdir</td>
      <td>Map verwijderen</td>
    </tr>
    <tr>
      <td>mv</td>
      <td>Bestand of map verplaatsen</td>
    </tr>
    <tr>
      <td>cp</td>
      <td>Bestand of map kopiëren</td>
    </tr>
    <tr>
      <td>pwd</td>
      <td>Huidige positie in mappenstructuur weergeven</td>
    </tr>
    <tr>
      <td>zip</td>
      <td>Bestanden naar zip-archieven schrijven</td>
    </tr>
    <tr>
      <td>unzip</td>
      <td>Bestanden uit zip-archieven extraheren</td>
    </tr>
    <tr>
      <td>ln</td>
      <td>Maak een symbolische link</td>
    </tr>
    <tr>
      <td>cat</td>
      <td>Bestandsinhoud combineren</td>
    </tr>
    <tr>
      <td>grep</td>
      <td>Tekstbestanden doorzoeken</td>
    </tr>
    <tr>
      <td>diff</td>
      <td>Verschillen tussen tekstbestanden zoeken</td>
    </tr>
    <tr>
      <td>cmp</td>
      <td>Bestanden op byte-niveau uitlijnen</td>
    </tr>
    <tr>
      <td>tar</td>
      <td>Bestanden schrijven en extraheren naar tar-archieven</td>
    </tr>
    <tr>
      <td>echo</td>
      <td>Voer string uit naar de standaardspecificatie</td>
    </tr>
    <tr>
      <td>clear</td>
      <td>Terminal wissen</td>
    </tr>
    <tr>
      <td>ssh</td>
      <td>Verbinding maken met een andere computer via een *beveiligde shell*</td>
    </tr>
    <tr>
      <td>wget</td>
      <td>Bestand rechtstreeks van internet downloaden</td>
    </tr>
    <tr>
      <td>ping</td>
      <td>Server opvragen en latentie meten</td>
    </tr>
    <tr>
      <td>ftp, sftp</td>
      <td>Bestanden overzetten via (S)FTP</td>
    </tr>
    <tr>
      <td>ip</td>
      <td>query en configureer netwerkinterfaces</td>
    </tr>
    <tr>
      <td>apt/pacman/yum</td>
      <td>Softwarepakketten downloaden en beheren</td>
    </tr>
    <tr>
      <td>netstat</td>
      <td>De status van netwerkinterfaces weergeven</td>
    </tr>
    <tr>
      <td>traceroute</td>
      <td>Gegevenspakketten volgen</td>
    </tr>
    <tr>
      <td>route</td>
      <td>IP-routeringstabellen weergeven en bewerken</td>
    </tr>
    <tr>
      <td>dig</td>
      <td>DNS-informatie opvragen</td>
    </tr>
    <tr>
      <td>koppelen/ontkoppelen</td>
      <td>Bestandssystemen integreren (instellen/koppelen)</td>
    </tr>
    <tr>
      <td>dd</td>
      <td>Bestanden, partities of gegevensdragers tot op de bit nauwkeurig kopiëren</td>
    </tr>
    <tr>
      <td>chmod</td>
      <td>Beheer toegangsrechten</td>
    </tr>
    <tr>
      <td>chown</td>
      <td>Beheer eigendomsrechten</td>
    </tr>
    <tr>
      <td>adduser</td>
      <td>Gebruikersaccount toevoegen/wijzigen</td>
    </tr>
    <tr>
      <td>passwd</td>
      <td>Wachtwoorden voor gebruikersaccounts aanmaken/bewerken</td>
    </tr>
    <tr>
      <td>groupadd</td>
      <td>Gebruikersgroepen aanmaken</td>
    </tr>
    <tr>
      <td>chattr</td>
      <td>Bestandsattributen beheren</td>
    </tr>
    <tr>
      <td>lsattr</td>
      <td>Bestandsattributen weergeven</td>
    </tr>
    <tr>
      <td>chgrp</td>
      <td>Beheer groepslidmaatschappen voor bestanden en mappen</td>
    </tr>
    <tr>
      <td>man</td>
      <td>Gebruikershandleiding oproepen</td>
    </tr>
    <tr>
      <td>shutdown, reboot</td>
      <td>Systeem afsluiten/opnieuw opstarten</td>
    </tr>
    <tr>
      <td>top</td>
      <td>Dynamisch procesoverzicht</td>
    </tr>
    <tr>
      <td>lscpu</td>
      <td>Processorinformatie weergeven</td>
    </tr>
    <tr>
      <td>lshw</td>
      <td>Hardware-informatie weergeven</td>
    </tr>
    <tr>
      <td>kill</td>
      <td>Proces stoppen en beëindigen via PID</td>
    </tr>
    <tr>
      <td>killall</td>
      <td>Stop en beëindig processen via naam</td>
    </tr>
    <tr>
      <td>nice</td>
      <td>Procesprioriteiten definiëren</td>
    </tr>
    <tr>
      <td>pgrep</td>
      <td>Identificeer PID via zoekterm</td>
    </tr>
    <tr>
      <td>ps</td>
      <td>Lijst met alle actieve processen weergeven</td>
    </tr>
  </tbody>
</table>

### sudo-commando in Linux

Met [het Linux-commando `sudo`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-sudo-commando/)(*substitute user do*) kan worden ingesteld dat het programma met de rechten van een andere gebruiker wordt uitgevoerd. Hiervoor is in de regel het invoeren van een wachtwoord vereist. Het commando `sudo` vraagt altijd om het wachtwoord van het gebruikersaccount dat wordt opgeroepen.

Als het commando zonder gebruikersnaam wordt ingevoerd, wordt de superuser root als doelgebruiker ingesteld.

```bash
sudo -u USERNAME PROGRAM CALL
```

### ls-commando in Linux

De Linux ls -opdrachtregelopdracht ls staat voor *list (lijst* ) en wordt gebruikt om de inhoud van een map weer te geven (de namen van alle bestanden en mappen die in de opgegeven map worden gevonden).

De syntaxis van het commando luidt:

```bash
ls [OPTIONS] DIRECTORY
```

Als `ls` wordt gebruikt zonder een directory-item, geeft het commando de inhoud van de huidige directory weer. Met behulp van extra opties kunt u bepalen welke informatie wordt weergegeven en hoe deze wordt weergegeven.

### cd-commando in Linux

[De Linux-opdracht `cd`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-cd-opdracht/) staat voor *‘change directory’*(map wijzigen) en wordt gebruikt voor navigatie in de mappenstructuur.

De syntaxis van het commando luidt:

```bash
cd [OPTION] DIRECTORY
```

Als er geen doelmap wordt opgegeven, schakelt `cd` automatisch over naar de thuismap van de gebruiker. Als `cd` wordt gebruikt met een minteken (-), keert het terug naar de vorige map.

### touch-commando in Linux

[De Linux-opdrachtregelopdracht `touch`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-opdracht-touch/) kan worden gebruikt om de tijdstempels voor toegang en wijziging van bestanden te wijzigen. Als `touch` wordt toegepast op een bestand dat nog niet bestaat, wordt het automatisch aangemaakt, wat betekent dat de opdracht ook geschikt is voor het aanmaken van lege bestanden. Gebruik `touch` volgens het volgende patroon:

```bash
touch [OPTIONS] FILE
```

Om de tijdstempel voor een bestand op de gewenste datum in te stellen, gebruikt u OPTIE `-t` samen met de tijdinformatie in de formulieren `[YY]MMDDhhmm[.ss]`.

Voorbeeld:

```bash
touch -t 1703231037 file.txt
```

De tijdstempels voor toegang en wijzigingen zijn nu ingesteld op 23 maart 2017, 10:37 uur. De wijziging kan worden beperkt tot toegang of tijdstempels met de opties `-a` en `-m`. Als het commando `touch` wordt gebruikt zonder optie `-t`, dan wordt het huidige tijdstempel gebruikt.

### mkdir-commando in Linux

Het [Linux-commando `mkdir`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-mkdir-commando/) staat voor *make directory* en stelt Linux-gebruikers in staat om nieuwe mappen aan te maken. Gebruik de volgende syntaxis om een nieuwe map aan te maken in de huidige map:

```bash
mkdir [OPTION] DIRECTORY NAME
```

Als een map in een bepaalde doelmap moet worden aangemaakt, geef dan het absolute of relatieve pad naar de map op.

### rm-commando in Linux

Het Linux-commando rm (*verwijderen*) verwijdert bestanden of hele mappen definitief. De programma-aanroep is gebaseerd op de volgende syntaxis:

```bash
rm [OPTIONS] FILE/DIRECTORY
```

Als een map samen met alle submappen moet worden verwijderd, gebruik dan `rm` plus de optie `-R` (*–recursive*).

### rmdir-commando in Linux

Als u een bepaalde map wilt verwijderen, gebruikt u de opdrachtregelopdracht `rmdir` (*map verwijderen*) volgens de volgende syntaxis:

```bash
rmdir [OPTION] DIRECTORY
```

Je kunt alleen lege mappen verwijderen met `rmdir`. Om een map samen met alle daarin opgenomen bestanden en submappen te verwijderen, gebruik je het commando `rm` (*verwijderen*) met de optie `–r`.

In andere artikelen vindt u aanvullende manieren om een Linux-bestand of een Linux-map te verwijderen.

### mv-commando in Linux

Het [Linux-commando `mv`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-mv-commando/) (*verplaatsen*) kopieert een bestand of map en verwijdert het oorspronkelijke element. Als het binnen dezelfde map wordt gebruikt, kan `mv` worden gebruikt om bestanden te hernoemen.

De programma-aanroep is gebaseerd op de volgende syntaxis:

```bash
mv [OPTIONS] SOURCE TARGET
```

### cp-commando in Linux

Het Linux-commando cp (*kopiëren*) wordt gebruikt om bestanden en mappen te kopiëren. De basissyntaxis van het commando luidt:

```bash
cp [OPTIONS] SOURCE TARGET
```

De BRON is het element dat moet worden gekopieerd. Vervolgens wordt een bestand of een map gedefinieerd als het DOEL van het kopieerproces. Als u een bestaand bestand als doelbestand definieert, wordt de inhoud ervan overschreven met het bronbestand. U hebt ook de mogelijkheid om een nieuw bestand met een naam naar keuze aan te maken als doelbestand.

### pwd-commando in Linux

Gebruik het [Linux-commando `pwd`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-pwd-commando/) (afkorting van *print working directory*) om de naam van de huidige werkdirectory weer te geven.

De syntaxis van het commando luidt:

```bash
pwd [OPTIONS]
```

### zip-commando in Linux

Gebruik het commando `zip` om meerdere bestanden te comprimeren tot een zip-archief. De syntaxis van het commando is:

```bash
zip DESTINATION FILES
```

De BESTEMMING is de naam of het pad van het resulterende zip-bestand. BESTANDEN verwijst naar de bestandsnamen of paden van de bestanden die moeten worden gecomprimeerd (gescheiden door spaties).

### unzip-commando in Linux

Je kunt `unzip` gebruiken om bestanden uit zip-archieven te extraheren. De syntaxis is:

```bash
unzip FILE.zip -d DESTINATION
```

Hier verwijst FILE naar de zip-archieven waaruit de bestanden moeten worden uitgepakt. Optioneel kunt u de optie -d TARGET gebruiken om een doelmap op te geven waar de resulterende bestanden moeten worden opgeslagen. Anders worden de bestanden in de huidige map opgeslagen.

### ln-commando in Linux

Het Linux-commando ln (afkorting van *link*) genereert een snelkoppeling naar een bestand of een map. Hierdoor wordt een nieuwe mapvermelding voor dit bestand aangemaakt, waardoor u via een ander bestandspad toegang krijgt tot het betreffende bestand. De aanroep voor `ln` moet altijd ten minste het pad naar het bronbestand bevatten.

```bash
ln [OPTIONS] path/to/sourcefile
```

In dit geval wordt er een snelkoppeling met dezelfde naam aangemaakt in de huidige werkdirectory. U kunt ook een doelpad invoeren en de snelkoppeling vervolgens een naam geven die u wilt:

```bash
ln [OPTIONS] path/to/sourcefile path/to/shortcut
```

### cat-commando in Linux

Het Linux-commando cat (afkorting van *concatenate*) is ontwikkeld als hulpmiddel voor het combineren van bestandsinhoud en kan worden gebruikt als pager voor het weergeven van bestandsinhoud in de terminal.

Gebruik `cat` met de volgende syntaxis in de terminal om een bestand te lezen en uit te voeren naar `stdout` (de standaarduitvoer):

```bash
cat OPTIONS FILE
```

Meerdere bestanden kunnen worden gescheiden door spaties:

```bash
cat OPTIONS FILE1 FILE2
```

### grep-commando in Linux

Met het Linux-commando grep kunt u tekstbestanden doorzoeken. Elke tekenreeks of reguliere expressie kan als zoekpatroon worden gebruikt. Gebruik `grep` volgens de volgende syntaxis:

```bash
grep [OPTIONS] SEARCH PATTERN [FILE(S)]
```

Als `grep` een tekenreeks tegenkomt die overeenkomt met het zoekpatroon, worden het regelnummer en de bestandsnaam naar de terminal uitgevoerd. Over het algemeen wordt `grep` gebruikt voor alle bestanden in de huidige map. Met de optie `-r` kan recursief worden gezocht in de submappen.

### diff-commando in Linux

Het opdrachtregelprogramma `diff` dient om twee bestanden te vergelijken. U kunt `diff` ook gebruiken om te bepalen of twee mappen dezelfde bestanden bevatten.

Roep het programma op in de terminal met behulp van de volgende syntaxis:

```bash
diff [OPTIONS] FILE1 FILE2
```

### cmp-commando in Linux

`cmp` maakt deel uit van het `diff` en wordt gebruikt om bestandsinhoud te vergelijken. In tegenstelling tot `diff` gebeurt de uitlijning op byteniveau en is het dus bijzonder geschikt voor binaire bestanden. Gebruik `cmp` volgens de volgende syntaxis:

```bash
cmp [OPTIONS] FILE1 FILE2
```

Als `cmp` verschillen vindt, geeft het opdrachtregelprogramma de byte en het regelnummer van de eerste afwijking weer in de terminal.

### tar-commando in Linux

Met het commando `tar` kunt u verschillende bestanden en mappen achtereenvolgens naar een `tar` schrijven en dit indien nodig gebruiken als back-up voor herstel. In tegenstelling tot het in Windows gangbare zip-formaat blijven alle gebruikersrechten van het gearchiveerde bestand behouden, zelfs na het uitpakken. Gebruik de volgende syntaxis:

```bash
tar [OPTIONS] FILES
```

Als u een nieuw archief wilt aanmaken, gebruik dan `tar` met de opties `-c` (nieuw archief aanmaken) en `-f` (archief naar een bepaald bestand schrijven of daaruit lezen). Lees meer in ons artikel over tar-back-ups en het aanmaken van archieven onder Linux.

### echo-commando in Linux

Gebruik het Linux echo -commando om strings regel voor regel uit te voeren op de standaarduitvoer (meestal de terminal).

De algemene opdracht-syntaxis luidt:

```bash
echo [OPTIONS] STRING
```

### duidelijk commando in Linux

Gebruik de opdrachtregelopdracht `clear` om de inhoud van het scherm te wissen.

```bash
clear
```

U krijgt een lege terminal met een prompt te zien. Oudere invoer blijft in de scrollback-buffer staan. In plaats van dit commando te gebruiken, kunt u de terminal ook wissen met de toetscombinatie \[Ctrl\] + \[L\].

### ssh-commando in Linux

U kunt `ssh` gebruiken om uw computer via het SSH-protocol met een externe computer te verbinden, wat betekent dat u zich dan in de shell van de andere computer bevindt. De syntaxis is als volgt:

```bash
ssh USERNAME@HOSTNAME
```

Hier staan USERNAME en HOSTNAME voor de gebruikersnaam waarmee u wilt inloggen en het adres van de externe computer.

### wget-commando in Linux

Je kunt het [Linux `wget` -commando](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-wget-commando/) gebruiken om bestanden van het internet te downloaden. Gebruik hiervoor de volgende syntaxis:

```bash
wget [OPTION] LINK
```

Hier geeft LINK de URL aan waar het bestand te vinden is. U kunt optioneel het optionele argument `-c` gebruiken om een onderbroken download voort te zetten.

### ping-commando in Linux

Gebruik het [Linux `ping` -commando](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-ping-commando/) om de toegankelijkheid van andere computers in het netwerk te testen. Het commando is gebaseerd op de volgende syntaxis:

```bash
ping [OPTIONS] TARGET
```

Samen met de round-trip time (*RTT*) – de tijdspanne tussen het verzenden van het datapakket en het ontvangen van een antwoord – schrijft `ping` ook het IP-adres van het doelsysteem in de terminal. U kunt optionele argumenten gebruiken om het aantal pakketten of seconden in te stellen waarna `ping` zichzelf beëindigt.

### ftp- of sftp-commando in Linux

Hiermee kunt u bestanden uitwisselen tussen het lokale systeem en een andere computer in het netwerk. Gebruik FTP (File Transfer Protocol) volgens de volgende syntaxis om een verbinding tot stand te brengen met de FTP-server van de doelcomputer:

```bash
ftp [OPTIONS] [HOST[PORT]]
```

De adressering gebeurt via de hostnaam of het IP-adres. Het opgeven van een poortnummer is optioneel. Gebruik FTP alleen in netwerken die u vertrouwt, aangezien dit protocol niet veilig is. Om veiligheidsredenen is het bijna altijd raadzaam om SFTP (SSH File Transfer Protocol) te gebruiken. Het commandoregelprogramma `sftp` functioneert net als `ftp` om gegevens in het netwerk over te dragen, maar hier is de overdracht versleuteld. SFTP maakt standaard gebruik van Secure Shell (SSH), d.w.z. ook de authenticatiemethoden ervan. In een ander artikel leggen we uit hoe u SSH-sleutels kunt gebruiken voor uw netwerkverbinding.

### ip-commando in Linux

Het opdrachtregelprogramma `ip` maakt deel uit van de programmacollectie `iproute2`, waarmee netwerkinterfaces via de terminal worden aangevraagd en geconfigureerd. De algemene syntaxis van de opdracht luidt:

```bash
ip [OPTIONS] OBJECT [COMMAND [ARGUMENT]]
```

Welke actie door `ip` wordt uitgevoerd, wordt gedefinieerd met behulp van objecten, subcommando’s en hun argumenten.

Het programma ondersteunt verschillende objecten, zoals `address` (IP-adres), `link` (netwerkinterface), `route` (vermelding in de routeringstabel) of `tunnel`, waaraan subcommando’s zoals `add`, `change`, `del`, `list` of `show` kunnen worden toegevoegd.

Als u bijvoorbeeld het IP-adres van een bepaalde netwerkinterface (bijvoorbeeld `eth0`) wilt opvragen, gebruikt u het commando `ip` in combinatie met het object `address`, het commando `show` en het argument `dev eth0`:

```bash
ip address show dev eth0
```

In een ander artikel laten we u zien hoe u een IP-adres in Linux kunt weergeven.

### apt-, pacman- en yum-commando’s in Linux

Elke Linux-distributie heeft een **pakketbeheerder** waarmee u softwarepakketten kunt downloaden en beheren. De syntaxis voor het installeren van apps is als volgt:

```bash
apt install [PACKET] # Debian-based distributions such as Ubuntu
pacman -S [PACKET] # Arch-based distributions
yum install [PACKET] # Red Hat-based distributions
```

`[PACKET]` is de naam van het pakket of programma dat u wilt installeren. In de meeste gevallen moeten deze commando’s worden uitgevoerd via `sudo` in root-modus. Voor andere distributies die andere pakketbeheerders gebruiken, kunnen de commando’s verschillen. Elke beheerder heeft ook commando’s om pakketten te verwijderen, de pakketlijst bij te werken en alle geïnstalleerde pakketten bij te werken, onder andere. Op Ubuntu zijn deze commando’s als volgt.

```bash
apt remove [PACKET] # remove package
apt update # update package list
apt upgrade # upgrade packages
```

### netstat-commando in Linux

Het opdrachtregelprogramma `netstat` wordt gebruikt om de status van netwerkinterfaces op te vragen. De algemene syntaxis van de opdracht luidt:

```bash
netstat [OPTIONS]
```

Gebruik `netstat` zonder optie om alle geopende sockets in de terminal weer te geven. U kunt ook de volgende opties gebruiken om de routeringstabel (`-r`), interface-statistieken (`-i`), gemaskeerde verbindingen (`-M`) of netwerkverbindingsberichten (`-N`) te bekijken. Lees meer in onze inleiding tot netstat.

### traceroute-commando in Linux

Om de transportroute van een IP-datapakket tussen uw systeem en een doelcomputer te traceren, kunt u het commando traceroute. Gebruik het volgende patroon.

```bash
traceroute [OPTIONS] HOSTNAME
```

Via `traceroute` kunt u vaststellen langs welke router en internetknooppunten een IP-pakket onderweg is naar de doelcomputer, bijvoorbeeld om de oorzaak van een vertraging te onderzoeken.

### route-commando in Linux

Met het commandoregelprogramma `route` kan de IP-routeringstabel van de kern worden opgevraagd en bewerkt. Het commando is gebaseerd op de volgende syntaxis:

```bash
route [OPTIONS] [add|del] [-net|-host] TARGET
```

Gebruik het commando zonder opties om de volledige routeringstabel van de kern weer te geven:

```bash
route
```

Als u een route naar een netwerk wilt instellen, gebruikt u het subcommando `add`.

```bash
route add -net 10.0.0.0
```

### dig-commando in Linux

`dig` is een opzoekprogramma dat kan worden gebruikt om informatie op te vragen bij de DNS-server en deze weer te geven in de terminal. Het opdrachtregelprogramma wordt over het algemeen gebruikt volgens de volgende syntaxis om het IP-adres en andere DNS-informatie over een bepaalde domeinnaam op te vragen:

```bash
dig [@SERVER] [DOMAIN] [TYPE]
```

SERVER is de DNS-server waarop naar de gewenste informatie moet worden gezocht. Als er geen server wordt opgegeven, identificeert `dig` de standaard DNS-server uit het bestand `/etc/resolv.conf`. DOMAIN staat voor de domeinnaam waarvan de DNS-informatie moet worden geïdentificeerd. TYPE wordt gebruikt om het type query te specificeren, d.w.z. ANY (alle vermeldingen), A (IPv4-record van een host) of AAAA (IPv6-record van een host). Het standaardverzoektype is gedefinieerd als A.

### mount- en unmount-commando in Linux

Als een bestandssysteem via de directorystructuur in de directorystructuur van het besturingssysteem moet worden geïntegreerd, wordt onder Linux het opdrachtregelprogramma `mount` gebruikt. De algemene syntaxis van de opdracht luidt:

```bash
mount [OPTIONS] DEVICE MOUNTPOINT
```

DEVICE = Pad naar het apparaatbestand van het opslagapparaat dat u als partitie wilt koppelen.

MOUNTPOINT = De locatie in de directorystructuur van uw besturingssysteem waar u de partitie wilt koppelen. Het koppelpunt wordt meestal gespecificeerd als een absoluut pad.

Voorbeeld:

```bash
mount /dev/sdd /media/usb
```

Het apparaat `sdd` is gemonteerd in de directory `/media/usb`.

### dd-commando in Linux

Het opdrachtregelprogramma `dd` maakt een kopieerproces mogelijk waarbij gegevens bit voor bit uit een invoerbestand (`if`) worden gelezen en naar een uitvoerbestand (`of`) worden geschreven. De programma-aanroep is gebaseerd op de volgende syntaxis:

```bash
dd if=Source of=Target [OPTIONS]
```

Als bron en doel kunt u zowel afzonderlijke bestanden als volledige partities (bijv. /dev/sda1) of een volledig opslagapparaat (bijv. /dev/sda) opgeven.

```bash
dd if=/dev/sda5 of=/dev/sdb1
```

### chmod-commando in Linux

Het commandoregelprogramma `chmod` (afkorting van *change mode*) wordt gebruikt om rechten toe te wijzen in Unix-achtige bestandssystemen (d.w.z. ext2, ext3, ext4, reiser, xfs). De algemene syntaxis van het commando luidt:

```bash
chmod [OPTIONS] MODE FILE
```

of

```bash
chmod [OPTIONS] MODE DIRECTORY
```

De MODE-plaatshouder staat voor het toepasselijke rechtenmasker. Meer informatie over hoe u een dergelijk systeem kunt maken en waar u op moet letten, vindt u in onze handleiding over toegangsrechten met chmod. Met behulp van de optie `-R` kunnen rechten recursief worden toegewezen aan submappen en bestanden in een map.

### chown-commando in Linux

Het [Linux-commando `chown`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-commando-chown/) staat voor *‘change owner’* (eigenaar wijzigen) en stelt u in staat om de rechten van de eigenaar te wijzigen.

```bash
chown [OPTIONS] [USER][:[GROUP]] FILE
```

of

```bash
chown [OPTIONS] [USER][:[GROUP]] DIRECTORY
```

Om eigendomsrechten voor een gebruiker of groep in te stellen, zijn er vier mogelijke combinaties beschikbaar. Eigenaar en groep worden opnieuw ingesteld op basis van de invoer:

```bash
chown [OPTIONS] owner_name:group_name file.txt
```

```bash
# The group is reset according to the input, the user remains unchanged:
chown [OPTIONS] :group_name file.txt
# The owner is reset according to the input, the group remains unchanged:
chown [OPTIONS] owner_name file.txt
# The user is reset according to the input. The group is set to the default group for the logged-in user:
chown [OPTIONS] owner_name: file.txt
# The changes are recursively extended to subdirectories with the help of OPTION `-R`.
```

### adduser-commando in Linux

De eenvoudigste manier om een gebruikersaccount aan te maken is met behulp van het commandoregelprogramma `adduser`. Dit is een Perl-script dat is gebaseerd op het [Linux-commando `useradd`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-commando-useradd/) en biedt dezelfde functies op een gebruiksvriendelijke manier. Het commando `adduser` vereist root-rechten en wordt gebruikt volgens de volgende syntaxis:

```bash
adduser [OPTIONS] USERNAME
```

Gebruik `adduser` zonder opties om automatisch een gebruikers-ID, homedirectory en gebruikersgroep met dezelfde naam aan te maken, naast het nieuwe gebruikersaccount.

```bash
adduser test
```

Daarna volgt een interactief dialoogvenster waarin u het wachtwoord en andere gebruikersgegevens (echte naam, kantoornummer, telefoonnummer, enz.) kunt definiëren.

### passwd-commando in Linux

Gebruik het [Linux `passwd` -commando](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-commando-passwd/) om het wachtwoord van een gebruiker te wijzigen of intervallen te definiëren, controleren en wijzigen. Het commando is gebaseerd op de volgende syntaxis:

```bash
passwd [OPTIONS] USERNAME
```

Als u het wachtwoord van een andere gebruiker wilt wijzigen, hebt u root-rechten nodig. Gebruik het commando `passwd` zonder gebruikersnaam om uw eigen wachtwoord te wijzigen. Als het wachtwoord moet worden geblokkeerd, gebruikt u het commando `passwd` met de optie `-l` (*–lock*). Andere opties bieden u de mogelijkheid om een geldigheidsduur voor wachtwoorden `(-x)`, waarschuwingen `(-w)` en controle-intervallen `(-i)` in te stellen.

### groupadd-commando in Linux

Het opdrachtregelprogramma `groupadd` wordt gebruikt om gebruikersgroepen aan te maken. Gebruik `groupadd` met root-rechten volgens de volgende syntaxis:

```bash
sudo groupadd [OPTIONS] GROUPS
```

Elke nieuw aangemaakte groep heeft een eigen groeps-ID (GID). Groeps-ID’s tussen 0 en 99 zijn gereserveerd voor systeemgroepen. Als u zelf de GID voor een nieuwe gebruikersgroep wilt definiëren, gebruikt u de opdrachtregelopdracht `groupadd` met de optie `-g` (GID). Als u een systeemgroep wilt aanmaken, gebruikt u de optie `-r` (root).

### chattr-commando in Linux

Met het opdrachtregelprogramma `chattr` (afkorting van *change attribute*) kunt u bestanden of mappen met attributen bekijken. Gebruik `chattr` volgens de volgende syntaxis om een attribuut in te stellen:

```bash
chattr [OPTIONS] +ATTRIBUTE FILE
```

Vervang het plusteken door een minteken om attributen weer te verwijderen. Stel bijvoorbeeld het attribuut `-i` in om wijzigingen (verwijderingen of aanpassingen) aan een bestand of map te voorkomen. Raadpleeg de handleiding van het programma `chattr` voor andere attributen en mogelijke opties.

### lsattr-commando in Linux

Als u wilt weergeven welke attributen zijn ingesteld voor een bestand of map, gebruikt u de opdrachtregelopdracht `lsattr` (afkorting van *list attributes*) volgens de volgende syntaxis:

```bash
lsattr [OPTIONS] FILE/DIRECTORY
```

### chgrp-commando in Linux

Het commando `chgrp` staat voor *‘change group’* (groep wijzigen) en wordt gebruikt voor het beheer van groepslidmaatschappen voor bestanden en mappen. Om `chgrp` te kunnen gebruiken op een gekozen bestand of map, moet u eigenaar- of rootrechten hebben. Dit zijn de enige groepen waartoe u kunt behoren. `chgrp` wordt gebruikt volgens de volgende syntaxis:

```bash
chgrp [OPTIONS] GROUP FILE
```

of

```bash
chgrp [OPTIONS] GROUP DIRECTORY
```

De optie `-R` verwijst naar submappen en bestanden in een map.

### man-commando in Linux

Het commando `man` opent de handleidingpagina’s (*man-pagina’s*) van uw Linux-distributie rechtstreeks in de terminal. Gebruik het volgende schema om de handleidingpagina’s op te roepen:

```bash
man [OPTION] TOPIC
```

De Linux man-pagina’s zijn onderverdeeld in 10 onderwerpsgebieden: gebruikerscommando’s, systeemaanroepen, functies van de programmeertaal C, bestandsformaten, configuratiebestanden, games, diversen, systeembeheercommando’s, kernfuncties, nieuwe commando’s.

### shutdown-commando in Linux

Het Linux-commando shutdown kan door de rootgebruiker worden gebruikt om het systeem af te sluiten. Het commando is gebaseerd op de volgende syntaxis:

```bash
shutdown [OPTIONS] [TIME] [MESSAGE]
```

Als u een uitschakeling wilt activeren, kunt u een tijdstip instellen waarop het systeem moet worden uitgeschakeld. Gebruik hiervoor een concrete tijdinvoer (uu:mm) of een aftelling (+m). Andere gebruikers op het systeem krijgen een uitschakelingsbericht. Dit kan indien nodig vergezeld gaan van een persoonlijk bericht. Als het commando `shutdown` wordt gebruikt met de optie `-r`, wordt het uitschakelen van het systeem gevolgd door een herstart.

### top-commando in Linux

Het commando `top` roept een dynamisch overzicht op van alle actieve processen. De oproep is gebaseerd op het volgende patroon:

```bash
top [OPTIONS]
```

De uitvoer van de procesinformatie kan met behulp van verschillende opties worden aangepast. Het `top` -procesoverzicht (onder andere) ondersteunt de volgende sneltoetsen om de uitvoer te sorteren:

- \[P\] = Sorteert de uitvoer op basis van CPU-belasting
- \[M\] = Sorteert de uitvoer op basis van opslagvereisten
- \[N\] = Sorteert de uitvoer numeriek op PID
- \[A\] = Sorteert de uitvoer op ouderdom
- \[T\] = Sorteert de uitvoer op tijd
- \[U GEBRUIKERSNAAM of UID\] = Filtert de uitvoer op respectievelijke gebruiker

Gebruik de sneltoets \[H\] om een helppagina weer te geven, of \[Q\] om het procesoverzicht te sluiten.

### lscpu-commando in Linux

Gebruik `lscpu` (afkorting van *list cpu*) volgens het volgende patroon om informatie over de CPU-architectuur in de terminal weer te geven.

```bash
lscpu [OPTIONS]
```

Raadpleeg de handleiding van uw besturingssysteem voor mogelijke opties.

### lshw-commando in Linux

Het commando `lshw` staat voor *lijst hardware* en geeft informatie weer over de hardwarecomponenten in de terminal. Gebruik `lshw` volgens de volgende syntaxis:

```bash
lshw [OPTIONS]
```

Het commando ondersteunt verschillende opties voor het aanpassen van het uitvoerformaat (`-html`, `-xml`, `-short`, `-businfo`) en het bereik van de informatie (bijvoorbeeld `–sanitize` om gevoelige informatie te verbergen).

### kill-commando in Linux

`kill` is een opdrachtregelprogramma waarmee processen kunnen worden gestopt en beëindigd. De opdracht wordt doorgegeven volgens het volgende patroon met een gewenst signaal en de ID van het gekozen proces.

```bash
kill [OPTIONS] [-SIGNAL] PID
```

Veelvoorkomende signalen zijn:

1. `TERM`: Zorgt ervoor dat een proces zichzelf beëindigt (standaard)
2. `KILL`: Dwingt het beëindigen van een proces af (via het systeem)
3. `STOP`: Stopt een proces
4. `CONT`: Laat een gestopt proces doorgaan

### killall-commando in Linux

Gebruik het [Linux `killall` -commando](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-commando-killall/) in combinatie met een bepaalde zoekterm om alleen de processen te beëindigen waarvan de namen overeenkomen (de eerste 15 tekens worden gebruikt om te matchen).

```bash
killall [OPTIONS] [-SIGNAL] [PROCESS NAME]
```

Met de optie `-e` (*–exact*) kunt u de overeenkomst uitbreiden naar alle tekens van de procesnaam.

### mooie opdracht in Linux

De opdrachtregelrichtlijn `nice` geeft een proceswaarde tussen -20 en +19 aan bij het starten van een proces in gehele stappen, waarna de beschikbare rekenkracht van het systeem wordt verdeeld. Het bereik van -20 tot +19 komt overeen met de Linux-prioriteitsniveaus 100 tot 139. Een proces met een `nice` -20 heeft een hogere prioriteit dan een proces met een `nice` 19. De solo-syntaxis luidt:

```bash
nice [OPTION] [COMMAND]
```

Zonder aanvullende specificatie begint elk proces met een waarde van 0 `nice`. Gebruik optie `-n` om de prioriteit van het proces te definiëren. Houd er rekening mee dat negatieve prioriteiten alleen kunnen worden toegewezen met root-rechten.

### pgrep-commando in Linux

Het opdrachtregelprogramma `pgrep` vergelijkt de lijst met actieve processen met een zoekterm en geeft de bijbehorende PID’s weer als er overeenkomsten zijn. De algemene syntaxis luidt als volgt:

```bash
pgrep [OPTIONS] Search term
```

Standaard geeft `pgrep` de PID’s weer van alle processen die de zoekterm bevatten. Als de zoekopdracht moet worden beperkt tot alleen exacte overeenkomsten, gebruik dan het commando samen met de optie `-x`. Als u naast de procesnaam ook de PID wilt verkrijgen, gebruik dan `pgrep` met de optie `-l`. Net als `grep` ondersteunt `pgrep` zoektermen op basis van reguliere expressies.

### ps-commando in Linux

Het [Linux-commando `ps`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-ps-commando/) geeft een lijst weer van alle actieve processen in de terminal.

```bash
ps [OPTIONS]
```

Als u een gedetailleerde uitvoer nodig hebt, gebruik dan `ps` met de opties `-f` (gedetailleerd) of `-F` (zeer gedetailleerd). Raadpleeg de handleiding van uw besturingssysteem voor aanvullende opties.

## Extra Linux-commando’s in één oogopslag

### Basisopdrachten

In de categorie basisopdrachten vindt u de basisopdrachten van Linux die worden gebruikt om **de terminal te bedienen**. Leer hoe u de zichtbaarheid van de terminal kunt wissen, eerdere terminal-invoer uit de geschiedenis kunt ophalen of de terminalsessie kunt afsluiten.

**1. afsluiten**

De opdrachtregelopdracht `exit` beëindigt de huidige sessie en sluit de terminal.

```bash
exit
```

In plaats daarvan kunt u de toetsencombinatie \[Ctrl\] + \[D\] gebruiken.

**2. hulp**

Gebruik het commando `help` om een lijst te zien van alle geïntegreerde shell-commando’s (ingebouwde commando’s). Roep `help` op in combinatie met een shell-commando om een korte beschrijving van de betreffende vraag op te halen.

```bash
help COMMAND
```

**3. geschiedenis**

In Bash worden de laatste 500 commando’s die in de opdrachtregel zijn ingevoerd, opgeslagen in de geschiedenis. Deze functie dient als invoerhulp en stelt u in staat om met de pijltjestoetsen door de lijst met eerdere commando’s te bladeren en deze opnieuw uit te voeren.

De geschiedenis kan worden doorzocht met behulp van trefwoorden met de toetscombinatie \[Ctrl\] + \[R\]. U hebt ook de mogelijkheid om de volledige lijst te bekijken, genummerd in de terminal. Gebruik het commando `history` zonder opties en argumenten.

```bash
history
```

Als u de resultaten wilt filteren, combineert u `history` via Linux Pipe met het opdrachtregelprogramma `grep` (zie zoekopties) en een zoekterm.

```bash
history | grep SEARCH TERM
```

### Help-pagina’s

Weet u niet wat u moet doen? Geen zorgen. Onder Linux zijn er verschillende **help- en documentatiepagina’s** direct beschikbaar via de terminal, zoals de *Unix man-pagina’s* en *GNU info-pagina’s*. Deze bevatten een gedetailleerde beschrijving van alle commandoregelprogramma’s, systeemaanroepen, configuratiebestanden, bestandsformaten en kernfuncties. Met de [Linux-commando’s `whatis`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-whatis-commando/) en `apropos` kunt u commandoregelprogramma’s vinden in de categorie help-pagina’s, waarmee u de handleidingpagina’s van uw besturingssysteem kunt doorzoeken op trefwoorden.

**1. apropos**

Gebruik `apropos` om de paginatitels en beschrijvingen van de handleiding van uw besturingssysteem op trefwoorden te doorzoeken. Raadpleeg het volgende schema:

```bash
apropos [OPTIONS] SEARCH TERM
```

Het commando ondersteunt verschillende opties. Gebruik de optie `-e` om de zoekopdracht te beperken tot exacte overeenkomsten, of gebruik jokertekens (`-w '*SEARCH TERM'`) en reguliere expressies (`-r`).

**2. info**

Met het commando `info` kunt u de GNU-infopagina’s voor een specifiek onderwerp opvragen. In de meeste gevallen komen deze pagina’s overeen met de handleidingspagina’s die via `man` kunnen worden geraadpleegd, maar in tegenstelling tot deze hebben ze links die de navigatie in de handleiding eenvoudiger maken. Gebruik de volgende syntaxis:

```bash
info [OPTION] TOPIC
```

Een oproep zonder optie of onderwerp brengt u naar het hoofdmenu van de GNU-infopagina.

**3. pinfo**

Met `pinfo` beschikt u over een variant van het opdrachtregelprogramma `info`, dat is gebaseerd op de opdrachtregelbrowser Lynx en informatiepagina’s met gemarkeerde koppelingen weergeeft. Gebruik `pinfo` op dezelfde manier als het commando `info`:

```bash
pinfo [OPTIONS] TOPIC
```

**4. wat is**

Het opdrachtregelprogramma `whatis` dient als een trefwoordzoekfunctie in de handleidingpagina’s. Roep dit programma op met een veelgebruikt trefwoord om de handleiding van uw besturingssysteem te doorzoeken op exacte overeenkomsten. Als er een overeenkomst is, geeft `whatis` een korte beschrijving in de terminal.

```bash
whatis [OPTIONS] SEARCH TERM
```

`whatis` (`-w '\*SEARCH TERM'`) ondersteunt ook plaatshouders en reguliere expressies (`-r`).

### Directory-bewerkingen

Je gebruikt Linux-commando’s voor directorybewerkingen om mappen op je systeem aan te maken, te verwijderen en te beheren via de terminal, en om door de mappenstructuur te navigeren. De belangrijkste commandoregelopdrachten in deze categorie zijn `cd`, `ls`, `mkdir` en `rmdir`.

**1. chroot**

Het commando `chroot` (afkorting van *change root*) wordt gebruikt om een commando in een andere root-directory uit te voeren. `chroot` wordt bijvoorbeeld gebruikt om kritieke programma’s te isoleren van de rest van het bestandssysteem. Het aanroepen van het programma vereist root-rechten en is gebaseerd op de volgende formule:

```bash
chroot DIRECTORY COMMAND
```

**2. mkdirhier**

Met `mkdirhier` kunt u volledige directoryhiërarchieën maken met één enkele opdrachtregelopdracht:

```bash
mkdirhier [OPTION] /home/user/directory1/directory2/directory3
```

Als `directory1` en `directory2` al bestaan, maakt `mkdirhier` alleen `directory3` aan. Anders worden alle drie de mappen aangemaakt.

**3. boom**

Terwijl `ls` alleen de inhoud van een map weergeeft, kan de opdrachtregelopdracht `tree` worden gebruikt om de volledige mapstructuur recursief weer te geven als een boomstructuur. De opdracht gebruikt de volgende syntaxis:

```bash
tree [OPTIONS] [DIRECTORY]
```

### Bestandsbewerkingen

Met de Linux-opdrachten in deze tabel kunt u verschillende bestandsbewerkingen uitvoeren vanaf de terminal. Gebruik de basisopdrachten van Linux, zoals `cp`, `mv` en `rm`, om bestanden op uw systeem te kopiëren, verplaatsen, hernoemen of verwijderen.

**1. basename**

Een bestandspad wordt doorgegeven aan de opdrachtregelrichtlijn `basename`, die eenvoudigweg de bestandsnaam zonder standaardpad retourneert. De syntaxis van de opdracht luidt:

```bash
basename [OPTIONS] path/to/files [SUFFIX]
```

Het commando kan met behulp van opties worden uitgebreid naar meerdere bestanden.

**2. comm**

Gebruik het opdrachtregelprogramma `comm` om gesorteerde bestanden (d.w.z. via `sort`) regel voor regel te vergelijken. De programma-aanroep is gebaseerd op de volgende syntaxis:

```bash
comm [OPTIONS] FILE1 FILE2
```

Het programma ondersteunt drie opties:

- -1: unieke regels uit `FILE1` onderdrukken
- -2: unieke regels uit `FILE2` onderdrukken
- -3: alle regels onderdrukken die in beide bestanden voorkomen

**3. knippen**

Met het commando `cut` kunt u de inhoud van een bestand uit de tekstregel van een bestand (bijvoorbeeld log- of CSV-bestanden) extraheren. De syntaxis van het commando luidt als volgt:

```bash
cut [OPTIONS] FILE
```

De exacte positie van een geëxtraheerd gedeelte wordt gedefinieerd via de opties `-b` (bytepositie), `-c` (tekenpositie), `-d` (scheidingsteken) en `-f` (veld).

**4. dirname**

`dirname` is de tegenhanger van `basename`. Met deze opdrachtregelopdracht kunt u het padgedeelte uit een bestandspad halen en dit zonder bestandsnamen in de terminal weergeven. De syntaxis van de opdracht luidt als volgt:

```bash
dirname [OPTIONS] path/to/file
```

**5. bestand**

Met de opdrachtregelopdracht `file` kunt u informatie over het bestandstype van een bestand weergeven. De aanroep is gebaseerd op de volgende syntaxis:

```bash
file [OPTIONS] FILE
```

**6. lsof**

[Het Linux-commando `lsof`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-lsof/) staat voor *list open files*, een tool die u informatie geeft over geopende bestanden in de terminal, gesorteerd op PID (process ID). Roep het programma op in de terminal met behulp van de volgende syntaxis:

```bash
lsof [OPTIONS]
```

Aangezien Unix-achtige systemen zoals Linux over het algemeen het beleid volgen dat ‘alles een bestand is’, is de lijst die door het `lsof` -commando wordt weergegeven navenant lang. In de regel worden de opties gebruikt om deze uitvoer te beperken.

**7. md5sum**

Met de opdrachtregelopdracht `md5sum` kunt u MD5-controlesommen voor bestanden berekenen en controleren.

**8. plakken**

Net als `cat` maakt het opdrachtregelprogramma `paste` het ook mogelijk om de inhoud van bestanden naar de standaarduitvoer te sturen. Maar terwijl `cat` alleen inhoud combineert, voegt `paste` kolom voor kolom samen. De basissyntaxis van de opdracht luidt:

```bash
paste [OPTIONS] FILE1 FILE2 …
```

U kunt met optie `-d` instellen welke scheidingsteken door `paste` wordt gebruikt. Standaard worden tabs als scheidingsteken gebruikt. Met optie `-s` (serieel) kan een tweede modus worden geactiveerd. Hiermee worden alle regels van het eerste invoerbestand naar de eerste regel van de uitvoer overgebracht. De gegevens voor alle andere invoerbestanden volgen in afzonderlijke uitvoerregels, zodat elke regel van de uitvoer de inhoud van slechts één invoerbestand bevat.

**9. hernoemen**

Het opdrachtregelprogramma `rename` maakt het mogelijk om bestanden en mappen te hernoemen met behulp van reguliere expressies (regex). In tegenstelling tot `mv` is de functie `rename` geschikt voor bestandsbewerkingen waarbij de namen van meerdere bestanden gedeeltelijk of volledig moeten worden aangepast. Gebruik `rename` volgens de volgende syntaxis:

```bash
rename [OPTIONS] 'REGULAR_EXPRESSION' FILE
```

Reguliere expressies komen overeen met de volgende syntaxis voor vervangingen:

```bash
s/SEARCHPATTERN/REPLACEMENT/MODIFIER
```

**10. versnipperen**

`shred` is een opdrachtregelprogramma waarmee bestanden veilig kunnen worden verwijderd. Geselecteerde elementen worden tijdens het verwijderingsproces overschreven en kunnen dus niet met forensische middelen worden hersteld. De algemene syntaxis van de opdracht luidt:

```bash
shred [OPTIONS] FILE
```

**11. sorteren**

Gebruik de opdrachtregelopdracht `sort` om bestandslijsten en programma-uitvoer numeriek, alfabetisch en op rij te sorteren. De algemene syntaxis van de opdracht luidt:

```bash
sort [OPTIONS] FILE
```

De sorteermethode kan worden aangepast met behulp van opties. Bijvoorbeeld numeriek (`-n`), willekeurig (`-R`) of in omgekeerde volgorde (`-r`).

**12. splitsen**

De opdrachtregelrichtlijn `split` wordt gebruikt om bestanden te splitsen. De onderliggende syntaxis luidt:

```bash
split [OPTIONS] [INPUT [PREFIX]]
```

De plaatshouder INPUT komt overeen met het bestand dat moet worden gesplitst. De *PREFIX* fungeert voor de namen van de deelnemende bestanden. Hun naam is gebaseerd op het volgende patroon:

```bash
PREFIXaa, PREFIXab, PREFIXac …
```

Als er geen voorvoegsel is gedefinieerd, gebruikt `split` het standaardvoorvoegsel `x`. De optie `-b` (bytes) kan worden gebruikt om de grootte van de gedeeltelijke bestanden te specificeren. Dit kan worden gespecificeerd in bytes (b), kilobytes (k) of megabytes (m).

Voorbeeld:

```bash
split -b 95m archive.tgz split-archive.tgz.
```

**13. stat**

De opdrachtregelopdracht `stat` (*status*) geeft de toegangs- en wijzigingstijdstempels weer voor geselecteerde bestanden en mappen. De algemene syntaxis van de opdracht luidt als volgt:

```bash
stat [OPTIONS] FILE
```

Het uitvoerformaat kan worden aangepast met behulp van opties.

**14. uniek**

De opdrachtregelopdracht `uniq` wordt meestal in combinatie met `sort` gebruikt om gesorteerde bestanden te ontdoen van dubbele regels. In het volgende voorbeeld wordt de opdracht `sort` via een pipe (`|`) gekoppeld aan de opdracht `uniq` om eerst een bestand te sorteren en vervolgens uit te voeren zonder dubbele regels.

```bash
sort file.txt | uniq
```

### Zoekopties

Linux biedt verschillende opdrachtregelopdrachten om rechtstreeks vanuit de terminal door het systeem te zoeken.

**1. vinden**

Met `find` kunt u een Linux-bestand doorzoeken. Dit is gebaseerd op de volgende syntaxis:

```bash
find [OPTIONS] [DIRECTORY] [SEARCHCONDITION] [ACTIONS]
```

De opgegeven map is de startmap van de zoekopdracht. Het commando doorzoekt vervolgens de startmap en de submappen daarvan. Als er geen map is opgegeven, begint `find` de zoekopdracht vanuit de huidige werkdirectory.

Met opties kunt u zoekcriteria en acties definiëren. De standaardactie is vooraf ingesteld op `-print`: de uitvoer van de volledige bestandsnamen van alle zoekresultaten naar de standaarduitvoer (meestal de terminal). Met verdere opties kunt u filteren op bestandsnaam, bestandsgrootte, tijdstip van toegang, enz. Deze staan vermeld op de bijbehorende man-pagina.

**2. lokaliseren**

Met het opdrachtregelprogramma `locate` kunt u ook via de terminal naar bestanden zoeken. Maar in tegenstelling tot `find` zoekt het niet in de bestandsmap, maar in een speciaal gecreëerde en regelmatig bijgewerkte database. Daardoor levert `locate` veel sneller resultaten op dan `find`. Om in de database naar een bepaald bestand te zoeken, wordt `locate` gebruikt volgens de volgende syntaxis:

```bash
locate SEARCHPATTERN
```

Het zoekpatroon kan metatekens bevatten als plaatshouders (`*`). Zet deze tussen aanhalingstekens om interpretatie door de shell te voorkomen.

**3. tre-agrep**

`tre-agrep` wordt ook gebruikt om op basis van zoekpatronen naar tekenreeksen in tekstbestanden te zoeken. Maar in tegenstelling tot `grep` worden niet alleen exacte overeenkomsten weergegeven, maar zijn ook vage resultaten toegestaan, zoals resultaten met omgewisselde letters of ontbrekende tekens. Het programma is gebaseerd op de TRE-bibliotheek en maakt deze beschikbaar in de opdrachtregel. De syntaxis van `tre-agrep` komt overeen met die van het commando `grep`:

```bash
tre-agrep [OPTIONS] SEARCHPATTERN FILE(S)
```

Met behulp van opties kunt u een maximale foutmarge definiëren. In het volgende voorbeeld wordt maximaal één afwijking getolereerd.

```bash
tre-agrep -1 'Linux' test .txt
```

**4. updatedb**

Een `locate` werkt alleen correct als het `/var/lib/locatedb` continu up-to-date wordt gehouden. Met het `updatedb` kunt u de database handmatig bijwerken. Let op: u hebt hiervoor root-rechten nodig:

```bash
updatedb
```

**5. waar is**

Met het commando `whereis` kunt u de binaire code, broncode of handleidingbestanden van het geselecteerde programma vinden. De algemene syntaxis van het commando luidt:

```bash
whereis [OPTIONS] PROGRAM
```

Opties kunnen worden gebruikt om de zoekopdracht te beperken tot specifieke bestandstypen of mappen.

**6. welke**

Als u de binaire bestanden van een programma wilt identificeren, gebruikt u het commando `which` met de volgende syntaxis om het pad in de terminal weer te geven.

```bash
which [OPTIONS] PROGRAM
```

In de standaardmodus geeft `which` het eerste bestand weer dat het vindt. Gebruik de optie `-a` om alle bestanden weer te geven die aan de zoekcriteria voldoen.

### Gebruikersinformatie

Gebruik de opdrachtregelprogramma’s voor de volgende categorieën om **gedetailleerde informatie** te verkrijgen **over de geregistreerde gebruikers in het systeem**, evenals hun groepen en processen.

**1. vinger**

Het opdrachtregelprogramma `finger` dient om toegang te krijgen tot gebruikersinformatie. Gebruik de opdracht in combinatie met de gewenste gebruikersnaam:

```bash
finger [options] [USERNAME]
```

Gebruik `finger` zonder gebruikersnaam om informatie over uw eigen account te verkrijgen.

**2. groepen**

Het commando `groups` geeft een overzicht van de groepslidmaatschappen van een geselecteerd gebruikersaccount. Gebruik `groups` zonder gebruikersnaam om alle groepen weer te geven waartoe uw gebruikersaccount behoort.

Gebruik de opdrachtregelrichtlijn volgens dit patroon:

```bash
groups [OPTIONS] [USERNAME]
```

**3. id**

De opdrachtregelopdracht `id` geeft de gebruikers- en groeps-ID’s van de geselecteerde gebruikersaccounts weer. Als u uw eigen ID’s wilt identificeren, gebruikt u de opdracht zonder gebruikersnaam.

```bash
id [OPTIONS] [USERNAME]
```

Het bereik van de uitvoer kan worden beperkt met behulp van opties.

**4. laatste**

Gebruik het commando `last` volgens het volgende patroon om een lijst te bekijken van recent ingelogde gebruikers, inclusief inlog- en uitlogtijden.

```bash
last [OPTIONS] [USERNAME]
```

De bijbehorende informatie wordt verkregen uit het bestand `wtmp` onder `/var/log/wtmp`. Als u alleen informatie over een bepaalde account wilt opvragen, voer dan de opdrachtregelopdracht in met de gewenste gebruikersnaam.

**5. w**

Het commando `w` geeft een lijst weer van alle geregistreerde gebruikers, inclusief alle processen die ze hebben uitgevoerd. Gebruik `w` in combinatie met een gebruikersnaam om het commando te beperken tot alleen dit gebruikersaccount:

```bash
w [OPTIONS] [USERNAME]
```

Het bereik en formaat van de uitvoer kan worden aangepast met behulp van opties.

**6. wie**

Het commando `who` geeft gedetailleerde informatie weer over gebruikers die op het systeem zijn geregistreerd. De algemene syntaxis van het commando luidt als volgt:

```bash
who [OPTION] [SOURCEFILE]
```

Standaard verwijst `who` naar gegevens over momenteel geregistreerde gebruikers uit het bestand `/var/run/utmp`. U kunt een van de volgende bestanden opgeven als bron van de informatie.

**7. wie ben ik**

Gebruik het commando `whoami` om uw eigen gebruikersnaam te verkrijgen.

```bash
whoami [OPTIONS]
```

### Beheer van gebruikersaccounts

Linux biedt u een reeks programma’s waarmee u rechtstreeks vanuit de terminal gebruikersaccounts en groepen kunt aanmaken, verwijderen en beheren. Hier vindt u een overzicht van de belangrijke **Linux-commando’s voor het beheer van gebruikersaccounts**. In deze categorie vindt u ook Linux-terminalcommando’s waarmee u toegang krijgt tot code met andere gebruikersrechten, waaronder die van de superuser root.

**1. chfn**

Met de opdrachtregelopdracht `chfn` (afkorting van *change finger*) kunt u aanvullende informatie over een gebruikersaccount aanpassen, zoals de echte naam, het kantoornummer en privé- of zakelijke telefoonnummers. De algemene syntaxis luidt als volgt:

```bash
chfn [OPTION "NEW VALUE"] [USERNAME]
```

Welke gebruikersinformatie een nieuwe waarde krijgt, wordt bepaald met behulp van de opties `-f` (echte naam), `-r` (kantoornummer), `-w` (telefoonnummer werk) en `-h` (telefoonnummer privé).

**2. chsh**

De opdrachtregelopdracht `chsh` (afkorting van *change shell*) wijzigt de aanmeldingsshell van een gekozen gebruiker. Gebruik het volgende patroon als richtlijn bij het invoeren van de gegevens:

```bash
chsh [OPTIONS] USERNAME
```

U kunt de optie `-s` gebruiken om de login-shell van een gebruikersaccount te wijzigen.

**3. deluser**

Het opdrachtregelprogramma `deluser` verwijdert alle vermeldingen voor een geselecteerd gebruikersaccount uit de systeemaccountbestanden. Voor het aanroepen van `deluser` zijn rootrechten vereist en wordt de volgende syntaxis gebruikt:

```bash
deluser [OPTIONS] USERNAME
```

Als u ook alle bestanden uit de homedirectory van de gebruiker wilt verwijderen, gebruik dan het commando met de opties `--remove-home`. Als u alle gebruikersbestanden uit het systeem wilt verwijderen, gebruik dan de opties `--remove-all-files`.

**4. delgroep**

De opdrachtregelopdracht `delgroup` (afkorting van *delete group*) verwijdert een bestaande gebruikersgroep. Om de opdracht uit te voeren, zijn root-rechten vereist. De algemene syntaxis van `delgroup` is:

```bash
delgroup [OPTIONS] GROUP
```

**5. groupmod**

Namen en groeps-ID’s (GID) van bestaande gebruikersgroepen kunnen worden aangepast via `groupmod`. De opdrachtregelopdracht wordt gebruikt met root-rechten volgens de volgende syntaxis:

```bash
groupmod OPTIONS GROUP
```

Gebruik `groupmod` met de optie `-g` om de GID aan te passen. Roep het commando aan met de optie `-n` om de groepsnaam te overschrijven.

**6. newgrp**

Met het commando `newgrp` (afkorting van *nieuwe groep*) kunnen geregistreerde gebruikers hun huidige groeps-ID wijzigen zonder zich af te melden en opnieuw aan te melden. De algemene syntaxis van het commando luidt:

```bash
newgrp [-] [GROUP]
```

Als het commando `newgrp` wordt gebruikt met de optionele parameter \[-\], dan zorgt de groepswijziging voor een herstart van de gebruikersomgeving – alsof de gebruiker opnieuw heeft ingelogd. Degenen die `newgrp` gebruiken zonder groepsspecificatie, veranderen naar de standaardgroep die is gespecificeerd onder `/etc/passwd`.

**7. su**

Met het commando `su` kan een tijdelijke gebruikerswijziging worden uitgevoerd om een programma aan te roepen met de rechten van een doelgebruiker. In tegenstelling tot `sudo` wordt het commando niet direct uitgevoerd. In plaats daarvan vindt er een identiteitswijziging plaats. In plaats van om het wachtwoord van de aanroepende gebruiker te vragen, wordt om het wachtwoord van de doelgebruiker gevraagd. De algemene syntaxis van het commando luidt:

```bash
su [OPTIONS] [USERNAME]
```

Een oproep zonder USERNAME selecteert `root` als doelgebruiker.

**8. usermod**

Met de opdrachtregelopdracht `usermod` kunt u eerder aangemaakte gebruikersaccounts bewerken. Gebruik `usermod` met root-rechten volgens de volgende syntaxis:

```bash
usermod [OPTIONS] USERNAME
```

Welke wijzigingen bedoeld zijn, kan worden gedefinieerd met behulp van opties. U kunt bijvoorbeeld de gebruikersnaam wijzigen met de optie `-l NEW_NAME`. Meer opties zijn te vinden op de bijbehorende man-pagina.

### Systeemopdrachten

In de categorie systeemcommando’s vindt u de basiscommando’s van Linux voor systeembeheer. Gebruik de volgende commando’s om het systeem opnieuw op te starten en af te sluiten vanaf de terminal – en beheer ze indien gewenst met een timer.

**1. logger**

Gebruik `logger` volgens het volgende patroon:

```bash
logger "YOUR MESSAGE"
```

Zoek het systeemlogboek onder `/var/log/syslog`.

**2. opnieuw opstarten**

De opdrachtregelopdracht `reboot` zorgt ervoor dat het systeem opnieuw wordt opgestart. Om een herstart te activeren, moet de opdracht worden uitgevoerd met root-rechten.

```bash
reboot [OPTIONS]
```

**3. rtcwake**

Met de opdrachtregelopdracht `rtcwake` kunt u het systeem starten en afsluiten volgens een timer. De opdracht is gebaseerd op de volgende syntaxis:

```bash
rtcwake [OPTIONS] [MODE] [Time]
```

Kies een bepaalde modus (`-m MODE`) waarnaar het systeem op een bepaald tijdstip in seconden (`-s TIME IN SECONDS`) moet overschakelen. U hebt ook de mogelijkheid om uw systeem op een precies bepaald tijdstip (`-t UNIXTIME`) te activeren.

### Systeeminformatie

In de categorie systeeminformatie hebben we commandoregelprogramma’s verzameld waarmee u **informatie en statusrapporten** kunt **verkrijgen**, zodat u een uitgebreid overzicht krijgt van de staat van uw systeem.

**1. datum**

Het commando `date` geeft de systeemtijd inclusief de datum weer.

```bash
date [OPTIONS] [OUTPUTFORMAT]
```

Als u met een bepaalde tijd in de context van een programma-oproep (zie `rtcwake`) wilt werken, definieert u dit met behulp van de optie `-d 'DATE'`. Daarnaast worden verschillende opties ondersteund waarmee datum- en tijdinformatie naar een gewenst formaat kan worden overgebracht.

**2. df**

Gebruik het commando `df` (*disk free*) volgens het volgende patroon.

```bash
df [OPTIONS] [FILE]
```

Als het commando wordt gebruikt in combinatie met een bepaald bestand, geeft het systeem alleen de vrije ruimte weer op de partitie waar het bestand zich bevindt. Anders wordt de vrije ruimte op de harde schijf van gekoppelde partities weergegeven. De optie `-l` (*lokaal*) beperkt `df` tot het lokale bestandssysteem. Het ondersteunt ook opties waarmee u het uitvoerformaat kunt aanpassen.

**3. dmesg**

Het programma `dmesg` (afkorting van *display message*) geeft berichten uit de circulaire buffer van de kern weer op de terminal en stelt u in staat om hardware- en stuurprogrammafouten op te sporen. Gebruik `dmesg` volgens het volgende patroon:

```bash
dmesg [OPTIONS]
```

De uitvoer `dmesg` bevat alle berichten van de opstartroutine en is dan ook erg lang. Het opdrachtregelprogramma wordt vaak gebruikt in combinatie met een pager, zoals `more`, `less` of `tail`.

**4. gratis**

Het commando `free` geeft het geheugengebruik weer. De algemene syntaxis luidt:

```bash
free [OPTIONS]
```

Als uitvoer krijgt u twee specificaties: `Mem` (*Geheugen*) en `Swap`. `Free` ondersteunt ook de optie `-h` voor het uitvoeren van het geheugengebruik in een voor mensen leesbaar formaat.

**5. hostnaam**

Gebruik het commando `hostname` volgens het volgende patroon om de DNS-namen van het systeem weer te geven.

```bash
hostname [OPTIONS]
```

**6. uname**

De opdrachtregelopdracht `uname` staat voor `unix name` en wordt gebruikt om systeeminformatie uit de kern op te vragen. De opdracht ondersteunt verschillende opties waarmee de uitvoer kan worden gefilterd op basis van de gewenste informatie. Deze zijn te vinden in de bijbehorende man-pagina.

```bash
uname [OPTIONS]
```

**7. uptime**

Als u wilt bepalen hoe lang het systeem al draait sinds de laatste herstart, gebruikt u de opdrachtregelopdracht `uptime` volgens het volgende patroon:

```bash
uptime
```

**8. vmstat**

Met behulp van de monitoringtool `vmstat` kunt u informatie opvragen over het virtuele geheugen, lees- en schrijfprocedures op de schijf en CPU-activiteit. Roep `vmstat` aan volgens de volgende syntaxis om de gemiddelde waarden sinds de laatste systeemstart weer te geven.

```bash
vmstat [OPTIONS]
```

`vmstat` biedt ook een continue bewakingsmodus die zo vaak als gewenst in een gewenst tijdsinterval in seconden toegang geeft tot systeemwaarden.

```bash
vmstat [Options] [INTERVAL [REPETITIONS]]
```

### Hardware-informatie

Linux-commando’s in deze categorie geven **gedetailleerde informatie over de hardwarecomponenten** die de basis van uw systeem vormen.

**1. lspci**

Gebruik `lspci` (afkorting van *list pci*) volgens het volgende patroon om gedetailleerde informatie over PCI-apparaten weer te geven.

```bash
lspci [OPTIONS]
```

Raadpleeg de handleiding van uw besturingssysteem voor mogelijke opties.

**2. lsusb**

Gebruik `lsusb` (afkorting van *list usb*) om gedetailleerde informatie over USB-apparaten weer te geven in de terminal.

```bash
lsusb [OPTIONS]
```

Raadpleeg de handleiding van uw besturingssysteem voor mogelijke opties.

### Procesbeheer

Op Linux wordt een exemplaar van een actief programma een proces genoemd. De volgende terminalopdrachten maken deel uit van het standaardrepertoire van het procesbeheer en stellen u in staat om **alle processen op uw systeem eenvoudig vanaf de terminal te controleren** en indien nodig te beheren.

**1. chrt**

Het opdrachtregelprogramma `chrt` houdt zich bezig met continue procesbesturing en maakt het mogelijk om de realtime-attributen (planningregeling en prioriteit) van lopende processen te identificeren en aan te passen, of om opdrachten en hun argumenten met gespecificeerde realtime-attributen uit te voeren. De algemene syntaxis van de opdracht luidt als volgt:

```bash
chrt [OPTIONS] [PRIOTITY] PID/COMMAND [ARGUMENT]
```

Gebruik `chrt` zonder een prioriteit in te voeren en met de optie `-p` om de realtime-attributen van gekozen processen te identificeren.

`chrt` biedt ook de mogelijkheid om met behulp van opties de planningsregels voor lopende of nieuw gestarte processen in te stellen of te definiëren. Meer informatie hierover vindt u in de bijbehorende man-entry.

**2. ionice**

De opdrachtregelrichtlijn `ionice` wordt gebruikt om de prioriteit te beïnvloeden van een proces dat gebruikmaakt van de I/O-interface van de kern. De algemene syntaxis van de opdracht luidt:

```bash
ionice [OPTIONS] COMMAND
```

Om ionice te kunnen uitvoeren, hebt u root-rechten nodig. Het commando maakt onderscheid tussen drie planningsklassen die worden doorgegeven met de optie `-c class`. Mogelijke waarden zijn 1, 2 en 3.

- 1 = Real time: De I/O-actie wordt onmiddellijk uitgevoerd.
- 2 = Best effort: De I/O-actie wordt zo snel mogelijk uitgevoerd.
- 3 = Inactief: De I/O-actie wordt alleen uitgevoerd wanneer geen ander proces I/O-tijd in beslag neemt.

**3. nohup**

Normaal gesproken worden alle afhankelijke processen van een gebruiker automatisch beëindigd zodra de terminalsessie wordt gesloten (d.w.z. via `exit`). Het [Linux-commando `nohup`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-nohup-opdracht/) (afkorting van *no hangup*) verwijdert een commando uit de huidige sessie en zorgt ervoor dat u het commando kunt blijven uitvoeren, zelfs wanneer u zich afmeldt bij het systeem.

```bash
nohup COMMAND
```

**4. pidof**

Het opdrachtregelprogramma `pidof` geeft de procesidentificatienummers (PID’s) van alle processen van een programma weer. Identificeer PID’s via `pidof` volgens het volgende patroon:

```bash
pidof [OPTIONS] PROGRAM
```

Als u alleen het eerste proces-ID wilt uitvoeren, gebruik dan `pidof` in combinatie met de optie `-s` (afkorting van *single shot*).

**5. pidkill**

Net als `kill` stuurt het commando `pkill` ook een signaal naar een gekozen proces. De adressering gebeurt echter niet op basis van PID. In plaats daarvan wordt een zoekterm opgegeven die overeenkomt met de naam van het actieve proces. Dit kan ook worden geformuleerd als een reguliere expressie. `pkill` stuurt het standaardsignaal TERM door, zolang er geen andere signalen zijn gedefinieerd. De algemene syntaxis van het commando luidt:

```bash
pkill [OPTIONS] [-SIGNAL] [SEARCHTERM]
```

Extra opties kunnen worden gebruikt om het commando te beperken tot de processen van een bepaalde gebruiker (`-U UID`), de subprocessen van een bepaald bovenliggend proces (`-P PID`) of de nieuwste (`-n`) of oudste (`-o`) processen.

**6. pstree**

Gebruik `pstree` om alle actieve processen in een boomstructuur weer te geven. De algemene syntaxis van het commando luidt:

```bash
pstree [OPTIONS]
```

Het formaat en het bereik van de uitvoer kunnen worden aangepast met behulp van verschillende opties.

**7. renice**

Met de opdrachtregelopdracht `renice` kunt u de prioriteit van een actief proces aanpassen. De algemene syntaxis luidt als volgt:

```bash
renice PRIORITY [OPTIONS]
```

**8. slaap**

Met het [Linux `sleep` -commando](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-commando-voor-slaapstand/) kunt u de huidige terminalsessie voor een bepaalde tijd onderbreken. De algemene syntaxis van het commando luidt:

```bash
sleep NUMBER[SUFFIX]
```

Als u `sleep` zonder achtervoegsel gebruikt, wordt het opgegeven getal geïnterpreteerd als tijd in seconden (s). U hebt ook de mogelijkheid om de terminalsessie te onderbreken voor minuten (m), uren (h) of dagen (d).

**9. takenpakket**

De opdrachtregelrichtlijn `taskset` wordt gebruikt voor geavanceerde procescontrole, die in multiprocessorsystemen wordt gebruikt om processen of opdrachten aan specifieke processors toe te wijzen. De opdracht vereist root-rechten en gebruikt een van de volgende patronen:

```bash
taskset [OPTIONS] MASK COMMAND
taskset [OPTIONS] -p PID
```

Het toewijzen van een proces of commando aan een processor gebeurt met behulp van een hexadecimaal bitmasker. Aangezien het toewijzen via een bitmasker niet erg intuïtief is, wordt `taskset` meestal gebruikt in combinatie met de optie `-c` (–cpu-list) om een numerieke toewijzing van processors mogelijk te maken (d.w.z. 0, 5, 7, 9-11).

### Pager

Wilt u uw overzicht gebruiken om de inhoud van bestanden met meerdere pagina’s bij te houden? Met een opdrachtregelprogramma uit de categorie pager kunt u selecteren welke secties in de terminal worden weergegeven en indien nodig in interactieve modus door het bestand bladeren.

**1. hoofd**

Het Linux-commando head wordt gebruikt om het eerste deel van een bestand weer te geven. De algemene syntaxis van het commando luidt:

```bash
head [OPTIONS] File
```

Gebruik optie `-n NUMBER_LINES` om te bepalen hoeveel regels er moeten worden uitgevoerd, beginnend bij het begin.

**2. minder**

Het opdrachtregelprogramma `less` maakt het mogelijk om de inhoud van een tekstbestand weer te geven in de terminal. De algemene syntaxis luidt:

```bash
less [OPTIONS] FILE
```

De uitvoer staat automatisch in interactieve modus. Hierdoor kunt u door het geselecteerde document bladeren of op trefwoord zoeken. Met de toets \[Q\] beëindigt u de interactieve leesmodus. Andere bedieningstoetsen en beschikbare opties vindt u in de handleiding van het programma.

**3. staart**

Terwijl `head` standaard de eerste 10 regels van een gekozen bestand weergeeft, geeft het Linux-commando tail de laatste 10 regels weer. Beide pagers worden volgens hetzelfde patroon gebruikt (zie `head`).

### Redactie

Onder Linux heb je geen grafisch tekstverwerkingsprogramma nodig om configuratiebestanden aan te passen, codefragmenten te bewerken of korte notities te maken. **Eenvoudige tekstverwerkers** kunnen zonder vertraging worden opgeroepen in de terminal. Hier presenteren we drie programma’s die je moet kennen.

**1. emacs**

*Emacs* is een platformonafhankelijke teksteditor die naar wens kan worden uitgebreid met een programmeerinterface. Emacs start standaard met een grafische gebruikersinterface, maar kan ook in de terminal worden geopend met de optie `--no-window-system`.

```bash
emacs --no-window-system
```

Emacs heeft een geïntegreerde tutorial die u kunt oproepen met de toetsencombinatie \[CTRL\] + \[H\], \[T\].

**2. nano**

Nano is een terminalgebaseerde teksteditor. Nano biedt minder functies dan vergelijkbare editors (bijvoorbeeld *Vim*), maar onderscheidt zich door een bijzonder gebruiksvriendelijke bediening. De algemene syntaxis van de programma-aanroep luidt:

```bash
nano [OPTIONS] FILE
```

Het programma opent het opgegeven bestand in een bewerkingsvenster in de terminal. Als u Nano zonder bestandsnamen oproept, kan een nieuw tekstbestand worden aangemaakt dat wordt opgeslagen in de momenteel geselecteerde map.

**3. vim**

Vim (afkorting van *Vi Improved*) is een verdere ontwikkeling van de teksteditor *Vi* die zich onderscheidt door talrijke uitbreidingen, zoals syntaxisaccentuering, een uitgebreid helpsysteem, native scripting, automatische codeaanvulling en visuele tekstselectie.

Het open-sourceprogramma biedt verschillende modi voor het bewerken van pure tekstbestanden en kan zowel in de terminal als als zelfstandige toepassing met een grafische gebruikersinterface (*GVim*) worden gebruikt. Een belangrijk toepassingsgebied van het programma is het bewerken van programmacode.

Als u Vim in de console start, wordt de bewerking via het toetsenbord uitgevoerd. Over het algemeen wordt het programma samen met een tekstbestand volgens het volgende patroon aangeroepen:

```bash
vim [OPTIONS] FILE
```

Vim biedt het programma `vimtutor` als uitgebreide introductie, dat ook vanaf de opdrachtregel wordt gestart. Ons basisartikel over de Linux-editor Vim biedt ook aanvullende informatie over de installatie en verschillende bedieningsmodi van het programma.

### Netwerkbeheer

**Netwerkbeheer** kan ook eenvoudig worden uitgevoerd vanaf de terminal in Linux. Of u nu de verbinding wilt testen, DNS-informatie wilt opvragen, de interface wilt configureren of bestanden wilt overzetten naar een andere computer in het netwerk, met de volgende programma’s volstaat één enkele opdracht om uw project in gang te zetten.

**1. arp**

Met het opdrachtregelprogramma `arp` kunt u de ARP-cache van uw besturingssysteem openen en bewerken. Gebruik `arp` zonder modificator om de inhoud van de ARP-tabel in de terminal weer te geven.

```bash
arp [OPTION]
```

Als alternatief kunt u de uitvoer beperken met opties of items aanmaken of verwijderen:

- `-a HOSTNAME` = Beperk uitvoer tot vermeldingen voor specifieke hostnamen (alternatief voor een IP-adres)
- `-s HOSTNAME MAC_ADDRESS` = Maak een ARP-vermelding met de opgegeven hostnaam en het MAC-adres
- `-d HOSTNAME` = APR-vermelding verwijderen

**2. iw**

Het opdrachtregelprogramma `iw` wordt gebruikt voor de configuratie van WLAN-interfaces en is opgezet als een huidig alternatief voor `iwconfig`. De aanroep is gebaseerd op een syntaxis die vergelijkbaar is met die van het `ip`:

```bash
iw [OPTIONS] OBJECT [COMMAND]
```

Mogelijke objecten zijn:

- dev NAME\_OF\_INTERFACE = Netwerkinterface
- phy NAME\_OF\_DEVICE = WLAN-apparaat (op naam)
- phy#INDEX\_VAN\_APPARAAT = WLAN-apparaat (op index)
- reg = Regelgevende instantie voor de configuratie van regionale en landinstellingen

Een overzicht van de mogelijke commando’s en opties is te vinden in de bijbehorende man-pagina.

**3. nslookup**

Net als `dig` is nslookup ook een naamresolutieservice. Het opdrachtregelprogramma is beschikbaar in twee modi: interactief en niet-interactief. Als u `nslookup` in niet-interactieve modus wilt gebruiken, roept u het programma op in combinatie met een hostnaam of een IP-adres.

```bash
nslookup [OPTIONS] [HOST/IP]
```

Om de interactieve modus te starten, voert u de opdracht `nslookup` in de terminal in zonder aanvullende informatie en voert u vervolgens hostnamen of IP-adressen in om de bijbehorende IP-adressen of hostnamen weer te geven.

Aangezien het programma **officieel verouderd** is, worden gebruikers aangemoedigd om in plaats daarvan `dig` te gebruiken.

**4. rsync**

Met het opdrachtregelprogramma `rsync` kunt u bestanden lokaal of via een netwerk synchroniseren. Hiervoor worden de grootte en de wijzigingstijd van de betreffende bestanden vergeleken. De syntaxis van de aanroep luidt:

```bash
rsync [OPTIONS] SOURCE(S) TARGET
```

Het commando rsync wordt meestal uitgevoerd met de optie `-a`, die ervoor zorgt dat alle submappen en symbolische links worden gekopieerd en alle gebruikersrechten van kracht worden.

**5. scp**

Met het Linux-commando scp (afkorting van *secure copy*) is er een ander programma voor veilige gegevensoverdracht in het netwerk direct via de terminal beschikbaar. `scp` kopieert gegevens van de ene computer naar de andere en maakt gebruik van het netwerkprotocol SSH. Het clientprogramma werkt op dezelfde manier als de bestandsoptie `cp`, maar wordt systeembreed gebruikt volgens de volgende syntaxis:

```bash
scp [OPTIONS] FILE [[user@]remote_host:]PATH
```

Bij het specificeren van het pad van de externe computer worden de gebruikersnaam en de betreffende hostnaam voor het pad geplaatst. Lokale bestanden worden expliciet aangeduid met behulp van relatieve of absolute paden.

Voorbeeld:

```bash
scp/home/max/images/image.jpg max@example.com:/home/max/archive
```

Met extra opties kunt u aanpassingen maken aan de overdrachtsmodus en de versleutelingsinstellingen.

**6. tty**

De opdrachtregelopdracht `tty` geeft de bestandsnamen weer van de terminal die zijn gedefinieerd als de standaardinvoer. De algemene syntaxis van de opdracht luidt:

```bash
tty [OPTIONS]
```

### Archiveren en comprimeren

Linux biedt verschillende technologieën waarmee bestanden kunnen worden verpakt en gecomprimeerd in archieven. Opgemerkt moet worden dat **niet elk archief een compressie bevat**. Daarom wordt `tar` – een programma voor het archiveren van bestanden – meestal gecombineerd met een compressieprogramma zoals `gzip`, `bzip2` of `xz`.

**1. gzip**

`gzip` is een programma waarmee u eenvoudig bestanden kunt comprimeren of decomprimeren via de opdrachtregel. De algemene syntaxis van de opdracht luidt:

```bash
gzip [OPTIONS] FILE(S)
```

Houd er rekening mee dat `gzip` standaard het originele bestand verwijdert als onderdeel van het compressieproces. Voorkom dit door de optie `-k` te gebruiken. Het programma kan indien nodig voor meerdere bestanden tegelijk worden gebruikt. Elk uitvoerbestand wordt geconverteerd naar een afzonderlijk `gz`. Als u meerdere bestanden in één gecomprimeerd archief wilt opslaan, gebruik dan `gzip` in combinatie met het archiveringsprogramma `tar`.

Als u een gz-bestand wilt decomprimeren, gebruikt u het commando `gzip` met de optie `-d`.

**2. bzip2**

Een populair alternatief voor `gzip` is het opdrachtregelprogramma `bzip2`. Dit gebruikt dezelfde syntaxis als `gzip`, maar is gebaseerd op een compressieproces in drie fasen, waardoor een aanzienlijk hogere compressieverhouding mogelijk is. Bestanden die met bzip2 zijn gecomprimeerd, hebben de bestandsextensie `.bz2`. Gebruik `bzip` volgens het volgende patroon om bestanden te comprimeren:

```bash
bzip2 [OPTIONS] FILE(S)
```

`bzip2` kan ook worden toegepast op `tar` archieven. De decompressie is analoog aan `gzip` en werkt met behulp van optie `-d`.

**3. xz**

Het opdrachtregelprogramma `xz` converteert bestanden in het gelijknamige gegevenscompressieformaat `xz`. De programma-aanroep gebruikt hetzelfde patroon als `gzip` en `bzip2`.

```bash
xz [OPTIONS] FILE(S)
```

Bestanden die met `xz` zijn gecomprimeerd, hebben de bestandsextensie `.xz`. Het decomprimeren werkt net als bij `gzip` en `bzip` met de optie `-d`. Het commando `unxz` kan ook worden gebruikt.

Net als gz- en bz2-bestanden zijn xz-bestanden ook geen archiefbestanden. Als u meerdere bestanden in hetzelfde gecomprimeerde xz-bestand wilt schrijven, moet u ook het archiveringsprogramma `tar` gebruiken met dit compressieprogramma.

**4. cpio**

Met het archiveringsprogramma `cpio` (afkorting van *copy in, copy out*) kunt u gegevens naar een archiefbestand (.cpio) schrijven en daaruit extraheren.

### Partitiebeheer

Als u in Linux toegang wilt krijgen tot een bestandssysteem op een andere partitie, moet u deze eerst integreren in de directorystructuur van uw besturingssysteem. Dit wordt het ‘mounten’ van een partitie genoemd. Indien nodig kan dit via de grafische gebruikersinterface gebeuren. Commandoregelprogramma’s zoals `lsblk`, `blkid` en `mount` bieden ook de mogelijkheid om informatie op te vragen over aangesloten blokopslagapparaten en deze indien nodig te mounten of unmounten.

**1. lsblk**

Gebruik het commando `lsblk` (afkorting van *list block devices*) om alle aangesloten blokopslagapparaten en partities weer te geven als een boomstructuur. Deze hoeven niet noodzakelijkerwijs betrokken te zijn. De aanroep is gebaseerd op de volgende syntaxis:

```bash
lsblk [OPTIONS]
```

Indien nodig kunnen de uitvoer en een lijst met gewenste attributen afzonderlijk worden gewijzigd met behulp van de optie `-o` (*–output*) om aanvullende informatie op te halen, zoals het identificatienummer (UUID), het bestandssysteem (FSTYPE) of de status (STATE).

In de standaardinstellingen worden lege opslagapparaten overgeslagen. Als u deze ook in het overzicht wilt opnemen, gebruik dan `lsblk` in combinatie met de optie `-a` (*–all*). Als u alleen informatie over een bepaald apparaat wilt opvragen, gebruik dan `lsblk` volgens het volgende patroon:

```bash
lsblk [OPTIONS] DEVICE
```

**2. blkid**

Net als `lsblk` geeft ook `blkid` informatie weer over aangesloten blokopslagapparaten. Gebruik `blkid` volgens het volgende patroon om het identificatienummer (`UUID`) en het bestandssysteemtype (`TYPE`) van alle aangesloten blokopslagapparaten te verkrijgen.

```bash
blkid [OPTIONS]
```

Voor tabeluitvoer gebruikt u de optie `-o` in combinatie met de waarde `list`. U kunt `blkid` ook beperken tot een gekozen apparaat:

```bash
blkid [OPTIONS] DEVICE
```

### Diversen

De volgende lijst bevat aanvullende basiscommando’s voor Linux die niet tot een van de voorgaande categorieën behoren.

**1. alias**

Interactie met de shell gebeurt meestal via commando’s die kunnen worden gebruikt om **commandoregelprogramma’s** met dezelfde naam op te roepen. U gebruikt een programma-oproep voor elke actie die u via de terminal wilt uitvoeren. Met het [Linux-commando `alias`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-alias-commando/) kunt u korte namen voor programma-oproepen definiëren. Gebruik `alias` volgens het volgende patroon:

```bash
alias NICKNAME= 'COMMAND'
```

Vervang de tijdelijke aanduiding COMMAND door een willekeurige opdrachtregelopdracht, inclusief opties. Hierdoor wordt de ingevoegde tekenreeks gekoppeld aan de tijdelijke aanduiding NICKNAME.

**2. bij**

Roep het opdrachtregelprogramma `at` op volgens het volgende patroon om een tijdgestuurde opdracht uit te voeren.

```bash
at TIME
```

Voer vervolgens de opdracht in en sluit de interactieve modus met \[CTRL\] + \[D\].

**3. cal**

Gebruik `cal` volgens het volgende patroon om een kalender weer te geven in de terminal.

```bash
cal [OPTIONS] [[MONTH] Year]
```

**4. pr**

Gebruik het opdrachtregelprogramma `pr` om tekstbestanden voor te bereiden voor afdrukken. De algemene syntaxis van de opdracht luidt:

```bash
pr [OPTIONS] File
```

In de standaardinstellingen genereert `pr` een paginakoptekst met de bestandsnaam, de huidige datum en het paginanummer.

**5. script**

Met het opdrachtregelprogramma `script` kunt u een terminalsessie opnemen in het bestand `typescript`. Als er al een opname van een eerdere sessie in `typescript` staat, wordt deze overschreven. De opname start automatisch met de programma-aanroep:

```bash
script
```

Gebruik de toetsencombinatie \[CTRL\] + \[D\] om de opname te beëindigen. Als u de opname in een ander bestand wilt opslaan dan in `typescript`, roep dan `script` op in combinatie met een bestandsnaam of pad.

**6. seq**

Gebruik het commando `seq` om een reeks getallen uit te voeren in de standaarduitvoer. Definieer een startwaarde, een eindwaarde en een increment (optioneel).

```bash
seq [OPTIONS] STARTVALUE INCREMENT ENDVALUE
```

**7. tasksel**

Het opdrachtregelprogramma `tasksel` dient als installatiehulp voor standaardtoepassingen (mailserver, DNS-server, OpenSSH-server, LAMP-server, enz.). Gebruik het hulpprogramma om alle pakketten en programma’s die nodig zijn voor een taak automatisch in de juiste volgorde te installeren. Roep `tasksel` aan met de optie `--list-tasks` om een lijst met alle beschikbare standaardtoepassingen weer te geven.

```bash
tasksel --list-tasks
```

Als u meer informatie wilt over een standaardtoepassing in de lijst, gebruikt u `tasksel` met de optie `--task-desc` en de bijbehorende taak. Als u alle pakketten wilt weergeven die bij de taak ‘mail-server’ horen, gebruikt u `tasksel` in combinatie met de optie `--task-packages`.

Om alle pakketten van een standaardtoepassing te installeren, gebruikt u het subcommando `install`. Hiervoor zijn root-rechten vereist.

**8. tee**

Het Linux-commando tee wordt gebruikt om de uitvoer van een programma te verdubbelen. De ene uitvoer wordt doorgegeven aan de standaarduitvoer en de andere wordt weggeschreven naar het bestand dat is opgegeven met het commando `tee`.

```bash
tee [OPTIONS] FILE
```

`tee` wordt meestal gebruikt in combinatie met de omleidingsoperator Pipe (`|`).

```bash
ls | tee example.txt
```

**9. tijd**

Gebruik het commando `time` volgens het volgende patroon om de looptijd te identificeren van programma’s die u via de terminal hebt gestart.

```bash
time [OPTIONS] Command [ARGUMENTS]
```

**10. tr**

Gebruik `tr` om een gewenste tekenset te verwijderen of te vervangen door een andere. Hiervoor leest `tr` de gegevensstroom van de standaardinvoer (bijvoorbeeld een bestand) en schrijft deze naar de standaarduitvoer volgens de gewenste wijziging. Als een tekenset door een andere moet worden vervangen, wordt `tr` met twee argumenten gebruikt.

```bash
tr OPTION CHARACTERSET1 CHARACTERSET2
```

Het tweede argument (CHARACTERSET2) vervangt het eerste (CHARACTERSET1). Als u een tekenreeks wilt verwijderen, gebruikt u `tr` met de optie `-d` en voert u de te verwijderen set in als argument.

```bash
tr -d CHARACTERSET
```

Het opdrachtregelprogramma wordt meestal gebruikt in combinatie met omleidingsoperatoren (&lt; en &gt;) om wijzigingen aan bestanden aan te brengen.

```bash
tr 'a-z' 'A-Z' < example1.txt > example2.txt
```

`tr` leest de inhoud van het bestand `example1.txt`, vervangt de kleine letters a tot en met z door hoofdletters en schrijft de uitvoer naar het bestand `example2.txt`.

**11. muur**

Met het opdrachtregelprogramma `wall` kunt u een bericht sturen naar alle gebruikers die op een systeem zijn geregistreerd. Om een bericht te verzenden, start u het programma met de volgende opdracht:

```bash
wall
```

Bevestig de programma-oproep met \[Enter\] en voer uw bericht in. Bevestig vervolgens opnieuw met \[Enter\] en verzend met de toetscombinatie \[CTRL\] + \[D\]. Alle gebruikers die op het systeem zijn geregistreerd, ontvangen uw bericht als een uitzending op de terminal. Het is belangrijk om te weten dat u, om berichten te kunnen ontvangen, andere gebruikers schrijftoegang tot uw terminal moet geven. Gebruik hiervoor het commando `mesg`:

Als u bestandsinhoud naar alle geregistreerde gebruikers wilt verzenden, gebruik dan `wall` in combinatie met een invoeromleiding en de betreffende bestandsnaam:

```bash
wall < FILENAME
```

**12. kijken**

Met het opdrachtregelprogramma `watch` kunt u een opdracht instellen die met regelmatige tussenpozen wordt uitgevoerd. De programma-aanroep is gebaseerd op de volgende syntaxis:

```bash
watch [OPTIONS] COMMAND
```

Het tijdsinterval waarin het in `watch` gegeven commando wordt uitgevoerd, wordt gedefinieerd met de optie `-n SECONDS`. Sluit `watch` af met de toetscombinatie \[CTRL\] + \[C\].

**13. wc**

[Het Linux-commando `wc`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-wc-commando/) (afkorting van *word count*) geeft op verzoek het aantal regels, woorden, letters, tekens en/of bytes van een tekstbestand weer. De algemene syntaxis van het commando luidt:

```bash
wc [OPTIONS] FILE
```

Als `wc` zonder opties wordt aangeroepen, komt de uitvoer overeen met het patroon `LINES WORDS CHARACTERS FILE`. Voor een gefilterde uitvoer ondersteunt het opdrachtregelprogramma de volgende opties: `-l` (regels), `-c` (bytes), `-m` (tekens), `-L` (lengte van de langste regel) en `-w` (woorden).

**14. xargs**

[Met het Linux-commando `xargs`](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-xargs-commando/) kunt u de uitvoer van een vorig commando als argument naar een nieuw commando overbrengen. Over het algemeen wordt dit gebruikt met de Pipe (`|`) als omleidingsoperator. Gebruik `xargs` volgens de volgende syntaxis:

```bash
COMMAND1 | xargs [OPTIONS] COMMAND2
```

`xargs` kan bijvoorbeeld worden gebruikt in combinatie met het commando `find`. In het volgende voorbeeld identificeert `find` alle bestanden in de huidige map die voldoen aan de zoekterm `*.tmp` en voert hun namen uit naar de standaarduitvoer. Daar worden de bestandsnamen van `xargs` geaccepteerd en doorgegeven als argumenten aan het commando `rm`.

```bash
find . -name '*.tmp' | xargs rm
```

Het hier gepresenteerde overzicht pretendeert niet volledig te zijn, maar bevat basiscommando’s voor Linux met geselecteerde toepassingsvoorbeelden voor dagelijks werk met Unix-achtige besturingssystemen. Een uitgebreide beschrijving van de hier gepresenteerde commandoregelprogramma’s, evenals alle andere commando’s, is te vinden in de handleiding van uw besturingssysteem. Een online versie van deze help- en documentatiepagina’s is beschikbaar via het [Linux man-pages-project](https://www.kernel.org/doc/man-pages/ "Linux man-pages project by Michael Kerrisk") van Michael Kerrisk.


This is a markdown version of: [https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-commandos-een-overzicht-van-terminalcommandos/](https://www.ionos.com/nl-be/digitalguide/server/configuratie/linux-commandos-een-overzicht-van-terminalcommandos/) for AI/LLM consumption.