Strip characters in bash output

Question

I have this command which is working for me, which will find zero or one directories in the current directory which match a pattern:

find . -maxdepth 1 -type d -name 'suman-*'| head -n1

on MacOS, this will result in something like:

./suman-1479860474833

<!EDIT>

My goal is to find the most recent directory (with the most recent timestamp). The directory contents look like:

foo
bar 
baz
suman-1479860475524
suman-1479860471431
suman-1479860474233
...
etc.

</EDIT>

I have three questions,

1. Using bash, how can I strip out the ./ characters if they exist in the result? They should always be there, but I think always removing the first two characters might be too kludgy.

2. Using bash, instead of finding the first result with head what is the best way to find the last result? I am guessing it's tail but maybe there is a better way.

3. Is there a way to only match against a number instead of just using 'suman-*'? Perhaps I should use -regex instead of -name?

Now, I could sort the directories by the timestamp in the directory name, or I could potentially sort them by their metadata (if that metadata is accurate and persists through version control updates etc). I am not personally sure that the directory metadata is persistent enough, so I guess would rather be more transparent and use the timestamp in the directory name. And it looks like there is no created time in Unix for directories => "In Unix creation time is not stored (only: access, modification and change)."

Answer 1

Getting the most recently modified folder (OS X Compatible):

stat -f "%HT %Sm %i" -t %Y%m%d%H%M%S * | grep "^Directory" | cut -f2- -d ' ' | sort -rn | head -1 | cut -f2- -d ' ' | while read inode ; do find . -inum "$inode" | basename "$(cat -)" ; done

Result: suman-1479860475524

Getting the most recently named suman- timestamp (OS X Compatible):

find ./ -mindepth 1 -maxdepth 1 -type d -name "suman-*" -print0 | sort -zn | while IFS= read -d '' file ; do basename "$file" ; done | tail -1

Result:

• suman-1479860475524

---

Most recent folder (any name):

• stat -f "%HT %Sm %i" -t %Y%m%d%H%M%S *: Lists folders beginning with a machine readable timestamp in seconds (therefore cut can be used safely), and displays the type, anode, and timestamp (see https://www.freebsd.org/cgi/man.cgi?stat(1) ):

  • Directory 20161124051357 17658795
    Directory 20161124051358 17658796
    Directory 20161124051356 17658793
    Directory 20161124051359 17658798
    Directory 20161124051400 17658800
    Directory 20161124051401 17658802
    

• | grep "^Directory" | cut -f2- -d ' ': Selects folders, and trims off "Directory"

• | sort -rn: Numerical sort, newest to oldest

• | head -1 : Only most recent

• | cut -f2- -d ' ': Show only inode component

• | while read inode ; do find . -inum "$inode" -print0: Find the file based on the inode (some may argue from this step on is un-necessary, but it returns full folder names in the event of an odd named folder with embedded special characters)

At this point (if we added ; done here) we would have :

• ./suman-1479860475524

So finally

• | basename "$(cat -)" ; done : Returns just the name of the folder:

  • suman-1479860475524

---

Most recent suman- folder timestamp:

• find ./ -mindepth 1 -maxdepth 1 -type d -name "suman-*" -print0 : gets the folder names in current folder

• | sort -zn: sort them numerically, based on timestamp in directory name, not the actual filesystem modified timestamp.

• while IFS= read -d '' file ; do basename "$file" ; done : Strip directory location characters and slashes from the file, and output the file list as line separated

• | tail -1: just list the most recent one.

In this example, the result happens to be the same:

• suman-1479860475524

---

An example of an odd folder name where the ...while read inode ;... becomes useful:

1.

• mkdir $'some \r\t strange \n folder  \n\n name \n  totally nuts'

2.

• stat -f "%HT %Sm %i" -t %Y%m%d%H%M%S * | grep "^Directory" | cut -f2- -d ' ' | sort -rn | head -1 | cut -f2- -d ' ' | while read inode ; do find . -inum "$inode" -print0 | basename "$(cat -)" ; done
  

3. (Output)

• some     strange 
   folder  
  
   name 
    totally nuts
  

---

The Specific Questions

Using bash, how can I strip out the ./ characters if they exist in the result? (hoping they should always be there, but I think always removing the first two characters might be too kludgy).

• Use basename on the resultant file
• Use find "$PWD" instead of find . (this will produce full paths)
• Use -printf "%P" (this will only show the name part without the ./) (Note: GNU Find Required for -printf)

Using bash, instead of finding the first result with head what is the best way to find the last result (I am guessing it's tail but maybe there is a better way)

One way is to use:

• First Result: find ... | sort -n | tail -n1
• Last Result: find ... | sort -rn | tail -n1

(obviously "First" might actually be "Last", depending on it's meaning to you. You could basically substitute head command given this fact, as long as you keep it consistent, the -r in sort will reverse the order, hence the two pipe command sets will give you each a "First" and "Last" result)

Is there a way to only match against a number (it's a timestamp in millis) instead of just using 'suman-*'? Perhaps I should use -regex instead of -name?

You can just do -name '*1479860474833' instead of -name 'suman-*'

---

Alternative (Simpler) approach for GNU Find:

Three test folders for this example:

• suman-1479860474833
• suman-1489860474833
• suman-1499860474833

Example 1:

Here's a strict example that mitigates some risks of crazy folder names with embedded special characters

• find "$PWD" -mindepth 1 -maxdepth 1 -type d -print0 | sort -zn | tail -zn1
  

Gives:

• /my/dir/suman-1499860474833
  

Example 2:

This strips the leading "./", while keeping the NULL separation, using printf and \0:

• find "$PWD" -mindepth 1 -maxdepth 1 -type d -printf "%P \0" | sort -zn | tail -zn1
  

Gives:

• suman-1499860474833
  

NOTE: -mindepth 1 avoids returning the parent folder.

Answer 2

With GNU find, if you don't want ./, you can simply avoid telling find to print it.

# with GNU find
find . -maxdepth 1 -type d -name 'suman-*' -printf '%P\n' | head -n1

The %P format string excludes the part of the filename derived from the argument to find -- in this case, the ./.

With BSD find, you don't have that option, but can postprocess once your result is in a shell variable:

# strip "./" prefix from filename variable, if and only if it exists
filename=${filename#./}

---

As for head or tail, ordering is not guaranteed, so you can't rely on such options to find a specific file. If you want newest, oldest, first, last, etc., then you'll need to do additional work to achieve this in a reliable way. For instance:

IFS= read -r -d '' filename \
  < <(find . -maxdepth 1 -type d -name 'suman-*' -printf '%P\0' | sort -z)

...will read the first item when the stream is sorted, and...

IFS= read -r -d '' filename \
  < <(find . -maxdepth 1 -type d -name 'suman-*' -printf '%P\0' | sort -rz)

...will sort in the opposite direction, and thus read what would otherwise be the last.

---

Portability Notes

Note that neither find -print0 or sort -z is POSIX-specified, but both of these are available both in GNU toolchains and on current MacOS. find -printf, by contrast, requires GNU find; this can be installed on MacOS via the macports findutils package (which installs it as gfind)

Answer 3

tl;dr

printf '%s\n' suman-*/ | tail -n 1 | sed 's|/$||' # ... | cut -d/ -f1 works too

---

^{Note that this answer assumes that filenames don't have embedded newlines, which, fortunately, is rarely a real-world concern.
All commands in this answer are POSIX-compliant, except where noted.}

If you're only looking for immediate subdirectories in your target directory, there's no need for find - a simple glob will do:

printf '%s\n' suman-*/ | head -n 1

Note, however, that:

• this outputs subdirectory names with a trailing /.
• symlinks to directories are included.
• hidden subdirectories are not included (not a concern with suman-*/, which by definition never matches hidden dirs.) - to include hidden items in general, run shopt -s dotglob first (this is a Bash extension).
• output sorting is case-sensitive, even though the macOS default filesystem is case-insensitive - to change that, pipe the printf output to sort -f or sort -rf before further processing.

Regarding your request to find the most recently modified directory matching the pattern, combining ls -dt with a glob is the simplest option:

ls -dt suman-*/ | head -n 1 # print most recently modified suman-* subdir.

If, by contrast, the timestamps embedded in the directory names should drive the sorting (e.g., 1479860475524), reverse lexical sorting will do:

ls -dr suman-*/ | head -n 1 

Without the trailing /:

ls -dr suman-*/ | head -n 1 | sed 's|/$||' # with no path prefix, | cut -d/ -f1 works too

A slightly more cumbersome, but more robust alternative that avoids use of ls in favor of avoiding the max. command-line length when calling external utilities, as reported by getconf ARG_MAX, which could be a concern if a large number of files match the glob: ^{Tip of the hat to Charles Duffy.}

printf '%s\n' suman-*/ | tail -n 1 | sed 's|/$||'

Note: This assumes that printf is implemented as a shell builtin (as opposed to having to rely on the printf utility), which, however, is true of all major POSIX-like shells (bash, zsh, ksh, dash).

Case-insensitive alternative with sort (makes no difference in this scenario):

printf '%s\n' suman-*/ | sort -rf | head -n 1 | sed 's|/$||'

---

Regarding your 3 original questions:

Re 1): use sed to trim the trailing /: printf '%s\n' suman-*/ | head -n 1 | sed 's|/$||' (if stripping path prefixes is also a concern, it's easiest to cd to the path prefix first and then use a filename-only glob).

Re 2): use printf ... | tail -1 | ... to get the lexically last entry (or printf ... | sort -rf | head -n 1 | ... to get the lexically last entry irrespective of case).

Re 3): (globbing) patterns allow per-character-position digit matching with character sets such as [0-9], but you cannot apply regex-style quantifiers (duplication symbols) such as ? and + to them.

---

Generally, there are many subtle differences between using find and globbing / ls - caveat emptor.
Generally, parsing ls output should be avoided, but - assuming one is aware of the edge cases and limitations - sometimes it is the most convenient solution.

Answer 4

Thinking that "simpler is better":

# 1: Using cut (The option "-c 3-" means "from 3rd character"
find... | cut -c 3-

# 2: You're right, tail is the command (-n1 == -1)
find... | tail -1

# 3: -name should do it:
TIME=1479860474833
find... -name "suman-$TIME"

EDIT:

As you said:

The directory contents look like: foo bar baz suman-1479860475524 suman-1479860471431 suman-1479860474233 ... etc.

Most recent

To get the most recent directory, based on name, you can do:

$ find . -maxdepth 1 -type d -name suman-\* | cut -c3- | sort -rnk1.7 | head -1
# Result is:
suman-1479860475524

And if the content only have directories with name like 'suman*' (never a file with that pattern), then I think this is easier:

$ ls -1d suman-* | sort -rnk1.7 | head -1
# Result is:
suman-1479860475524

In both cases, the sort option -r (reverse) brings the most recent first, and -k1.7 will sort numerically -n from 7th character (millisecond part of name).

Oldest

In order to get the oldest directory, based on name, just not use -r option:

$ find . -maxdepth 1 -type d -name suman-\* | cut -c3- | sort -nk1.7 | head -1
# Result is:
suman-1479860471431

$ ls -1d suman-* | sort -nk1.7 | head -1
# Result is:
suman-1479860471431