Some useful commands with files and folders in Git

Delete operation
Rename operation
Move operation
Search operation
Undo operations
Wrapping up

Delete operation

Stop tracking a file from the staging area

 # with a file
 git rm --cached <file-path>

 # with a folder
 # -r option means recursive
 git rm -r --cached <folder-path>

Remove a file from the local repository
- First, we need to revert to the previous commit.
```
  git reset --soft HEAD^1
```
  So, our files that are in the staging area.
- Second, we will remove them from the staging area.
```
  git rm --cached <file-path>
```
  Now, our files appear in the untracking files section. Then, we will remove directly that file.
- Finally, commit the remaining files and push them to the remote repository.
```
  git commit -m "message"

  git push origin <branch-name>
```

Remove files that are not tracked by the staging area

 git clean -f

 # delete folder
 git clean -f -d

 # watch files before deleting
 git clean -n -f -d

Delete local’s all removed files in repository
```
 git rm $(git ls-files --deleted)
```

Remove a folder in the remote repository

 git rm -rf <folder-name>

 git commit -m "message"

 git push -f origin <branch-name>

Rename operation

# rename a file
git mv <file-name> <new-file-name>

Move operation

git mv <file-path> <folder-path>

Search operation

Search files’s name that is managed by Git
```
 git ls-files | grep <file-name>
```

Search files that contain words

 git grep <word-pattern>

 # accompany with the number of line
 git grep -n <word-pattern>

 # only list the files's name
 git grep -l <word-pattern>

 # list the amount of word's appearance
 git grep -c <word-pattern>

Search the user that remove a file
```
 # When a file was removed
 git log --diff-filter=D -- <file-path>

 # find the datetime and what's commit that file was deleted
 git log --diff-filter=D --summary -- <file-path>
```
The meaning of above options:
- –: It is used to notify Git that it’s not a branch or is an option of a command.
- –summary: list files that were deleted or added. We have another option with the similar functionality: –name-status.
- –diff-filter: specify the type of change a file. It has some values such as Added - A, Coppied - C, Modified - M, Renamed - R.

Search information of a file that was added

 git log --diff-filter=A --name-status | grep -C 10 <pattern>

Find information of user that has the last change for a line of a file
```
 git blame <file-path>
```
Search commits that removed or added a sequence of characters

Using **git log -S** or **git log -G**.
```
 git log -Sgoogle --diff-filter=M --patch
```
Search for commits by a particular author
```
 git log --author="<pattern>"
```
Search for commits with a commit message that matches <pattern>
```
 git log --grep="<pattern>"
```
Display commits that have the specified file
```
 git log -- <file-path>
```

Undo operation

Restore a file that does not add to the staging area

 # 1st way - use git checkout
 git checkout -- <file-path>

 # 2nd way - use git reset
 git reset 

Restore a file that is added to the staging area.

 # 1st way - using git restore
 git restore --staged <file-path>

 # 2nd way - using git reset in mixed mode
 # the local respority and the staging area will be reset, but the changes in working space are still remained
 git reset -- <file-path>

Restore a file that is pushed to the local/remote repository

Sometimes we push the changes of a files as the 2 commits to the local/remote repository. But now we want to revert this file to the previous state of the 2 commits.

 # commits of a file in the master of the local/remote repository
            HEAD (refers to branch 'master')
             |
             v
 a --- b --- c  branch 'master' (refers to commit 'c')

 # switch to the master branch
 git checkout master

 # reverts to two revision back
 git checkout master~2

 # delete file in the workspace
 rm -f <file-name>

 # restore <file-name> from the staging area
 git checkout <file-name>

 # push to the remote repository
 git push -f origin master

OR we can use the below way:

 git checkout master

 # In git, -- before the file tells git that all the next arguments should be interpreted as filenames,
 # not as branch-names or anything else.
 git checkout <commit-id> -- <file-name>

Wrapping up

To use above commands effectively, we need to think about what object that we cope with, and then action for it.

Refer:

https://dodangquan.blogspot.com/2017/11/tim-kiem-voi-git.html