Is there a way to use a command like git ls-files
to show only untracked files?
The reason I'm asking is because I use the following command to process all deleted files:
git ls-files -d | xargs git rm
I'd like something similar for untracked files:
git some-command --some-options | xargs git add
I was able to find the -o
option to git ls-files
, but this isn't what I want because it also shows ignored files. I was also able to come up with the following long and ugly command:
git status --porcelain | grep '^??' | cut -c4- | xargs git add
It seems like there's got to be a better command I can use here. And if there isn't, how do I cre开发者_StackOverflow社区ate custom git commands?
To list untracked files try:
git ls-files --others --exclude-standard
If you need to pipe the output to xargs
, it is wise to mind white spaces using git ls-files -z
and xargs -0
:
git ls-files -z -o --exclude-standard | xargs -0 git add
Nice alias for adding untracked files:
au = !git add $(git ls-files -o --exclude-standard)
Edit: For reference: git-ls-files
If you just want to remove untracked files, do this:
git clean -df
add x
to that if you want to also include specifically ignored files. I use git clean -dfx
a lot throughout the day.
You can create custom git by just writing a script called git-whatever
and having it in your path.
git add -A -n
will do what you want. -A
adds all untracked and modified files to the repo, -n
makes it a dry-run
where the add isn't performed but the status output is given listing each file that would have been added.
Everything is very simple
To get list of all untracked files use command git status with option -u (--untracked-files)
git status -u
The accepted answer crashes on filenames with space. I'm at this point not sure how to update the alias command, so I'll put the improved version here:
git ls-files -z -o --exclude-standard | xargs -0 git add
I know its an old question, but in terms of listing untracked files I thought I would add another one which also lists untracked folders:
You can used the git clean operation with -n (dry run) to show you which files it will remove (including the .gitignore files) by:
git clean -xdn
This has the advantage of showing all files and all folders that are not tracked. Parameters:
x
- Shows all untracked files (including ignored by git and others, like build output etc...)d
- show untracked directoriesn
- and most importantly! - dryrun, i.e. don't actually delete anything, just use the clean mechanism to display the results.
It can be a little bit unsafe to do it like this incase you forget the -n
. So I usually alias it in git config.
When looking for files to potentially add. The output from git show
does that but it also includes a lot of other stuff. The following command is useful to get the same list of files but without all of the other stuff.
git status --porcelain | grep "^?? " | sed -e 's/^[?]* //'
This is useful when combined in a pipeline to find files matching a specific pattern and then piping that to git add
.
git status --porcelain | grep "^?? " | sed -e 's/^[?]* //' | \
egrep "\.project$|\.settings$\.classfile$" | xargs -n1 git add
All previous answers which I checked would list the files to be committed, too.
Here is a simple and easy solution that only lists files which are not yet in the
repo and not subject to .gitignore
.
git status --porcelain | awk '/^\?\?/ { print $2; }'
or
git status --porcelain | grep -v '\?\?'
I think this will do the same thing as the original poster intended:
git add .
Adding some caveats:
- You have run
git status
and confirmed your local directories are clean - You have run
git diff
on each file reported ingit status
, and confirmed your changes are clean - Your changes are covered with automated unit testing
- Your changes are covered with automated integration testing
- You have run the integration tests through a debugger, verifying the new behavior by white box observing the new code in action
- You have run all linting / code convention rules and they pass
- You have run all unit tests and they pass
- You have run all local integration tests, and they pass
- You have deployed your changes to an app review environment and manually tested them end to end in isolation from other changes
- You have merged latest from main branch and re-run all automated unit and integration testing, fixing any merge conflicts and test failures
Now, my friend, you are ready to git add .
with impunity.
精彩评论