ChatGPT解决这个技术问题 Extra ChatGPT

Listing only directories using ls in Bash?

This command lists directories in the current path: ls -d */

What exactly does the pattern */ do?

And how can we give the absolute path in the above command (e.g. ls -d /home/alice/Documents) for listing only directories in that path?


G
Gordon Davisson

*/ is a pattern that matches all of the subdirectories in the current directory (* would match all files and subdirectories; the / restricts it to directories). Similarly, to list all subdirectories under /home/alice/Documents, use ls -d /home/alice/Documents/*/


Note that */ won't match any hidden folders. To include them, either specify them explicitly like ls -d .*/ */, or set the dotglob option in Bash.
@GordonDavisson The message of failure could be avoided with bash option shopt -s nullglob
@BinaryZebra Setting nullglob would avoid the error message, but would cause even more confusion: with nullglob set and no subdirectories, ls */ would expand to just ls, which would list all files in the current directory. I'm pretty sure that's not what you want in that case.
*/ also sets the names of the subdirs to be displayed with a trailing slash.
List all folders exclude ./ ../: ls -d */ .[^.]*/
I
Iulian Onofrei

Four ways to get this done, each with a different output format

1. Using echo

Example: echo */, echo */*/
Here is what I got:

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

2. Using ls only

Example: ls -d */
Here is exactly what I got:

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

Or as list (with detail info): ls -dl */

3. Using ls and grep

Example: ls -l | grep "^d" Here is what I got:

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. Bash Script (Not recommended for filename containing spaces)

Example: for i in $(ls -d */); do echo ${i%%/}; done
Here is what I got:

cs  
draft  
files  
hacks  
masters  
static

If you like to have '/' as ending character, the command will be: for i in $(ls -d */); do echo ${i}; done

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

NB. 3 was noticeably slower than the others for me. In the directory I tested: 1 .012s, 2 .016s, 3 .055s, 4 .021s.
@isomorphismes, how did you measure the time? By what means? By the way, I have to say, No. 1 is my favorite.
Albert, I used time, the Unix function. /// I agree, echo */ is cleverer than ls -d */.
Two minor things that you should note. ls -l | grep "^d" filters out symbolic links to directories, whereas 'ls -d */' displays them. Also, 'ls -d */' fails if there are no directories present at all in the target directory.
The 1. option will cause major pains when dealing with folders names that have spaces.
P
Peter Mortensen

I use:

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

This creates a single column without a trailing slash - useful in scripts.


The -1 option for ls will output in single-column format as well, as in ls -1 -d */.
@user29020 Should note that -1 still outputs a trailing slash for every entry.
When I add this to .bashrc as alias, how do I add '/'?
@RNA late to answer, but for future people: try escaping with a backslash? '\/'
Breaks if there's a leading slash. This removes trailing slashes only: | sed -e 's-/$--'
P
Peter Mortensen

For all folders without subfolders:

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

For all folders with subfolders:

find /home/alice/Documents -type d

To match the question (but include dotfiles), the first should be: find /home/alice/Documents -maxdepth 1 -mindepth 1 -type d otherwise you include /home/alice/Documents itself. To include symlinks to directories, prefix with -L
This seems like the sanest solutions, since find is the tool that is actually made for this task. You can exclude the first result - ./ for the current directory - by piping to grep -v '^\./$'
P
Peter Mortensen

Four (more) Reliable Options.

An unquoted asterisk * will be interpreted as a pattern (glob) by the shell. The shell will use it in pathname expansion. It will then generate a list of filenames that match the pattern.

A simple asterisk will match all filenames in the PWD (present working directory). A more complex pattern as */ will match all filenames that end in /. Thus, all directories. That is why the command:

1.- echo.

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

will be expanded (by the shell) to echo all directories in the PWD.

To test this: Create a directory (mkdir) named like test-dir, and cd into it:

mkdir test-dir; cd test-dir

Create some directories:

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:

The command echo ./*/ will remain reliable even with odd named files:

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

But the spaces in filenames make reading a bit confusing.

If instead of echo, we use ls. The shell is still what is expanding the list of filenames. The shell is the reason to get a list of directories in the PWD. The -d option to ls makes it list the present directory entry instead of the contents of each directory (as presented by default).

ls -d */

However, this command is (somewhat) less reliable. It will fail with the odd named files listed above. It will choke with several names. You need to erase one by one till you find the ones with problems.

2.- ls

The GNU ls will accept the "end of options" (--) key.

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

3.-printf

To list each directory in its own line (in one column, similar to ls -1), use:

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

And, even better, we could remove the trailing /:

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

An attempt like

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

will fail on:

some names (ls -d */) as already shown above.

will be affected by the value of IFS.

will split names on spaces and tabs (with default IFS).

each newline in the name will start a new echo command.

4.- Function

Finally, using the argument list inside a function will not affect the arguments list of the present running shell. Simply

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

presents this list:

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

These options are safe with several types of odd filenames.


P
Peter Mortensen

The tree command is also pretty useful here. By default it will show all files and directories to a complete depth, with some ASCII characters showing the directory tree.

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

But if we wanted to get just the directories, without the ASCII tree, and with the full path from the current directory, you could do:

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

The arguments being:

-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.

And if you then want the absolute path, you could start by specifying the full path to the current directory:

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

And to limit the number of subdirectories, you can set the max level of subdirectories with -L level, e.g.:

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

More arguments can be seen with man tree.


P
Peter Mortensen

In case you're wondering why output from 'ls -d */' gives you two trailing slashes, like:

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

it's probably because somewhere your shell or session configuration files alias the ls command to a version of ls that includes the -F flag. That flag appends a character to each output name (that's not a plain file) indicating the kind of thing it is. So one slash is from matching the pattern '*/', and the other slash is the appended type indicator.

To get rid of this issue, you could of course define a different alias for ls. However, to temporarily not invoke the alias, you can prepend the command with backslash:

\ls -d */

P
Peter Mortensen

Actual ls solution, including symlinks to directories

Many answers here don't actually use ls (or only use it in the trivial sense of ls -d, while using wildcards for the actual subdirectory matching. A true ls solution is useful, since it allows the use of ls options for sorting order, etc.

Excluding symlinks

One solution using ls has been given, but it does something different from the other solutions in that it excludes symlinks to directories:

ls -l | grep '^d'

(possibly piping through sed or awk to isolate the file names)

Including symlinks

In the (probably more common) case that symlinks to directories should be included, we can use the -p option of ls, which makes it append a slash character to names of directories (including symlinked ones):

ls -1p | grep '/$'

or, getting rid of the trailing slashes:

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

We can add options to ls as needed (if a long listing is used, the -1 is no longer required).

Note: if we want trailing slashes, but don't want them highlighted by grep, we can hackishly remove the highlighting by making the actual matched portion of the line empty:

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

P
Peter Mortensen

A plain list of the current directory, it'd be:

ls -1d */

If you want it sorted and clean:

ls -1d */ | cut -c 1- | rev | cut -c 2- | rev | sort

Remember: capitalized characters have different behavior in the sort


P
Peter Mortensen

If a hidden directory is not needed to be listed, I offer:

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

And if hidden directories are needed to be listed, use:

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

Or

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

If you need to know more about awk, please look at this answer
Compared to other answers the first option of "ls .. | grep ...| awk" seems excessive scripting.
You're assuming no directories have whitespace inside their names.
ls -l | awk '/^d/ {print $9}' This is what I cam up with :) and since is already there thumb up!
ls -l | awk '/^d/ {print $9}' works, other solutions do not work when there is no directory
P
Peter Mortensen

I just add this to my .bashrc file (you could also just type it on the command line if you only need/want it for one session):

alias lsd='ls -ld */'

Then lsd will produce the desired result.


Couldn't you just use? ls -l path | grep dr
"then lsd will produce the desired result." I laugh
In my experience, it produces a result.
I use 'lad' (list all directories), and I also included '.*/' to include hidden directories too. Of course, the innuendo is not lost on me either.
v
vinzee

Here is what I am using

ls -d1 /Directory/Path/*;

This is actually a pretty good solution to display it line by line.
It won't list directories only. You must add a trailing slash : ls -d1 /Directory/Path/*/
Yep. Thanks for the comment. To list the directories in my current path I had to do this: ls -d1 ./*/ or this ls -d1 */
P
Peter Mortensen

For listing only directories:

ls -l | grep ^d

For listing only files:

ls -l | grep -v ^d 

Or also you can do as:

ls -ld */

P
Peter Mortensen

Try this one. It works for all Linux distribution.

ls -ltr | grep drw

ls -l | grep '^d' | awk '{print $9}'
P
Peter Mortensen

To show folder lists without /:

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

or ls -d1 */ | tr -d "/"
No need to call an external command: set -- */; printf "%s\n" "${@%/}"
I like solution of @wholanda. My a bit shorter solution is (tested & works): ls -d */|sed 's|/||g'
Also having an lsdir alias is useful: alias lsdirs="ls -d */ | sed 's|/||g'"
m
muru

Test whether the item is a directory with test -d:

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

Please explain what this code does, and how it relates to the question.
it runs teh command 'ls' then loops through the output test-ing if each is a directory and echo-ing if it is.. works but there are better ways
@ShoeLace: What are some better ways? Are some of them represented in answers here?
D
DevWL

ls and awk (without grep)

ls -l | awk '/^d/ {print $9}'

where ls -l list files with permisions
awk filter output
'/^d/' regularexpresion that search only for lines starting with letter d (as directory) looking at first line - permisions
{print} would prints all columns
{print $9} will print only 9th column (name) from ls -l output

Very simple and clean


w
warfreak92

FYI, if you want to print all the files in multi-line, you can do a ls -1 which will print each file in a separate line. file1 file2 file3


P
Peter Mortensen

*/ is a filename matching pattern that matches directories in the current directory.

To list directories only, I like this function:

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

Put it in your .bashrc file.

Usage examples:

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

Note: it will break if you use the -i option. Here is a fix for that:

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

P
Peter Mortensen
file * | grep directory

Output (on my machine) --

[root@rhel6 ~]# file * | grep directory
mongo-example-master:    directory
nostarch:                directory
scriptzz:                directory
splunk:                  directory
testdir:                 directory

The above output can be refined more by using cut:

file * | grep directory | cut -d':' -f1
mongo-example-master
nostarch
scriptzz
splunk
testdir

* could be replaced with any path that's permitted
 file - determine file type
 grep - searches for string named directory
 -d - to specify a field delimiter
 -f1 - denotes field 1

u
user9342572809

One-liner to list directories only from "here".

With file count.

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

g
glennsl

Using Perl:

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

P
Peter Mortensen

I partially solved it with:

cd "/path/to/pricipal/folder"

for i in $(ls -d .*/); do sudo ln -s "$PWD"/${i%%/} /home/inukaze/${i%%/}; done

    ln: «/home/inukaze/./.»: can't overwrite a directory
    ln: «/home/inukaze/../..»: can't overwrite a directory
    ln: accesing to «/home/inukaze/.config»: too much symbolics links levels
    ln: accesing to «/home/inukaze/.disruptive»: too much symbolics links levels
    ln: accesing to «/home/inukaze/innovations»: too much symbolics links levels
    ln: accesing to «/home/inukaze/sarl»: too much symbolics links levels
    ln: accesing to «/home/inukaze/.e_old»: too much symbolics links levels
    ln: accesing to «/home/inukaze/.gnome2_private»: too much symbolics links levels
    ln: accesing to «/home/inukaze/.gvfs»: too much symbolics links levels
    ln: accesing to «/home/inukaze/.kde»: too much symbolics links levels
    ln: accesing to «/home/inukaze/.local»: too much symbolics links levels
    ln: accesing to «/home/inukaze/.xVideoServiceThief»: too much symbolics links levels

Well, this reduce to me, the major part :)


C
Community

Here is a variation using tree which outputs directory names only on separate lines, yes it's ugly, but hey, it works.

tree -d | grep -E '^[├|└]' | cut -d ' ' -f2

or with awk

tree -d | grep -E '^[├|└]' | awk '{print $2}'

This is probably better however and will retain the / after directory name.

ls -l | awk '/^d/{print $9}'

A
Avinash Raut

if you have space in your folder name $9 print wont work try below command

ls -l yourfolder/alldata/ | grep '^d' | awk '{print $9" " $10}'

output

ls -l yourfolder/alldata/ | grep '^d' | awk '{print $9" " $10}'
testing_Data 
Folder 1

t
torbatamas

I found this solution the most comfortable, I add to the list:

find * -maxdepth 0 -type d

The difference is that it has no ./ at the beginning, and the folder names are ready to use.


f
flow2k

To answer the original question, */ has nothing to do with ls per se; it is done by the shell/Bash, in a process known as globbing.

This is why echo */ and ls -d */ output the same elements. (The -d flag makes ls output the directory names and not contents of the directories.)


P
Peter Mortensen

Adding on to make it full circle, to retrieve the path of every folder, use a combination of Albert's answer as well as Gordans. That should be pretty useful.

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

Output:

/pathto/parent/folder/childfolder1/
/pathto/parent/folder/childfolder2/
/pathto/parent/folder/childfolder3/
/pathto/parent/folder/childfolder4/
/pathto/parent/folder/childfolder5/
/pathto/parent/folder/childfolder6/
/pathto/parent/folder/childfolder7/
/pathto/parent/folder/childfolder8/

P
Peter Mortensen

Here is what I use for listing only directory names:

ls -1d /some/folder/*/ | awk -F "/" "{print \$(NF-1)}"