Shulou(Shulou.com)06/02 Report--

Git engineering development practice (3)-- Git common operations 1, Git warehouse operations 1, Git warehouse creation

Git init

Initialize the Git repository in the current directory

Git init [project-name]

Create a new directory and initialize the repository

Initializing the git repository creates a mater branch by default and creates a subdirectory called .git, which contains all the backbone files in the initialized Git repository. At this time, the files in the repository have not been tracked.

Trace the specified file through the git add command, and then perform a git commit commit.

Git add. Git commit-m 'initial project version'

The directory of the .git repository is as follows:

A, HEAD: which branch are you currently in?

B, config: configuration information of the project

C, description: project description information

D, index: index file (staging area)

E, hooks/: system default hook script directory

Historical information of each refs of F and logs/:

G, all objects in objects/:git repository (commit,tree,blog,tag)

H and refs/: identify which commit each branch in the directory points to

2. Git warehouse cloning

Command format of Git clone repository: git clone [url]

When the git clone command is executed, every version of every file in the remote Git repository will be pulled by default. All local branches default to branches with the same name as the remote host and establish a tracking relationship.

The command to clone Git's linkable library libgit2 is as follows:

Git clone https://github.com/libgit2/libgit2

Create a directory called libgit2 under the current directory, initialize a .git directory under the directory, pull all data from the remote warehouse and put it into the .git directory, and then read a copy of the latest version of the file.

If you specify that the name of the locally created repository becomes libgit, you can use:

Git clone https://github.com/libgit2/libgit2 libgit

Git clone is a command that encapsulates other commands. Executing the git clone command will perform the following operations: create a new directory, change to a new directory, then git init to initialize an empty Git repository, then add a remote repository (git remote add) for the specified URL (default name is origin), execute git fetch against the remote warehouse, and finally check out the latest submission of the remote warehouse to the local working directory through git checkout.

Git clone supports four protocols, HTTP (S), SSH, Git, and Local File Protocol.

Git clone-o newname [url]

Specify the creation directory as newname when cloning the repository from url

II. Git file operation

1. Git file status

Untracked: not tracked, files in the working directory, but not added to the repository, do not participate in version control. Change the state to Staged through git add.

Unmodified: the file has been added to the version library and has not been modified, that is, the contents of the file snapshot in the version library are exactly the same as those in the working directory. If it is modified, it becomes Modified;. If you use git rm to move to publish this library, it becomes Untracked.

Modified: the file has been modified and nothing else has been done. You can enter the staging staged state through git add, and discard the changes using git checkout and return to the unmodified state. Git checkout takes the file out of the version library and overwrites the current modification.

Staged: temporary status. Executing git commit synchronizes the changes to the version library, where the files in the version library are the same as the local files, and the files are in a Unmodified state. Execute git reset HEAD filename to cancel temporary storage, and the file status is Modified.

The file status can be viewed using the following command:

Git status [filename]

View the specified file status

Git status

View the status of all files

2. Git add files and directories

Git add adds changes to the working directory to the staging area for next submission.

Git add [file1] [file2]...

Add the specified file to the staging area

Git add [dir]

Add the specified directory to the staging area, including subdirectories

Git add. Add new and modified files to the temporary storage area, but do not include deleted files git add-u submit modified and deleted files to the temporary storage area, excluding new files git add-An add all changes to the working directory to the temporary storage area 3, Git delete files and directories

Git rm-cached

Delete the file directly from the staging area, but leave the workspace unchanged

Git reset HEAD...

If you have added the file to the staging area with add, you need to undo it first.

When the git reset HEAD command is executed, the directory tree of the staging area is rewritten and replaced by the directory tree pointed to by the current branch, but the workspace is not affected.

Git clean [options]

Remove all untracked files,-d for containing directories, and-f for forced cleanup.

Git rm filename

Delete files in temporary storage area and working directory

4. Check the differences in Git files.

Git diff is used to view the differences between files in the working directory and files in the staging area

Git diff [files]

When there are no files in the staging area, compare the differences between the files in the workspace and the files last submitted to the version library; when there are files in the staging area, compare the differences between the files in the current workspace and the files in the staging area.

Git diff-cached

Compare the files in the temporary storage area with those that have already been submitted

Git diff HEAD~n

Compare the differences between a historical version and the files in the working directory

5. Git check out

Git checkout is used to check out the Git version library and rewrites the working directory, which is a dangerous command.

Git checkout branch

Check out the branch branch. Point the HEAD to the branch branch and update the staging area and working directory with the current directory tree of branch.

Git checkoutgit checkout HEAD

Displays the differences between the working directory, staging area, and HEAD.

Git checkout-filename

Overwrite the filename file in the working directory with the filename file in the staging area.

Git checkout.

Overwrite all files in the working directory with all files in the temporary storage area

Git checkout-filename

Overwrites the specified file in the working directory with the specified file in the temporary storage area

Git checkout HEAD.

Use HEAD to point to all files in the branch to overwrite files in the staging area and working directory

Git checkout HEAD

Use HEAD to point to the specified file in the branch to overwrite the file in the staging area and working directory

Git checkout branch-filename

Keep the point of HEAD unchanged, and overwrite the corresponding files in the staging area and workspace with the filename files in the submission pointed to by branch.

Git checkout commit_id-file_name

Keep the point of HEAD unchanged and use commit_id to overwrite the corresponding files in the staging area and workspace with the filename file in the submission.

6. Git submission

When the git commit command is executed, create a persistent snapshot of all the file contents of the staging area in the version library, and then move the HEAD pointer on the current branch to the newly created snapshot. Each commit generates a commit object, each commit object points to a tree object, and each tree object points to a folder or file.

Git commit-m [message]

Submit the temporary storage area to the local warehouse

Git commit [file1] [file2]...-m [message]

Submit the specified files of the temporary storage area to the local warehouse

Git commit-a

Submit changes to the workspace directly to the local warehouse, not valid for new files

Git commit-v

Show all diff information on submission

Git commit-- amend-m [message]

Revision submission, using a new commit to replace the previous submission. If there are no new changes in the code, it will be used to rewrite the submission information of the last commit

Git commit-- amend [file1] [file2]...

Redo the last commit and include new changes to the specified file

Git revert commit-id

Withdraw the specified version of the content and submit a new commit without affecting the previously submitted content

7. Git log view

You can use git log to view the submission log

Git log-graph

Graphically display the relationship of submission history

Git reflog

Record all update records for all branches in the warehouse, including updates that have been revoked.

Git log-pretty=oneline

Display all submission log information on a single line

Git log-n

Print the last n submission log information

8. Git file view

Git ls-files is used to view a list of files with a specified status

Git ls-files

View all cached files by default

Git ls-files-o

View files that are not being tracked

Git ls-files-modified

View modified files

Git ls-files-s

View the details of files in the staging area

9. Git stack storage

In the actual project development, a bug may need to be repaired urgently, but the work in the current working directory may not be completed and needs to be temporarily saved in order to clean up the working directory and switch to another branch for repair. At this point, you can use the stack storage function.

Git stash

Stack all files in the workspace into the storage area

Git stash-list

View a list of all the stash in the stack storage area

Git stash pop [stash_id]

Pop up the data at the top of the stack from the storage stack and restore it to the working directory. You can specify stash_id.

Git stash drop [stash_id]

To pop up and discard the data at the top of the storage stack, you can specify stash_id

Git stash apply [--index] [stash_id]

If the status of the workspace when executing git stash is that some files have been added to the temporary storage area and some files are not, when you execute git stash apply, you will find that all the files have not been temporarily stored. If you want to maintain the original temporary files, you can add the-- index parameter. You can specify stash_id.

Git stash clear

Delete all data in the storage stack

10. Git undoes the update

Git reset [options] commit_id

The git reset command is mainly used to perform undo operations based on the parameters passed to the action. Git reset will make the HEAD point to the specified commit_id. Generally, three parameters will be used, which will affect the changes in the workspace and the temporary storage area:

-- soft: only change the State of HEAD, not the contents of the workspace and staging area

-- mixed (default): undo the changes to the staging area, which will be transferred to the workspace

-- hard: undo changes to workspaces and staging areas

11. Delete Git files

Git rm-f filename

Delete fiename files in temporary storage area and working directory

Git rm-cached filename

Delete the filename file in the temporary storage area without modification in the working directory

For files with untracked status, you can delete them directly.

3. Git branch operation 1. Git branch view

Git branch

List all local branches

Git branch-r

List all remote branches

Git branch-a

List all local and remote branches

2. Git branch creation

Git branch [branch-name]

Create a new branch-name branch, but stay at the current branch

Git checkout-b [branch]

Create a new branch branch and switch to it

Git branch [branch] [commit_id]

Create a new branch and point to the specified commit_id submission

Git branch-- track [branch] [remote-branch]

Create a new branch and establish a tracking relationship with the remote branch

3. Git branch handoff

Git checkout [branch-name]

Switch to the specified branch and update the working directory

Git checkout-

Switch to the previous branch

Git branch-- set-upstream [branch] [remote-branch]

Establish a tracking relationship between an existing specified branch and a specified remote branch

4. Git branch merging

Git merge is used to merge one or more branches into the current branch, and then move the HEAD pointer over the submitted snapshot of the merge result.

Git merge branchname

Merge the branchname branch into the current branch

Git merge [remote/branch]

Merge the acquired remote branch to the current branch

Git merge-ff branch

Using fast forward (fast-forward) to merge branches does not produce a new merge commit snapshot, which is the default merge method.

Git merge-no-ff branch

Using a non-fast-forward merge creates a new merge submission snapshot

Fast-forward:

No-fast-forwar:

Git cherry-pick [commit]

Select a commit to merge into the current branch

5. Git conversion (derivative)

The current branch is then mywork, and when the origin branch is merged into the mywork branch using git merge, Git creates a new commit C7.

If you use git rebase to rebase the origin branch to the mywork branch, Git copies the current branch mywork branch from each commit after the bifurcation commit point (C2) to the origin branch and points the HEAD pointer to the latest commit point.

Git rebase [startpoint] [endpoint]

Raise × × multiple times from startpoint to endpoint and submit it once.

Git rebase-I HEAD~3

Raise × × for the last three times and submit it for one time.

Git rebase [startpoint] [endpoint]-- onto [branchName]

Copy the commit from [startpoint] to [endpoint] open and closed interval to the [branchName] branch

At this point, the current HEAD is free, and Git only copies and pastes a copy of the submission content of the master part and pastes it behind the submission pointed to by master. You need to set the submission id pointed to by master to the submission pointed to by the current HEAD.

Git reset-hard commit_id

Merge does not modify the submission history, rebase does. Rebase only applies to code that is not committed locally and cannot be used in remote branches. Get merge can be applied to remote branches.

6. Delete Git branch

Git branch- d [branch-name]

Delete local branch,-D (uppercase) force delete

Git push [remote]-- delete [branch-name] git push [remote]: remote-branchgit branch- dr [remote/branch]

Delete remote branch

4. Git remote warehouse operation

Git fetch [remote-name] [branch]

Gets the update of the specified branch in the warehouse, but does not automatically merge the current branch

Git fetch [remote-name]

Get all updates to the warehouse, but do not automatically merge the current branch

Git pull [remote] [remote-branch]: [local-branch]

Retrieve the update from a branch of the remote host and merge it with the specified branch locally

Git pull

Gets the only remote tracking branch of the current branch and automatically merges it into the current branch

Git pull [remote] [branch]

Retrieve the branch branch of the remote warehouse and merge it with the local current branch

Git pull [remote]

Gets the remote warehouse tracking branch of the current branch and merges it with the local current branch

Git pull-p

If the remote host deletes a branch, by default, git pull does not delete the corresponding local branch when pulling the remote branch. Use the parameter-p to delete remotely deleted branches locally.

Git remote-v

Show all remote warehouses

Git remote show [remote]

Display information about a remote warehouse

Git remote add [shortname] [url]

Add a new remote repository and name it

Git remote

Simply view all remote warehouses (only the name of the remote warehouse can be seen)

Git remote show [remote-branch-name]

View a single warehouse

Git remote add [branchname] [url]

Build a new remote warehouse

Git remote rename [oldname] [newname]

Modify remote warehouse

Git remote rm [remote-name]

Delete remote warehouse

Git push [remote] [local-branch]: [remote-branch] git push [remote] [local-branch]

Upload the tracking branch of the local specified branch to the remote warehouse, and if the remote branch does not exist, it will be created.

Git push [remote]-- force

Force the current branch to the remote warehouse, even if there is a conflict

Git push [remote]-- all

Push all branches to remote warehouse

Git push [remote]: [remote-branch]

Delete the specified remote branch of the remote warehouse, which is equivalent to:

Git push [remote]-- delete [remote-branch]

Welcome to subscribe "Shulou Technology Information " to get latest news, interesting things and hot topics in the IT industry, and controls the hottest and latest Internet news, technology news and IT industry trends.