3

I have a directory with the following content:

$ mkdir dir && cd "$_" ~/dir $ mkdir a1 a2 a3 a4 b1 c1 c2 1a 2a 2b 2c 2d 3a _1 _2 ~/dir $ touch a_1 a_2 a_3 a_4 b_1 c_1 c_2 1_a 2_a 2_b 2_c 2_d 3_a __1 __2 ~/dir $ ls __1 1_a __2 2_a 2_b 2_c 2_d 3_a a_1 a_2 a_3 a_4 b_1 c_1 c_2 _1 1a _2 2a 2b 2c 2d 3a a1 a2 a3 a4 b1 c1 c2

Now I want to group all these files and directories based on their first letter and move them to directories of the same letter. So the output would be:

~/dir $ ls _ 1 2 3 a b c

And using exa, the tree would look something like this:

~/dir $ exa --tree . ├── 1 │ ├── 1_a │ └── 1a ├── 2 │ ├── 2_a │ ├── 2_b │ ├── 2_c │ ├── 2_d │ ├── 2a │ ├── 2b │ ├── 2c │ └── 2d ├── 3 │ ├── 3_a │ └── 3a ├── _ │ ├── _1 │ ├── _2 │ ├── __1 │ └── __2 ├── a │ ├── a1 │ ├── a2 │ ├── a3 │ ├── a4 │ ├── a_1 │ ├── a_2 │ ├── a_3 │ └── a_4 ├── b │ ├── b1 │ └── b_1 └── c ├── c1 ├── c2 ├── c_1 └── c_2

I know I can move using wildcards:

~/dir $ mkdir a && mv a* a

Which throws an error:

mkdir: cannot create directory ‘a’: File exists

But it gets the job done. And I can do something like this to avoid the error:

~/dir $ mkdir temp && mv a* temp && mv temp a

And then I could use that in a for loop for every letter that I know. But the problem is that I don't know what those first letters could possibly be, we have quite a lot of letters. Is there a way I can achieve this without the need to know those letters?

Improve this question

5 Answers 5

Reset to default
3

Just iterate over all the things:

#!/bin/bash for f in *; do firstChar="${f:0:1}"; mkdir -p -- "$firstChar"; mv -- "$f" "$firstChar"; done

The -p tells mkdir not to complain if the directory already exists and ${f:0:1} is Ksh/Bash/Zsh syntax for "get the first character".

And here it is in action:

$ mkdir a1 a2 a3 a4 b1 c1 c2 1a 2a 2b 2c 2d 3a _1 _2 $ touch a_1 a_2 a_3 a_4 b_1 c_1 c_2 1_a 2_a 2_b 2_c 2_d 3_a __1 __2 $ ls -F __1 _1/ 1_a 1a/ __2 _2/ 2_a 2a/ 2_b 2b/ 2_c 2c/ 2_d 2d/ 3_a 3a/ a_1 a1/ a_2 a2/ a_3 a3/ a_4 a4/ b_1 b1/ c_1 c1/ c_2 c2/ $ for f in *; do firstChar="${f:0:1}"; mkdir -p "$firstChar"; mv -- "$f" "$firstChar"; done $ tree . ├── _ │   ├── __1 │   ├── _1 │   ├── __2 │   └── _2 ├── 1 │   ├── 1_a │   └── 1a ├── 2 │   ├── 2_a │   ├── 2a │   ├── 2_b │   ├── 2b │   ├── 2_c │   ├── 2c │   ├── 2_d │   └── 2d ├── 3 │   ├── 3_a │   └── 3a ├── a │   ├── a_1 │   ├── a1 │   ├── a_2 │   ├── a2 │   ├── a_3 │   ├── a3 │   ├── a_4 │   └── a4 ├── b │   ├── b_1 │   └── b1 └── c ├── c_1 ├── c1 ├── c_2 └── c2 22 directories, 15 files

Note that if you can have existing file or directory names that are only one character, that will cause errors. For instance, if you create a file called a and try the above approach, you will get:

mkdir: cannot create directory ‘a’: File exists mv: 'a' and 'a' are the same file

If that is a problem, you could do something convoluted like renaming to a temp file, creating the directory, and moving the file into it:

for f in *; do firstChar="${f:0:1}"; ## if the first character exists as a dir, move the file there if [[ -d "$firstChar" ]]; then mv -- "$f" "$firstChar"; ## if it exists but is not a dir, move to a temp location, ## re-create it as a dir, and move back from temp elif [[ -e "$firstChar" ]]; then tmp=$(mktemp ./tmp.XXXXX) mv -- "$firstChar" "$tmp" mkdir -p "$firstChar" mv -- "$tmp" "$firstChar"/"$f" else mkdir -p "$firstChar"; mv -- "$f" "$firstChar"; fi done
Improve this answer
3
  • In my case there are regular files f, fu and fuu. Will I lose data? Commented Apr 16, 2021 at 12:45
  • @KamilMaciorowski good point. You won't lose data, but the f would cause errors. See update. Commented Apr 16, 2021 at 13:25
  • I have tested the basic code of yours. I lost data because all the files overwrote f one by one. Improvement: mv -- "$f" "$firstChar"/. Commented Apr 16, 2021 at 13:26
1

POSIXly:

find . -path './*' -prune -exec sh -c ' j="${1%${1#???}}"; mkdir "$j" && mv -- "$1" "$j/" ' _ {} \; 2>/dev/null
Improve this answer
1

Another approach that hasn't been mentioned is to find all the unique first letters of files and directories, move everything to a temporary directory, create the first letter directory, and then move back everything.

letters=($(ls -1 | sort -n | cut -c 1 | uniq)) temp=$(mktemp -dp .) for letter in "${letters[@]}"; do mv "$letter"* "$temp"; mkdir "$letter"; mv "$temp/"* "$letter"; done rm -r "$temp"

With this approach, one-letter directories and files are also taken care of. In action:

$ mkdir a1 a2 a3 a4 b1 c1 c2 1a 2a 2b 2c 2d 3a _1 _2 $ touch a_1 a_2 a_3 a_4 b_1 c_1 c_2 1_a 2_a 2_b 2_c 2_d 3_a __1 __2 $ mkdir a b c $ touch 1 2 3 _ $ ls -F _ 1 __2 2_a 2b/ 2_d 3_a a_1 a2/ a_4 b_1 c_1 c2/ __1 1_a _2/ 2a/ 2_c 2d/ 3a/ a1/ a_3 a4/ b1/ c1/ _1/ 1a/ 2 2_b 2c/ 3 a/ a_2 a3/ b/ c/ c_2

And after that script, the result becomes:

$ ls -F _/ 1/ 2/ 3/ a/ b/ c/ $ exa --tree . ├── 1 │ ├── 1 │ ├── 1_a │ └── 1a ├── 2 │ ├── 2 │ ├── 2_a │ ├── 2_b │ ├── 2_c │ ├── 2_d │ ├── 2a │ ├── 2b │ ├── 2c │ └── 2d ├── 3 │ ├── 3 │ ├── 3_a │ └── 3a ├── _ │ ├── _ │ ├── _1 │ ├── _2 │ ├── __1 │ └── __2 ├── a │ ├── a │ ├── a1 │ ├── a2 │ ├── a3 │ ├── a4 │ ├── a_1 │ ├── a_2 │ ├── a_3 │ └── a_4 ├── b │ ├── b │ ├── b1 │ └── b_1 └── c ├── c ├── c1 ├── c2 ├── c_1 └── c_2

With this approach, you create only the necessary directories. So the mkdir commands runs the least amount of times possible.

Edit: As @terdon mentioned, parsing the output of ls will cause the command to fail on files with newline in their names. To fix that, we can use this:

temp=$(mktemp -dp .) for f in *; do letter="${f:0:1}"; mv -- "$letter"* "$temp"; mkdir "$letter"; mv "$temp/"* "$letter"; done rm -r "$temp"
Improve this answer
0

First, the solution for your move pattern is simple, just add a ?. That only matches a followed by at least another character.

mv a?* a

We don't have that many letters, but to find all actually present letters, you can use this command. sed removes everything after the first letter, sort uniq removes the duplicates.

ls | sed -r 's/^(.).*$/\1/' | sort -u
Improve this answer
5
  • 1
    Note that your sed approach will fail if any file names contain newlines. Commented Apr 16, 2021 at 12:45
  • @terdon Yes. But have you ever seen newline in file names in real life? Commented Apr 16, 2021 at 12:58
  • 3
    Yes, of course. Many times. Usually because of a bug somewhere, but not always. More importantly, such files can be trivially created (e.g. touch foo$'\n'bar) so we should make sure we can deal with them. Commented Apr 16, 2021 at 13:00
  • @RalfFriedl, of nothing else, we see them every time we test the answers we write here on the site :D Commented Apr 16, 2021 at 14:06
  • @RalfFriedl, but, a world where such effed-up filenames were not possible would indeed be a nicer one. We just need to convince every Unix-like system to add some limitations. Or at least convince them to read dwheeler.com/essays/fixing-unix-linux-filenames.html Commented Apr 16, 2021 at 14:37
0

With zsh:

autoload -Uz zmv # best in ~/.zshrc () { mkdir ${(uM)@#?}; } ??* && zmv '(?)?*' '$1/$f'

We have:

  • () { body; } args: an anonymous function, here passed the expansion of ??* (the file names made of at least 2 characters) as arguments. In the body:
  • ${@#?} would be the args stripped of their first character, but with the M (for matched) parameter expansion flag, that's reversed and only the first character is retained instead. u (for unique) removes duplicates.
  • then zmv '(?)?*' '$1/$f' moves the files with at least 2 characters into their respective folder.
Improve this answer

You must log in to answer this question.

Start asking to get answers

Find the answer to your question by asking.

Ask question

Explore related questions

See similar questions with these tags.