*/ este un model care se potrivește tuturor subdirectoarelor din directorul curent (* ar a se potrivi toate fișierele și subdirectoarele; a / se limitează la directoare). În mod similar, pentru a lista toate subdirectoarele în /home/alice/Documente, utilizați e -d /home/alice/Documente/*/`

Patru modalități de a obține acest lucru făcut, fiecare cu un alt format de ieșire

1. Folosind "echo"

Exemplu: echo /,echo /*/`
Aici este ceea ce am primit:

cs/ draft/ files/ hacks/ masters/ static/  
cs/code/ files/images/ static/images/ static/stylesheets/  

2. Folosind " ls " numai

Exemplu: ls -d */`
Aici este exact ceea ce am primit:

cs/     files/      masters/  
draft/  hacks/      static/  

Sau ca listă (cu informații de detaliu): ls-dl */

3. Folosind e și grep

Exemplu: ls -l | grep "^d"` Aici este ceea ce am primit:

drwxr-xr-x  24 h  staff     816 Jun  8 10:55 cs  
drwxr-xr-x   6 h  staff     204 Jun  8 10:55 draft  
drwxr-xr-x   9 h  staff     306 Jun  8 10:55 files  
drwxr-xr-x   2 h  staff      68 Jun  9 13:19 hacks  
drwxr-xr-x   6 h  staff     204 Jun  8 10:55 masters  
drwxr-xr-x   4 h  staff     136 Jun  8 10:55 static  

4. Script Bash (Nu este recomandat pentru numele fișierului care conține spații)

Exemplu: for i in $(e -d */); do echo ${i%%/}; făcut`
Aici este ceea ce am primit:

cs  
draft  
files  
hacks  
masters  
static

Dacă vă place să aveți '/' ca finalul caracter, comanda va fi: pentru că nu în $(e -d */); do echo ${i}; face

cs/  
draft/  
files/  
hacks/  
masters/  
static/

Eu folosesc:

ls -d */ | cut -f1 -d'/'

Acest lucru creează o singură coloană, cu nici un trailing slash - util în scripturi.

Cei doi cenți ai mei.

Pentru toate folderele fără subfoldere:

find /home/alice/Documents -maxdepth 1 -type d

Pentru toate folderele cu subfoldere:

find /home/alice/Documents -type d

4 (mai mult) de Încredere Opțiuni.

O necotate asterisc " " va fi interpretat ca un model (glob) de coajă.
shell-ul va folosi în pathname expansiune.
Se va genera apoi o listă de nume de fișiere care se potrivesc cu pattern.
Un simplu asterisc se va potrivi toate numele de fișiere în PWD (prezent directorul de lucru).
Un model mai complex ca `/se va potrivi toate numele de fișiere care se termina in/`.
Astfel, toate directoarele. De aceea comanda:

1.- echo.

echo */
echo ./*/              ### avoid misinterpreting filenames like "-e dir"

va fi extins (cu coajă) la "echo", toate directoarele în PWD.

Pentru a testa acest lucru: de a Crea un director (mkdir) numit ca test-dir, și " cd " in ea:

mkdir test-dir; cd test-dir

Crea unele directoare:

mkdir {cs,files,masters,draft,static}   # safe directories.
mkdir {*,-,--,-v\ var,-h,-n,dir\ with\ spaces}  # some a bit less secure.
touch -- 'file with spaces' '-a' '-l' 'filename'    # and some files:

Comanda echo ./*/ va rămâne fiabile chiar și cu ciudate nume de fișiere:

./--/ ./-/ ./*/ ./cs/ ./dir with spaces/ ./draft/ ./files/ ./-h/
./masters/ ./-n/ ./static/ ./-v var/

Dar spații în numele de fișiere face lectura un pic confuz.

Dacă în loc de "echo", vom folosi "ls", shell-ul este tot ce se extinde lista de nume de fișiere. Shell-ul este un motiv pentru a obține o listă de directoare în PWD. La -d opțiunea de a " ls " face o listă prezent director de intrare în loc de conținutul fiecărui director (cum sunt prezentate în mod implicit).

ls -d */

Cu toate acestea, această comandă este (oarecum) mai puțin fiabile. Acesta va eșua, cu nume ciudat fișierele enumerate mai sus. Se va îneca cu mai multe nume. Aveți nevoie pentru a șterge unul câte unul până îi găsești pe cei cu probleme.

2.- e

GNU " ls " va accepta "sfârșitul opțiuni" (--) cheie.

ls -d ./*/                     ### more reliable BSD ls
ls -d -- */                    ### more reliable GNU ls

3.-printf

Pentru a lista fiecare director în linie proprie (într-o singură coloană, similar cu ls -1), utilizați:

$ printf "%s\n" */        ### Correct even with "-", spaces or newlines.

Și, chiar mai bine, am putea elimina oscilant /:

$ set -- */; printf "%s\n" "${@%/}"        ### Correct with spaces and newlines.

O încercare ca aceasta:

$ for i in $(ls -d */); do echo ${i%%/}; done

Va reuși pe:

• unele nume (ls-d */) așa cum am arătat deja mai sus.
• vor fi afectate de valoare de "DACĂ"`.
• se va împărți numele în spații și file (cu default "DACĂ"`).
• fiecare linie nouă în numele va începe un nou comanda echo.

4.- Funcția

În cele din urmă, folosind lista argument în interiorul unei funcții nu va afecta argumentele lista de prezenta de funcționare shell. Pur și simplu:

$ listdirs(){ set -- */; printf "%s\n" "${@%/}"; }
$ listdirs

prezintă această listă:

--
-
*
cs
dir with spaces
draft
files
-h
masters
-n
static
-v var

Aceste opțiuni sunt în siguranță cu mai multe tipuri de ciudat nume de fișiere.

La "copac" comandă este, de asemenea, destul de util aici. În mod implicit, acesta va afișa toate fișierele și directoarele de la un complet de adâncime, cu unele caractere ascii arată arborele de directoare.

$ tree
.
├── config.dat
├── data
│   ├── data1.bin
│   ├── data2.inf
│   └── sql
|   │   └── data3.sql
├── images
│   ├── background.jpg
│   ├── icon.gif
│   └── logo.jpg
├── program.exe
└── readme.txt

Dar dacă am vrut pentru a obține doar directoare, fără ascii copac, și cu calea completă de la directorul curent, ai putea face:

$ tree -dfi
.
./data
./data/sql
./images

Argumentele fiind:

-d     List directories only.
-f     Prints the full path prefix for each file.
-i     Makes tree not print the indentation lines, useful when used in conjunction with the -f option.

Și apoi, dacă doriți calea absolută, ai putea începe prin a preciza calea completă a directorului curent:

$ tree -dfi "$(pwd)"
/home/alice/Documents
/home/alice/Documents/data
/home/alice/Documents/data/sql
/home/alice/Documents/images

Și pentru a limita numărul de subdirectoare, puteți seta nivelul maxim de subdirectoare cu-N nivel`, de exemplu:

$ tree -dfi -L 1 "$(pwd)"
/home/alice/Documents
/home/alice/Documents/data
/home/alice/Documents/images

Mai multe argumente pot fi văzute cu om copac

În cazul în care te're vă întrebați la ce ieșire din 'e -d /' vă oferă două* trailing slash-uri, cum ar fi:

[prompt]$ ls -d */    
app//  cgi-bin//  lib//        pub//

l's, probabil, pentru că undeva, shell sau sesiune de fișiere de configurare alias ls comanda la o versiune ls, care include pavilion F. Steagul adaugă un caracter la fiecare nume de ieșire (ca's nu este un simplu fișier), indicând un fel de lucru este. Deci un slash este de potrivire de model '*/', și alte slash este anexată de tip indicator.

Pentru a scapa de aceasta problema, ai putea, bineînțeles, să definească un alt alias pentru ls. Cu toate acestea, temporar nu invoca numele, poti adauga comanda cu backslash:

\ls-d */

Eu trebuie doar să adăugați această meu .bashrc file (ai putea, de asemenea, doar tastați în linia de comandă dacă aveți nevoie doar de/vreau pentru o sesiune)

alias lsd='ls -ld */'

apoi lsd va produce rezultatul dorit.

Real " ls " soluție, inclusiv legături simbolice la directoare

Multe răspunsuri aici don't folosi de fapt, " ls " (sau doar l utilizați în banal sentiment de ls-d, în timp ce utilizați metacaractere pentru real subdirector de potrivire. Un adevărat " ls "soluția este utilă, deoarece permite utilizarea de" ls " opțiuni pentru ordinea de sortare, etc.

Exclusiv legături simbolice

O soluție folosind " ls " a fost dat, dar nu ceva diferit de alte soluții în care se exclude legături simbolice la directoarele:

ls -l | grep '^d'

(eventual conducte prin sed sau awk pentru a izola nume de fișiere)

Inclusiv legături simbolice

În (probabil mai frecvente) caz că legături simbolice la directoare ar trebui să fie incluse, putem folosi -p opțiune de "ls", care face adăugați o bară de caractere la nume de directoare (inclusiv symlinked altele):

ls -1p | grep '/$'

sau, a scăpa de trailing slash-uri:

ls -1p | grep '/$' | sed 's/\/$//'

Putem adăuga opțiuni pentru a " ls " după cum este necesar (dacă o lungă perioadă de listare este folosit, -1, nu mai este necesară).

nota: dacă am vrea ** trailing slash-uri, dar nu't vreau să le evidențiat prin grep, putem hackishly elimina evidențierea de a face efectiv potrivite porțiunea de linie goală:

ls -1p | grep -P '(?=/$)'

Dacă ascuns directorul nu este necesar pentru a fi enumerate, ofer:

ls -l | grep "^d" | awk -F" " '{print $9}'  

Și dacă directoare ascunse este necesar pentru a fi enumerate, utilizați:

ls -Al | grep "^d" | awk -F" " '{print $9}'

SAU

find -maxdepth 1 -type d | awk -F"./" '{print $2}'

pentru a afișa folderul liste fără /

ls -d */|sed 's|[/]||g'

Pentru listare numai directoare:

ls -l | grep ^d

pentru listare numai fișiere:

ls -l | grep -v ^d 

sau, de asemenea, puteți face ca: ls-ld */

Aici este ceea ce eu sunt, folosind

e -d1 /Director/Cale/*;`

Testa dacă elementul este un director cu test -d:

for i in $(ls); do test -d $i && echo $i ; done

Cel mai scurt comandă vreodată (de fapt, un hack) pentru listarea doar directoare. Tip în cale absolută sau relativă calea de director de interes. Tip cd și a lovit fila. Doar directoarele sunt afișate.

$ cd 

Mai scurt, într-adevăr.

-O linie pentru a lista de directoare doar de "aici".

Cu numărul de dosar.

for i in `ls -d */`; do g=`find ./$i -type f -print| wc -l`; echo "Directory $i contains $g files."; done

*/ este un nume de fișier de potrivire model care se potrivește directoarele din directorul curent.

Pentru a lista doar directoare, îmi place această funcție:

# long list only directories
llod () { 
  ls -l --color=always "$@" | grep --color=never '^d'
}

Pune-l în .bashrc.

Exemple de utilizare:

llod       # long listing of all directories in current directory
llod -tr   # same but in chronological order oldest first
llod -d a* # limit to directories beginning with letter 'a'
llod -d .* # limit to hidden directories

NOTĂ: se va rupe dacă utilizați -i opțiune. Aici este o soluție pentru asta:

# long list only directories
llod () { 
  ls -l --color=always "$@" | egrep --color=never '^d|^[[:digit:]]+ d'
}

FYI, dacă doriți să imprimați toate fișierele în multi-line, puteți face o ls -1 care va imprima fiecare fișier într-o linie separată. file1 file2 file3

Folosind Perl:

ls | perl -nle 'print if -d;'

Încercați această unul. Acesta funcționează pentru toate distributii linux. ls-l | grep drw