Linux commando: tree

Voer ls uit in een diep project en je krijgt steeds maar een platte laag tegelijk. Je ziet de mappen, dan stap je in de een, dan de ander, en zo bouw je de vorm van het geheel in je hoofd weer op. tree doet dat werk voor je. Het loopt de map naar beneden door en tekent de hele structuur als een enkel ingesprongen diagram, met nette lijnen die precies laten zien wat in wat zit. Een commando, en de indeling van een heel project staat op je scherm.

2. Waar komt de naam vandaan?

De naam is het plaatje. Teken een map met zijn submappen die uitwaaieren en zijn bestanden die aan de uiteinden hangen, en je hebt een boom getekend (in het Engels een "tree"): een enkele wortel bovenaan, takken die zich in meer takken splitsen, en bladeren aan de tippen. Informatici noemen precies deze structuur al sinds de vroegste dagen van het vak een "boom", omdat het overeenkomt met de botanische vorm op zijn kop.

Een bestandssysteem is een boom in deze precieze zin. Er is een wortel, geschreven als /, elke map is een tak die meer takken kan bevatten, en elk gewoon bestand is een blad met niets eronder. Het commando verzint de metafoor niet; het tekent gewoon de boom die er altijd al was. Als je tree uitvoert, kijk je naar de letterlijke datastructuur waarop je bestandssysteem is gebouwd.

Dus de naam is zo direct als een naam maar kan zijn. De tool toont je de boom, en het heet tree. Er is geen afkorting en geen verborgen grap, alleen het meest voor de hand liggende woord voor het ding op het scherm.

4. Eenvoudige toepassingen

4.1 Het simpelst mogelijke gebruik

Voer tree uit zonder argumenten en het tekent de huidige map en alles eronder:

$ tree
.
├── docs
│   └── guide.md
└── src
    └── main.py

2 directories, 2 files

De enkele punt . bovenaan is de startmap, dezelfde . die overal elders in de shell "hier" betekent. Om een andere map te tekenen, geef je die als argument mee:

$ tree /etc/nginx
/etc/nginx
├── nginx.conf
└── conf.d
    └── default.conf

4.2 Beperk hoe diep het gaat

Bij een groot project kan de volledige boom pagina's lang scrollen. De -L-vlag (kort voor level, niveau) stopt het afdalen na een vast aantal niveaus, en dat is de nuttigste vlag die tree heeft:

$ tree -L 1        # only the top level, like a quick ls
.
├── docs
├── README.md
├── src
└── tests

3 directories, 1 file

Grijp naar -L wanneer je iets onbekends verkent. Begin met -L 1 of -L 2 om de grote vorm te zien, en daal dan af in de ene tak die je interesseert.

4.3 Toon verborgen bestanden

Net als ls verbergt tree standaard bestanden waarvan de naam met een punt begint. De -a-vlag (kort voor all, alles) laat ze zien:

$ tree -a -L 1
.
├── .env
├── .gitignore
├── docs
├── README.md
└── src

Zo zie je configuratiebestanden zoals .env en .gitignore, en ook de .git-map, die meestal groot is en zelden iets dat je wilt uitklappen. Sectie 5 laat zien hoe je die weer verbergt terwijl je de rest houdt.

4.4 Alleen mappen

Als je alleen om het geraamte geeft en niet om de losse bestanden, print de -d-vlag (kort voor directories, mappen) alleen de mappen:

$ tree -d
.
├── docs
├── src
└── tests

3 directories

Dit geeft je de kaart van een project zonder de rommel van elk bronbestand, precies wat je wilt als je je weg leert kennen in een nieuwe codebase.

4.5 Zet de samenvattingsregel uit

Elke boom eindigt met de rapportregel, zoals 3 directories, 5 files. Op het scherm is die handig, maar hij zit in de weg als je een boom in een document opslaat of aan een ander programma doorgeeft. De --noreport-vlag verwijdert hem en laat alleen het diagram over:

$ tree -L 1 --noreport
.
├── docs
├── README.md
├── src
└── tests

Gebruik het wanneer de boom in een README, een e-mail of een script terechtkomt, waar een afsluitende tellregel alleen maar ruis zou zijn.

6. Gevorderde toepassingen

6.1 Volledige paden voor pipes en scripts

De tekenlijnen zijn heerlijk voor mensenogen maar nutteloos voor een ander programma. De -f-vlag (kort voor full path, volledig pad) print het complete pad van elk item, en -i (kort voor indentation off, inspringen uit) verwijdert de boomlijnen en laat een platte lijst over die je elders kunt invoeren:

$ tree -if
.
./docs
./docs/guide.md
./src
./src/main.py
./src/utils.py

Gecombineerd met -P wordt dit een leesbaar, gestructureerd alternatief voor een kaal find voor snelle taken. Voor echt scripten zijn de gestructureerde uitvoeren hieronder echter veiliger.

6.2 Machineleesbare uitvoer: JSON en XML

Als een ander programma de boom moet verwerken, vraag hem dan in een echt gegevensformaat. De -J-vlag (kort voor JSON) print de structuur als JSON, en -X print XML:

$ tree -J docs
[
  {"type":"directory","name":"docs","contents":[
    {"type":"file","name":"guide.md"}
  ]}
,
  {"type":"report","directories":1,"files":1}
]

De JSON-uitvoer nest contents-arrays precies zoals de visuele boom zijn takken nest, zodat een script de structuur direct kan doorlopen. Pipe het naar een tool als jq om het te filteren of te herschikken. Dit is de juiste manier om een programma een mappenindeling te laten lezen; het parsen van de getekende lijnen met de kadertekens is fragiel en kun je beter vermijden.

6.3 Publiceer een boom als webpagina

De -H-vlag (kort voor HTML) schrijft een complete HTML-pagina, waarbij elk item een klikbare link wordt ten opzichte van het basisadres dat je opgeeft:

$ tree -H '.' -o index.html      # write a browsable listing to a file

De -o-vlag (kort voor output, uitvoer) stuurt het resultaat naar een bestand in plaats van naar het scherm. Richt een browser op dat bestand en je krijgt een doorbladerbare index van de map, dezelfde functie die tree ooit een snelle manier maakte om een downloadmap te publiceren.

6.4 Extra details: rechten, eigenaren en typemarkeringen

tree kan elk item annoteren met dezelfde metadata die ls -l toont. De -p-vlag (kort voor permissions, rechten) print de modusreeks, -u (kort voor user, gebruiker) print de eigenaar, -g (kort voor group, groep) print de groep, en -F (kort voor file type, bestandstype, net als ls -F) voegt een markering toe zoals / voor een map of * voor een uitvoerbaar bestand:

$ tree -pF docs
docs
└── [-rw-rw-r--]  guide.md

Met deze vlaggen wordt tree een recursieve ls -l die de vorm behoudt, wat handig is als je rechten over een hele deelboom tegelijk controleert.

6.5 Als de lijnen op rommel lijken

De verbindingslijnen worden getekend met speciale kadertekens. Als je terminal, lettertype of bestandscodering ze niet kan tonen, krijg je kapotte symbolen zoals M-bM-^T in plaats van nette hoeken. De optie --charset vertelt tree met welke tekenset hij moet tekenen, en het gewone ascii valt terug op gewone toetsenbordtekens die overal weergegeven worden:

$ tree --charset=ascii docs
docs
`-- guide.md

Hier worden de hoeken `-- en de takken |--. Het is minder mooi maar volkomen draagbaar, precies wat je wilt als je een boom in een e-mail, een ticket of een document plakt dat elke codering moet overleven.

6.6 Symbolische links volgen

Standaard toont tree een symbolische link maar stapt er niet doorheen. Het print de link en waar hij naar wijst, met een pijl, en stopt daar:

$ tree
.
├── link_to_real -> real
└── real
    └── inside
        └── file.txt

De -l-vlag (kort voor follow links, links volgen) vertelt tree om een gelinkte map als een echte te behandelen en erin af te dalen, zodat de inhoud ervan ook onder de link verschijnt:

$ tree -l
.
├── link_to_real -> real
│   └── inside
│       └── file.txt
└── real
    └── inside
        └── file.txt

Links volgen is krachtig maar riskant, want een link kan terugwijzen naar een map die hem bevat, wat een eindeloze lus veroorzaakt. tree beschermt hiertegen: het houdt bij welke mappen het al heeft bezocht, en als een link het ergens heen zou sturen waar het al is geweest, markeert het het item en weigert het om verder af te dalen in plaats van eindeloos rond te draaien:

$ tree -l
.
└── loopback -> ..  [recursive, not followed]

De les is om -l bewust te gebruiken, alleen als je gelinkte mappen echt uitgeklapt wilt hebben, en om de melding [recursive, not followed] te vertrouwen als teken dat het vangnet zijn werk heeft gedaan.

8. Beste praktijken

• Begin ondiep met -L. Voer bij elke onbekende map eerst tree -L 2 uit om de vorm te zien, en daal dan af in de ene tak die je interesseert.
• Verberg de ruis. Voeg -I 'node_modules|.git|__pycache__' toe zodat de boom van een echt project leesbaar blijft in plaats van te verdrinken in afhankelijkheden.
• Gebruik --gitignore in een repository. Het toont de bestanden die echt bij het project horen zonder dat je elke rommelmap met de hand hoeft op te sommen.
• Zet je patronen tussen aanhalingstekens. Schrijf tree -P '*.log', niet tree -P *.log, anders breidt de shell de glob uit voordat tree hem ziet.
• Gebruik --charset=ascii als je deelt. Voor een e-mail, ticket of README overleven platte ASCII-lijnen elke codering; de mooie kadertekens misschien niet.
• Grijp naar -J voor scripts. Parse nooit de getekende lijnen in een programma; vraag om JSON en laat een echte parser het lezen.
• Onthoud dat het misschien niet geinstalleerd is. tree is geen onderdeel van coreutils, dus een verse server of container heeft vaak eerst apt install tree nodig.

Als je alle details nodig hebt, is de documentatie een commando ver weg:

$ man tree        # the full manual with every option
$ tree --help     # a quick summary of every flag

10. Samenvatting

Het commando tree tekent een map en alles eronder als een enkel ingesprongen diagram, en verandert de onzichtbare vorm van een project in een plaatje dat je in een oogopslag kunt lezen.

• tree daalt recursief af in elke submap en verbindt items met lijnen: │ zet een tak voort, ├── markeert een item met meer buren, en └── markeert het laatste.
• Het is een apart pakket, geen onderdeel van coreutils, dus installeer het met apt, dnf of pacman als het ontbreekt.
• Bepaal de weergave met -L (diepte), -a (verborgen bestanden), -d (alleen mappen) en --prune (lege takken weglaten).
• Filter met -P (treffers houden), -I (treffers verbergen) en --gitignore (de negeerregels van het project respecteren).
• Voeg details toe met -h en --du voor groottes, -p -u -g voor rechten en eigenaren, en -F voor typemarkeringen.
• Voor machines gebruik je -J voor JSON of -X voor XML; om te delen gebruik je --charset=ascii zodat de lijnen overal weergegeven worden.

Dit is de snelle naslag die het bewaren waard is:

tree                       draw the current directory and everything below
tree -L 2                  stop after two levels deep
tree -a                    include hidden dotfiles
tree -d                    directories only, no files
tree -P '*.py' --prune     keep only .py files, drop empty folders
tree -I 'node_modules|.git'  hide noisy folders
tree --gitignore           respect the project's .gitignore
tree -h --du               human-readable sizes with directory totals
tree -pug                  show permissions, owner, and group
tree -J                    output as JSON for scripts
tree --charset=ascii       portable lines for email and tickets
man tree                   the full manual

Zodra tree in je gereedschapskist zit, houdt een vreemde map op een doolhof te zijn die je een cd tegelijk verkent en wordt het een kaart die je in een oogopslag overziet. Als je servers zijn uitgegroeid tot een wirwar die niemand nog echt voor zich kan zien, is dat helder uittekenen, en het netjes houden, precies het soort werk waarmee ik help.