如何在Linux中使用命令Shell在目录中创建特定文件的数组？

Question

I have been trying to add files smaller than 2 Megabytes in a directory to an array and then add those files to git and then commit.

  find . -type f -size -2M
  i=0
  while read line
  do
    array[ $i ]="$line"
    (( i++ ))
  done
  for item in "${array[@]}"
  do
    git add "$item"
  done
  git commit -am "${COMMIT_MESSAGE}"

The script is supposed to add and commit files below 2M. But my script is adding and committing all the files (including the ones larger than 2M). What am I doing wrong?

Answer 1

Use find to run git add .

find . -type f -size -2M -exec git add {} +

This will work for all valid file names.

The -a option to commit is probably not necessary. If you only have untracked large files, they won't be added by commit -a anyway, and you've already added all the modified small files. However, you do need to drop it if you have large tracked files with modifications that you don't want to include in the pending commit.

Answer 2

Short form: Resolving the immediate problem

First, with respect to correctly reading files from find , follow the advice in @chepner's answer .

Second, as to why your existing code includes all files already added to git in some past revision, as opposed to only those under 2MB, despite not running git add at all : That's because you're passing the -a argument to git commit .

find . -type f -size -2M -exec git add -- {} +
git commit -m "Commit message" # no -a here!

---

Long form: Explaining the problem

To be clear as to what I mean by "despite not running git add at all " above -- as currently written, the output of find isn't actually passed into the while read loop.

find .
while read ...

doesn't redirect the output of find into the while read loop. Thus, your while read line loop iterates only on input given to your script on stdin, if any (and the output of find is written to stdout).

For other issues, see notes below.

---

Long form: Answering the question as-asked

Now, to answer your literal question, about how to build a shell array, doing it right looks like the following:

# correctly building a shell array
files=( )
while IFS= read -r -d '' file; do
  files+=( "$file" )
done < <(find . -type f -size -2M -print0)

## using that array efficiently (if not huge)
#git add -- "${files[@]}"

# using that array efficiently (if potentially huge)
printf '%s\0' "${files[@]}" | xargs -0 git add --

Implementation notes:

• Putting the while loop in the outer shell ensures that changes to variable state that it makes are accessible after it finishes running. Using the < <(...) idiom is necessary to do so, as given in BashFAQ #24 .
• Passing multiple files to a single git add instance is much more efficient than calling git add once per file.
• Using the -print0 argument to find causes filenames to be separated by NULs (which, unlike newline literals, cannot possibly exist in filenames) in find 's output.
• Using the IFS= read -r -d '' file idiom (as described in BashFAQ #1 ) reads names from find in byte-for-byte literal form.
• Using array+=( "$value" ) is much, much easier than keeping an integer index counter and incrementing it between each append.

Answer 3

Please try

find . -type f -size -2M -print0 | xargs -0 git add
git commit -m 'Message here'

Answer 4

the one-line command from the first comment is good but if you still need a script in order to add some extra logic try to use this:

#!/bin/bash

root_dir="/home/myuser/myproject"
exclude_path="dirname_to_exclude"
max_size="-2048k"

for file in $(find $root_dir -type f -size $max_size | grep -v $exclude_path)
do
    git add $file
done

git commit -m "blablabla..."