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

This article mainly introduces how to create a local warehouse in Git, which has a certain reference value, and interested friends can refer to it. I hope you will gain a lot after reading this article.

Create a new project directory and generate some simple file contents:

$mkdir test_proj$ cd test_proj$ echo "hello,world" > readme.txt

Create a new local warehouse in the project directory, and add and submit all the files in the project to the local warehouse:

$git init # create a new empty local repository Initialized empty Git repository in / home/user/test_proj/.git/$ git add under the current directory. # add all files in the previous directory to the staging area $git commit-m 'project init' # create and submit [master (root-commit) b36a785] project init1 files changed, 1 insertions (+), 0 deletions (-) create mode 100644 readme.txt

The structure of Git directory

The git init command creates a directory called ".git" in the top-level directory of the project, and its alias is "Git directory" (Git directory). At this time, although there are some files in the Git directory, there are no commit in it, so we call it an empty warehouse (empty Git repository).

Unlike SVN, a Git project generally creates a ".git" directory under the root of the project, while SVN creates a ".svn" directory under each directory of the project; this is one of the reasons I like Git:)

Git stores all historical submissions in the "Git directory", which is a repository of Git projects; submissions created by editing and modifying your local source code are saved here, and then pushed to a remote server. When I copy the project directory and the "Git directory" to another computer, it works immediately (all the submission information is saved in the Git directory); you can even just copy the "Git directory", but check it out again.

Git can specify the location of the project's Git directory for debugging convenience. There are two ways: one is to set the "GIT_DIR" environment variable, and the other is to set the "--git-dir--git-dir" parameter on the command line to specify its location, you can take a look here (git (1) Manual Page).

dismember an ox as skillfully as a butcher

I also talked about some of the above in the article, but today we not only want to drive this sports car called "Git", but also want to see what kind of parts it has and how it is made up.

OK, let's look at the structure of the "Git directory" in the "test_proj" project:

$cd test_proj/.git$ ls | morebranches/ # the new version of Git no longer uses this directory, so you can see that it # is usually empty COMMIT_EDITMSG # holds the comment information from the last submission, config # project configuration information, description # project description information, HEAD # information about which branch the project is currently in, hooks/ # default "hooks" script file, index # index file Git add temporarily save the items to be added here info/ # there is an exclude file, specify the file # to be ignored in this project, take a look at the logs/ # historical information of each refs objects/ # this directory is very important, which stores Git data objects # including: commits, trees, binary object # (blobs), tag object (tags). # it doesn't matter if I don't understand. I'll talk about it later. Refs/ # identifies which commit each of your branches points to.

Let me first use the git log command to see which submissions are in this Git project:

$git logcommit 58b53cfe12a9625865159b6fcf2738b2f6774844Author: liuhui998Date: Sat Feb 19 18:10:08 2011 + 0800project init

You can see that there is currently only one commit object, and its name is "58b53cfe12a9625865159b6fcf2738b2f6774844". This name is a SHA signature string value of the content of the object. As long as the content in the object is different, we can assume that the name of the object will not be the same, and vice versa. When I use it, I usually don't have to type all 40 characters, just type the first 5 or 8 characters (as long as it doesn't conflict with other object names). For convenience, I will write only the first six characters of the SHA string value without affecting the expression.

We can use git cat-file to take a look at what is in this submission:

$git cat-file-p 58b53ctree 2bb9f0c9dc5caa1fb10f9e0ccbb3a7003c8a0e13author liuhui998 1298110208 + 0800committer liuhui998 1298110208 + 0800project init

You can see that submitting "58b53c" refers to a tree object named "2bb9f0" (tree). A tree object (tree) can refer to one or more binary objects (blob), each corresponding to a file. Further, tree objects can also refer to other tree objects, forming a directory hierarchy. Let's take another look at what's in this tree object (tree):

$git cat-file-p 2bb9f0100644 blob 2d832d9044c698081e59c322d5a2a459da546469 readme.txt

It is not difficult to see that the "2bb9f0" tree object (tree) includes a binary object (blob) that corresponds to the file we created earlier called "readme.txt". Now let's see if the data in this "blob" is consistent with the previous submission:

$git cat-file-p 2d832dhellodomain world

Haha, the familiar "hello,world" is back.

If you want to see how commit objects, tree objects, and binary objects are stored in the Git directory; no problem, execute the following command to see the contents of the .git / objects directory:

$find .git / objects.git/objects.git/objects/2b.git/objects/2b/b9f0c9dc5caa1fb10f9e0ccbb3a7003c8a0e13.git/objects/2d.git/objects/2d/832d9044c698081e59c322d5a2a459da546469.git/objects/58.git/objects/58/b53cfe12a9625865159b6fcf2738b2f6774844.git/objects/info.git/objects/pack

If you take a closer look at the bold type in the execution result of the above command, all objects are stored in the ".git / objects" directory using the SHA signature string value as the index; the first two characters of the SHA string are used as the directory name and the next 38 characters as the file name.

The contents of these files are actually compressed data plus a header of dimension type and length. The type can be a commit object (commit), a binary object (blob), a tree object (tree), or a label object (tag).

How to clone a remote project

Many of my friends started learning to use Git because they wanted to get code for an open source project. The general way to get the code of a project is to copy it directly with the git clone command.

For example, some friends may want to take a look at the linux kernel source code of * *. When we open its website, we find a prompt like the following:

URLgit://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git http://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.githttps://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git

The three lines of string below URL represent three addresses from which we can get the same copy of the Linux kernel source code.

This means that the following three commands end up with the same source code:

Git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.gitgit clone http://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.gitgit cone https://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git

Let's take a look at URL,git://, http://, https://, these are the protocol forms of the transport git repository, while "git.kernel.org" represents the server name (domain name) stored in the Git repository, and "/ pub/scm/linux/kernel/git/torvalds/linux-2.6.git" represents the location of the Git repository on the server.

Git warehouse can be transmitted not only through the above git, http, https protocols, but also through ssh, ftp (s), rsync and other protocols. The essence of git clone is to copy the contents of the "Git directory". Think about it. There are thousands of objects (commit objects, tree objects, binary objects) in the general "Git directory". If you copy them one by one, the efficiency can be imagined.

If transmitted through git and ssh protocols, the server will package all kinds of objects that need to be transmitted before transmission, while http (s) will repeatedly request different objects to be transmitted. If there are not many submissions in the warehouse, the efficiency of the former is not much different from that of the latter, but if there are many submissions in the warehouse, git and ssh protocols will be more efficient.

But now Git has optimized the Git warehouse for http (s) protocol transmission, and http (s) transmission can now achieve the efficiency of ssh protocol. Interested friends can take a look here (Smart HTTP Transport).

OK, now we have executed the following command to clone the source code of the * version of linux-2.6:

$cd ~ / $mkdir temp$git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.gitInitialized empty Git repository in / home/liuhui/temp/linux-2.6/.git/remote: Counting objects: 1889189, done.remote: Compressing objects: 100% (303141), done.Receiving objects: 100% (1889189 prime 1889189), 385.03 MiB | 1.64 MiB/s, done.remote: Total 1889189 (delta 1570491) Reused 1887756 (delta 1569178) Resolving deltas: 100% (1570491), done.Checking out files: 100% (35867), done.

When we execute the "git clone git://git.kernel.org/pub/scm/linux/kernel/git/torvalds/linux-2.6.git" command, you can see this output:

Initialized empty Git repository in / home/user/temp/linux-2.6/.git/

This means that we have created a "linux-2.6" directory locally, and then an empty Git local repository (Git directory) in this directory; history submissions pulled from the Internet will be stored in it.

The following two inputs represent that the server now calls git-pack-objects to package and compress its repository:

Remote: Counting objects: 1888686, done.remote: Compressing objects: 100% (302932 + 302932), done.

Then the client receives the data sent by the server:

Receiving objects: 100% (1889189 MiB), 385.03 MiB/s, done.

After we have executed the above clone linux-2.6 code, Git will checkout the * * code from the "Git directory" to the "linux-2.6" directory. We usually call the local "linux-2.6" directory "working directory" (work directory), which contains the code you clone (or checkout) from other places. When you switch between different branches of the project, the files in the "working directory" may be replaced or deleted; the "working directory" only saves the current work, and you can modify the contents of the files until the next submission.

Thank you for reading this article carefully. I hope the article "how to create a local warehouse in Git" shared by the editor will be helpful to you. At the same time, I also hope that you will support us and follow the industry information channel. More related knowledge is waiting for you to learn!

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.