How to list all files in a directory with absolute paths

Question

I need a file (preferably a .list file) which contains the absolute path of every file in a directory.

Example dir1: file1.txt file2.txt file3.txt

listOfFiles.list:

/Users/haddad/dir1/file1.txt
/Users/haddad/dir1/file2.txt
/Users/haddad/dir1/file3.txt

How can I accomplish this in linux/mac?

Answer 1

You can use find. Assuming that you want only regular files, you can do:

find /path/to/dir -type f > listOfFiles.list

You can adjust the type parameter as appropriate if you want other types of files.

Answer 2

ls -d "$PWD"/* > listOfFiles.list

Answer 3

Note that in:

ls -d "$PWD"/* > listOfFiles.list

It's the shell that computes the list of (non-hidden) files in the directory and passes the list to ls. ls just prints that list here, so you could as well do:

printf '%s\n' "$PWD"/* > listOfFiles.list

Note that it doesn't include hidden files, includes files of any type (including directories) and if there's no non-hidden file in the directory, in Bourne/POSIX/rc-like shells, you'd get /current/wd/* as output. Also, since the newline character is as valid as any in a file path, if you separate the file paths with newline characters, you won't be able to use that resulting file to get back to the list of files reliably.

With the zsh shell, you could do instead:

print -rNC1 $PWD/*(ND-.) > listOfFiles.list

Where:

• -rC1 prints raw on 1 Column.
• -N, output records are NUL-delimited instead of newline-delimited (lines) as NUL is the only character that can't be found in a file name.
• N: expands to nothing if there's no matching file (nullglob)
• D: include hidden files (dotglob).
• -.: include only regular files (.) after symlink resolution (-).

Then, you'd be able to do something like:

xargs -0 rm -f -- < listOfFiles.list

To remove those files for instance.

You could also use the :P modifier in the glob qualifiers to get the equivalent of realpath() on the files expanded from the globs (gets a full path exempt of any symlink component):

print -rNC1 -- *(ND-.:P) > listOfFiles.list

Answer 4

To see just regular files --

find "$PWD" -type f  > output

Answer 5

Another way with tree, not mentioned here, it goes recursively and unlike find or ls you don't have any errors (like: Permission denied, Not a directory) you also get the absolute path in case you want to feed the files to xargs or other command

tree -fai /pathYouWantToList >listOfFiles.list

the options meaning:

-a     All  files  are  printed.  By default tree does not print hidden files (those beginning with a dot
       `.').  In no event does tree print the file system constructs `.'  (current  directory)  and  `..'
       (previous directory).

-i     Makes tree not print the indentation lines, useful when used in conjunction with the -f option.

-f     Prints the full path prefix for each file.

To install tree:

sudo apt install tree on Ubuntu/Debian

sudo yum install tree on CentOS/Fedora

sudo zypper install tree on OpenSUSE

Answer 6

You can just use realpath or readlink this naughty way:

ls | xargs realpath

When ls prints to a TTY it formats the file names in columns, but when it's writing to a file, pipe, or other non-TTY it behaves like ls -1 and prints one file name per line. You can check this by running ls | cat in place of ls.^[1]

• xargs build and execute command lines from standard input.
• realpath: return the canonicalized absolute pathname
• readlink: read value of a symbolic link
• Use realpath -- to make it treat everything that follows as parameters instead of options, if files could have " -something".
• If some files have spaces you could:

  ls | xargs -I {} realpath -- {}
  

Answer 7

In a past Linux environment, I had a resolve command that would standardize paths, including making a relative path into an absolute path. I can't find it now, so maybe it was written by someone in that organization.

You can make your own script using functions in the Python or Perl standard libraries (and probably other languages too).

resolve.py :

#!/bin/env python

import sys
import os.path

for path in sys.argv:
    print os.path.abspath(path)

resolve.pl :

#!/bin/env perl

use warnings;
use Cwd qw ( abs_path );

foreach (@ARGV) {
    print abs_path($_), "\n";
}

Then, you would solve your problem with:

resolve.py * > listOfFiles.list

---

With this command, you can also do things like this:

cd /root/dir1/dir2/dir3
resolve.py ../../dir4/foo.txt
# prints /root/dir1/dir4/foo.txt

Answer 8

Recursive files can be listed by many ways in linus. Here i am sharing one liner script to clear all logs of files(only files) from /var/log/ directory and second check recently which logs file has made an entry.

First:-

find /var/log/ -type f  #listing file recursively 

Second:-

for i in $(find $PWD -type f) ; do cat /dev/null > "$i" ; done #empty files recursively 

Third use:-

ls -ltr $(find /var/log/ -type f ) # listing file used in recent

note: for directory location you can also pass $PWD instead of /var/log.

Answer 9

I find bash find $(pwd) works well. Also, ls | xargs realpath works. You can add any other flags to the latter example as well as the first.

Answer 10

To list the full path of all commands (apps/programs) accessible to the user... (revised to address most, but not all limitations outlined in the comments)

eval ls -d $(echo $PATH | sed -e 's|^:|.:|'  -e 's|:$|:.:|'  -e 's|:|/{.,}[[:word:]]* |g') 2>/dev/null | sort

NOTE
The PATH variable would normally have a colon (:) either at the beginning or at the end, but not both. A colon at the beginning or end signifies to search the current directory as well. Standard practice is for it to be at the end so as to never override standard utility programs. The sed substitutions here handle either case.

Explanation...

• eval
  Frankly, I don't know why eval is needed here, but it is. Without it, I get...

ls: cannot access './{.,}[[:word:]]': No such file or directory
ls: cannot access '/home/alpha/bin/{.,}[[:word:]]': No such file or directory
ls: cannot access '/usr/local/sbin/{.,}[[:word:]]': No such file or directory
ls: cannot access '/usr/local/bin/{.,}[[:word:]]': No such file or directory
ls: cannot access '/usr/sbin/{.,}[[:word:]]': No such file or directory
ls: cannot access '/usr/bin/{.,}[[:word:]]': No such file or directory
ls: cannot access '/sbin/{.,}[[:word:]]': No such file or directory
ls: cannot access '/bin/{.,}[[:word:]]': No such file ordirectory

• ls -d
  List directories. The -d option doesn't really just list directories. By appending /* to each directory (see below), we will get the contents of the directories.
• $( ... ) Perform the commands inside parens and replace the $( ... ) with the results for ls to use.
  • $(echo :$PATH | sed -e 's|^:|.:|' -e 's|:$|:.:|' -e 's|:|/{.,}[[:word:]]* |g')
    • Produces a space-separated list of directory patterns like...

      ./{.,}[[:word:]]* /home/alpha/bin/{.,}[[:word:]]* /usr/local/sbin/{.,}[[:word:]]* /usr/local/bin/{.,}[[:word:]]* /usr/sbin/{.,}[[:word:]]* /usr/bin/{.,}[[:word:]]* /sbin/{.,}[[:word:]]* /bin/{.,}[[:word:]]*
      

    • echo $PATH
      The PATH environment variable contains a colon-separated list of all directories that will be searched for commands.
    • sed
      Stream editor utility. The following -e substitution options are processed sequentially so that the results of each are available to the next. Thus, the :.: inserted by the second one allow the colons be replaced by the pattern in the third.
    • -e 's|^:|.:|'
      If PATH starts with a colon(:), replace it with .:
    • -e 's|:$|:.:|'
      If PATH ends with a colon(:), replace it with :.:
    • -e 's|:|/{.,}[[:word:]]* |g
      Replace every colon (:) with /{.,}[[:word:]]*. This pattern includes files beginning with a dot (.) followed by any number of alphanumeric or underscore characters. The extra comma (,) in {.,} is a quirk of bash 5.0.18 as it is expecting a comma separated list or range. We are using brace substitution here to make the dot (.) optional.
    • 2>/dev/null
      Discard error messages.
• | sort
  Optionally, sort the output from the previous command.

Answer 11

fd, a find alternative, can be used (replace PATH):

fd . PATH --type file --absolute-path --max-depth 1 > list-of-files.txt