Ygtjki

find /foo/foo2/ -maxdepth 1 | wc -l

Is considerably faster on my machine but the local . directory is added to the count.

ls -1U before the pipe should spend just a bit less resources, as it does no attempt to sort the file entries, it just reads them as they are sorted in the folder on disk. It also produces less output, meaning slightly less work for wc.

You could also use ls -f which is more or less a shortcut for ls -1aU.

I don't know if there is a resource-efficient way to do it via a command without piping though.

Another point of comparison. While not being a shell oneliner, this C program doesn't do anything superflous. Note that hidden files are ignored to match the output of ls|wc -l (ls -l|wc -l is off by one due to the total blocks in the first line of output).

#include <stdio.h>
#include <stdlib.h>
#include <dirent.h>
#include <error.h>
#include <errno.h>

int main(int argc, char *argv[])

 int file_count = 0;
 DIR * dirp;
 struct dirent * entry;

 if (argc < 2)
 error(EXIT_FAILURE, 0, "missing argument");

 if(!(dirp = opendir(argv[1])))
 error(EXIT_FAILURE, errno, "could not open '%s'", argv[1]);

 while ((entry = readdir(dirp)) != NULL) 
 if (entry->d_name[0] == '.') /* ignore hidden files */
 continue;
 
 file_count++;
 
 closedir(dirp);

 printf("%dn", file_count);

You could try perl -e 'opendir($dh,".");$i=0;while(readdir $dh)$i++;print "$in";'

It'd be interesting to compare timings with your shell pipe.

From this answer, I can think of this one as a possible solution.

/*
 * List directories using getdents() because ls, find and Python libraries
 * use readdir() which is slower (but uses getdents() underneath.
 *
 * Compile with 
 * ]$ gcc getdents.c -o getdents
 */
#define _GNU_SOURCE
#include <dirent.h> /* Defines DT_* constants */
#include <fcntl.h>
#include <stdio.h>
#include <unistd.h>
#include <stdlib.h>
#include <sys/stat.h>
#include <sys/syscall.h>

#define handle_error(msg) 
 do perror(msg); exit(EXIT_FAILURE); while (0)

struct linux_dirent 
 long d_ino;
 off_t d_off;
 unsigned short d_reclen;
 char d_name[];
;

#define BUF_SIZE 1024*1024*5

int
main(int argc, char *argv[])

 int fd, nread;
 char buf[BUF_SIZE];
 struct linux_dirent *d;
 int bpos;
 char d_type;

 fd = open(argc > 1 ? argv[1] : ".", O_RDONLY 

Copy the C program above into directory in which the files need to be listed. Then execute these commands:

gcc getdents.c -o getdents
./getdents | wc -l

A bash-only solution, not requiring any external program, but don't know how much efficient:

list=(*)
echo "$#list[@]"

Probably the most resource efficient way would involve no outside process invocations. So I'd wager on...

cglb() ( c=0 ; set --
 tglb() [ -e "$2" ] 
 for glb in '.?*' *
 do tglb $1 $glb##.* $glb#*
 set -- ..
 done
 echo $c
)

After fixing the issue from @Joel 's answer, where it added . as a file:

find /foo/foo2 -maxdepth 1 | tail -n +2 | wc -l

tail simply removes the first line, meaning that . isn't counted anymore.

os.listdir() in python can do the work for you. It gives an array of the contents of the directory, excluding the special '.' and '..' files. Also, no need to worry abt files with special characters like 'n' in the name.

python -c 'import os;print len(os.listdir("."))'

following is the time taken by the above python command compared with the 'ls -Af' command.

~/test$ time ls -Af |wc -l
399144

real 0m0.300s
user 0m0.104s
sys 0m0.240s
~/test$ time python -c 'import os;print len(os.listdir("."))'
399142

real 0m0.249s
user 0m0.064s
sys 0m0.180s

ls -1 | wc -l comes immediately to my mind. Whether ls -1U is faster than ls -1 is purely academic - the difference should be negligible but for very large directories.

I know this is old but I feel that awk has to be mentioned here. The suggestions that include the use of wc simply aren't correct in regards to OP's question: "the most resource efficient way." I recently had a log file get way out of control (due to some bad software) and therefore stumbled onto this post. There was roughly 232 million entries! I first tried wc -l and waited 15 minutes - it was not even able to finish counting the lines. The following awk statement gave me an accurate line count in 3 minutes on that log file. I've learned over the years to never underestimate awk's ability to simulate standard shell programs in a much more efficient fashion. Hope it helps someone like me. Happy hacking!

awk 'BEGINi=0 i++ ENDprint i' /foo/foo2

And if you need to substitute a command like ls for counting files in a directory:

`#Normal:` awk 'BEGINi=0 i++ ENDprint i' <(ls /foo/foo2/)
`#Hidden:` awk 'BEGINi=0 i++ ENDprint (i-2)' <(ls -f /foo/foo2/)

I would think echo * would be more efficient than any 'ls' command:

echo * | wc -w