Git 源代码分析

最新推荐文章于 2024-05-12 20:16:51 发布
最新推荐文章于 2024-05-12 20:16:51 发布
阅读量8.9k 收藏 8
点赞数 4
分类专栏： Other

Git 源代码分析

from: http://www.molearning.com/?p=9

Git介绍

Git — The stupid content tracker, 傻瓜内容跟踪器。Linus 是这样给我们介绍 Git 的。

Git 是用于 Linux 内核开发的版本控制工具。与常用的版本控制工具 CVS, Subversion 等不同，它采用了分布式版本库的方式，不必服务器端软件支持，使源代码的发布和交流极其方便。 Git 的速度很快，这对于诸如 Linux kernel 这样的大项目来说自然很重要。 Git 最为出色的是它的合并跟踪（merge tracing）能力。

实际上内核开发团队决定开始开发和使用 Git 来作为内核开发的版本控制系统的时候，世界开源社群的反对声音不少，最大的理由是 Git 太艰涩难懂，从 Git 的内部工作机制来说，的确是这样。但是随着开发的深入，Git 的正常使用都由一些友好的脚本命令来执行，使 Git 变得非常好用，即使是用来管理我们自己的开发项目，Git 都是一个友好，有力的工具。现在，越来越多的著名项目采用 Git 来管理项目开发，例如：wine, U-boot 等，详情看http://www.kernel.org/git

 

Git架构

                    commit-tree
                     commit obj
                      +----+
                      |    |
                      |    |
                      V    V
                   +-----------+
                   | Object DB |
                   |  Backing  |
                   |   Store   |
                   +-----------+
                      ^
          write-tree  |     |
            tree obj  |     |
                      |     |  read-tree
                      |     |  tree obj
                            V
                   +-----------+
                   |   Index   |
                   |  "cache"  |
                   +-----------+
        update-index  ^
            blob obj  |     |
                      |     |
   checkout-index -u  |     |  checkout-index
            stat      |     |  blob obj
                            V
                   +-----------+
                   |  Working  |
                   | Directory |
                   +-----------+

git 使用“三大数据结构”来完成它的工作，当前工作目录、“index file”(index cache) 和 git仓库。 git commit 会将 index file 中的改变写到 git 仓库；git add 会将“当前工作目录”的改变写到“index file”；“commit -a”则会直接将“当前工作目录”的改动同时写到“index file”和“git仓库”。

将 Current working directory 记为 (1), 将 Index file 记为 (2), 将 Git repository 记为 (3), 他们之间的提交层次关系是 (1) -> (2) -> (3) 。git add 完成的是(1) -> (2)，git commit 完成的是(2) -> (3)，git commit -a 是两者的直接结合。从时间上看，可以认为(1)是最新的代码，(2)比较旧，(3)更旧。

git diff 得到的是从(2)到(1)的变化。git diff –cached 得到的是从(3)到(2)的变化。 git diff HEAD 得到的是从(3)到(1)的变化。

Git简单用法

转载自 http://roclinux.cn/?p=371 (需要注明作者，文章题名；另外，该段内容属于使用问题，因该移到其他页面。)

独立开发者的最大特点就是他们不需要和其他人来交换补丁，而且只在一个独立的固定的git仓库中工作。

下面这些命令将可以帮助你完成日常工作：

git-show-branch：可以显示你当前所在的分支以及提交记录。

git-log：显示提交日志

git-checkout或者git-branch：用于切换日志

git-add：用于将修改内容加入到index文件中

git-diff和git-status：用于显示开发者所做的修改

git-commit：用于提交当前修改到git仓库。

git-reset和git-checkout：用于撤销某些修改

git-merge：用于合并两个分支

git-rebase：用于维护topic分支（此处我也不太懂，等完成git学习后转过头来会关注此问题）

git-tag：用于标记标签。
1）获得帮助可以使用类似man git-****的命令格式：想获得关于commit命令的帮助，则man git-commit想获得关于pull命令的帮助，则man git-pull想获得关于merge命令的帮助，则man git-merge以此类推

2）任何人在使用git之前，都要提交简单的个人信息，以便git区分不同的提交者身份。

  1. git config –global user.name “your name”
  2. git config –global user.email yourname@example.com

3）想新开启一个项目，应该先建立一个目录，例如名为myproject，然后所有的项目开发内容都在此目录下进行。

  1. cd myproject
  2. git init
  3. git add .
  4. git commit //这个步骤会自动进入编辑状态，要求提交者输入有关本次提交的“开发信息”

至此，一个新项目就诞生了，第一个开发信息（开发日志）也随之诞生。

4）如果改进了项目源代码，并且到了开发者认为“应该再次记录开发信息”的时候，则提交“工作成果”。

  1. git commit -a //这是一个偷懒的命令，相当于git add .; git commit;

5）想检查到目前为止对源码都做了哪些修改（相对于本次工作刚开始之时）：

  1. git diff //这个命令只在git add之前使用有效。如果已经add了，那么此命令输出为空
  2. git diff –cached //这个命令在git add之后在git commit之前有效。
  3. git status //这个命令在git commit之前有效，表示都有哪些文件发生了改动

6）想查看自项目开启到现在的所有开发日志

  1. git log
  2. git log -p //会输出非常详细的日志内容，包括了每次都做了哪些源码的修改

7）开启一个试验分支(experimental)，如果分支开发成功则合并到主分支（master），否则放弃该试验分支。

  1. git branch experimental //创建一个试验分支，名称叫experimental
  2. git branch //显示当前都有哪些分支，其中标注*为当前所在分支
  3. git checkout experimental //转移到experimental分支

（省略数小时在此分支上的开发过程）…如果分支开发成功：

  1. git commit -a //在experimental分支改进完代码之后用commit在此分支中进行提交
  2. git checkout master //转移回master分支
  3. git merge experimental //经证实分支开发成功，将exerimental分支合并到主分支
  4. git commit -a //彻底完成此次分支合并，即提交master分支
  5. git branch -d experimental //因为experimental分支已提交，所以可安全删除此分支

如果分支开发失败：

  1. git checkout master
  2. git branch -D experimental //由于分支被证明失败，因此使用-D来放弃并删除该分支

8）随时查看图形化分支信息。

  1. gitk

9）当合作伙伴bob希望改进我（rocrocket）的工作成果，则：

  1. bob$git clone /home/rocrocket/project myrepo //此命令用于克隆我的工作到bob的myrepo目录下。请注意，此命令有可能会因为/home/rocrocket的目录权限问题而被拒绝，解决方法是chmod o+rx /home/rocrocket。

（省略bob数小时的开发过程）…

  1. bob$git commit -a //bob提交自己的改进成果到自己的git仓库中，并口头告知我（rocrocket）他已经完成了工作。

我如果非常非常信任bob的开发能力：

  1. cd /home/rocrocket/project
  2. git pull /home/bob/myrepo //pull命令的意思是从远端git仓库中取出(git-fetch)修改的代码，然后合并(git-merge)到我（rocrocket）的项目中去。读者要记住一个小技巧，那就是“git pull .”命令，它和git merge的功能是一样的，以后完全可以用git pull .来代替git merge哦！请注意，git-pull命令有可能会因为/home/bob的目录权限问题而被拒绝，解决方法是chmod o+rx /home/bob。

如果我不是很信任bob的开发能力：

  1. cd /home/rocrocket/project
  2. git fetch /home/bob/myrepo master:bobworks //此命令意思是提取出bob修改的代码内容，然后放到我（rocrocket）工作目录下的bobworks分支中。之所以要放到分支中，而不是master中，就是要我先仔仔细细看看bob的开发成果，如果我觉得满意，我再merge到master中，如果不满意，我完全可以直接git branch -D掉。
  3. git whatchanged -p master..bobworks //用来查看bob都做了什么
  4. git checkout master //切换到master分区
  5. git pull . bobworks //如果我检查了bob的工作后很满意，就可以用pull来将bobworks分支合并到我的项目中了
  6. git branch -D bobworks //如果我检查了bob的工作后很不满意，就可以用-D来放弃这个分支就可以了

过了几天，bob如果想继续帮助我开发，他需要先同步一下我这几天的工作成果，只要在其当初clone的myrepo目录下执行git pull即可：

  1. git pull //不用加任何参数，因为当初clone的时候，git已经记住了我（rocrocket）的工作目录，它会直接找到我的目录来取。

数据结构

GIT 核心数据结构有五个： object, blob, tree, commit,cache_entry。其中

  • object: 基类。
  • blob: 对应于一个文件。
  • tree: 对应于一个目录。 一个 tree 包含一个或多个 blob 和 tree。
  • commit: 对应于一个版本。 一个 commit 对象指向一个 tree 对象，该tree 对象对应于该版本的根目录。 一个 commit 对象指向一个父 commit 对象， 表示它是该父commit 的下一个版本，或指向多个父commit 对象，表示它由这些父 commit 合并得到。

Example

执行下面代码来创建一个测试目录

$ git init
$ echo ‘Hi,rocrocket’>file.txt
$ git add .
$ git commit -a -m “initial commit”

然后键入 `git log’ 得到

commit 241e0a4d2a5644f92737b7fba8b9eb19dcb0c345
Author: rocrocket <wupengchong@gmail.com>
Date:   Fri Sep 26 10:57:13 2008 +0800
initial commit

commit字符串后面的一大长串（共40位）十六进制数字是干什么用的？

这40位十六进制数是用来“标识一次commit”的名称。其实，这40位十六进制数是一个SHA1哈希数（Secure Hash Algorithm），它可以保证每次commit生成的名称都是唯一的且可以永远有效的。

 

  • $git cat-file -t 241e //cat-file命令中-t选项表示列出相应ID的对象类型；241e是刚才commit后得出的SHA1码

commit //可以看到此ID对应的对象类型为一次commit

然后介入 cat-file 命令

 $git cat-file commit 241e //此处的commit表示要查询的是一个对象类型为commit的对象，后面给出此对象的ID

 

 tree 9a327d5e3aa818b98ddaa7b5b369f5deb47dc9f6
 author rocrocket <wupengchong@gmail.com> 1222397833 +0800
 committer rocrocket <wupengchong@gmail.com> 1222397833 +0800

 

  • $ git ls-tree 9a327

100644 blob 7d4e0fa616551318405e8309817bcfecb7224cff file.txt
我们可以看到9a327这棵树上包括了一个file.txt文件，其ID为7d4e0f

 

  • $ git cat-file -t 7d4e0f

blob

  • $ git cat-file blob 7d4e0f

Hi,rocrocket
可以看到7d4e0f对应的对象的类型是blob，而其内容就是“Hi,rocrocket”

object

#ifndef OBJECT_H
#define OBJECT_H

struct object_list {
	struct object *item;
	struct object_list *next;
};

struct object {
	unsigned parsed : 1;
	unsigned used : 1;
	unsigned int flags;
	unsigned char sha1[20];
	const char *type;
	struct object_list *refs;
};

int nr_objs;
struct object **objs;

struct object *lookup_object(unsigned char *sha1);

void created_object(unsigned char *sha1, struct object *obj);

/** Returns the object, having parsed it to find out what it is. **/
struct object *parse_object(unsigned char *sha1);

void add_ref(struct object *refer, struct object *target);

void mark_reachable(struct object *obj, unsigned int mask);

#endif /* OBJECT_H */

 

blob

#ifndef BLOB_H
#define BLOB_H

#include "object.h"

extern const char *blob_type;

struct blob {
	struct object object;
};

struct blob *lookup_blob(unsigned char *sha1);

int parse_blob(struct blob *item);

#endif /* BLOB_H */

tree

#ifndef TREE_H
#define TREE_H

#include "object.h"

extern const char *tree_type;

struct tree_entry_list {
	struct tree_entry_list *next;
	unsigned directory : 1;
	unsigned executable : 1;
	char *name;
	union {
		struct tree *tree;
		struct blob *blob;
	} item;
};

struct tree {
	struct object object;
	unsigned has_full_path : 1;
	struct tree_entry_list *entries;
};

struct tree *lookup_tree(unsigned char *sha1);

int parse_tree(struct tree *tree);

#endif /* TREE_H */

commit

#ifndef COMMIT_H
#define COMMIT_H

#include "object.h"
#include "tree.h"

struct commit_list {
	struct commit *item;
	struct commit_list *next;
};

struct commit {
	struct object object;
	unsigned long date;
	struct commit_list *parents;
	struct tree *tree;
};

extern const char *commit_type;

struct commit *lookup_commit(unsigned char *sha1);

int parse_commit(struct commit *item);

void commit_list_insert(struct commit *item, struct commit_list **list_p);

void free_commit_list(struct commit_list *list);

void sort_by_date(struct commit_list **list);

/** Removes the first commit from a list sorted by date, and adds all
 * of its parents.
 **/
struct commit *pop_most_recent_commit(struct commit_list **list, 
				      unsigned int mark);

#endif /* COMMIT_H */

 

cache_entry

struct cache_entry {
	struct cache_time ce_ctime;
	struct cache_time ce_mtime;
	unsigned int ce_dev;
	unsigned int ce_ino;
	unsigned int ce_mode;
	unsigned int ce_uid;
	unsigned int ce_gid;
	unsigned int ce_size;
	unsigned char sha1[20]; //对应仓库中object的sha1
	unsigned short ce_flags;
	char name[0];  //对应working tree中文件的路径
};

重要函数

由于index cache对理解git工作原理起到至关重要的作用，这里主要分析与之相关的一些函数

 

cache中的全局变量

const char *sha1_file_directory = NULL;
struct cache_entry **active_cache = NULL;
unsigned int active_nr = 0, active_alloc = 0;

void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size)

void *map_sha1_file(const unsigned char *sha1, unsigned long *size)
{
	char *filename = sha1_file_name(sha1);
	int fd = open(filename, O_RDONLY);
	struct stat st;
	void *map;

	if (fd < 0) {
		perror(filename);
		return NULL;
	}
	if (fstat(fd, &st) < 0) {
		close(fd);  
		return NULL;
	}
	map = mmap(NULL, st.st_size, PROT_READ, MAP_PRIVATE, fd, 0);
	close(fd);
	if (-1 == (int)(long)map)
		return NULL;
	*size = st.st_size;
	return map;
}

void * unpack_sha1_file(void *map, unsigned long mapsize, char *type, unsigned long *size)
{
	int ret, bytes;
	z_stream stream;
	char buffer[8192];
	char *buf;

	/* Get the data stream */
	memset(&stream, 0, sizeof(stream));
	stream.next_in = map;
	stream.avail_in = mapsize;
	stream.next_out = buffer;
	stream.avail_out = sizeof(buffer);

	inflateInit(&stream);
	ret = inflate(&stream, 0);
	if (sscanf(buffer, "%10s %lu", type, size) != 2)
		return NULL;

	bytes = strlen(buffer) + 1;
	buf = malloc(*size);
	if (!buf)
		return NULL;

	memcpy(buf, buffer + bytes, stream.total_out - bytes);
	bytes = stream.total_out - bytes;
	if (bytes < *size && ret == Z_OK) {
		stream.next_out = buf + bytes;
		stream.avail_out = *size - bytes;
		while (inflate(&stream, Z_FINISH) == Z_OK)
			/* nothing */;
	}
	inflateEnd(&stream);
	return buf;
}

void * read_sha1_file(const unsigned char *sha1, char *type, unsigned long *size)
{
	unsigned long mapsize;
	void *map, *buf;

	map = map_sha1_file(sha1, &mapsize);
	if (map) {
		buf = unpack_sha1_file(map, mapsize, type, size);
		munmap(map, mapsize);
		return buf;
	}
	return NULL;
}

int write_sha1_file(char *buf, unsigned len, unsigned char *returnsha1)

int write_sha1_file(char *buf, unsigned len, unsigned char *returnsha1)
{
	int size;
	char *compressed;
	z_stream stream;
	unsigned char sha1[20];
	SHA_CTX c;

	/* Set it up */
	memset(&stream, 0, sizeof(stream));
	deflateInit(&stream, Z_BEST_COMPRESSION);
	size = deflateBound(&stream, len);
	compressed = malloc(size);

	/* Compress it */
	stream.next_in = buf;
	stream.avail_in = len;
	stream.next_out = compressed;
	stream.avail_out = size;
	while (deflate(&stream, Z_FINISH) == Z_OK)
		/* nothing */;
	deflateEnd(&stream);
	size = stream.total_out;

	/* Sha1.. */
	SHA1_Init(&c);
	SHA1_Update(&c, compressed, size);
	SHA1_Final(sha1, &c);

	if (write_sha1_buffer(sha1, compressed, size) < 0)
		return -1;
	if (returnsha1)
		memcpy(returnsha1, sha1, 20);
	return 0;
}

int write_sha1_buffer(const unsigned char *sha1, void *buf, unsigned int size)
{
	char *filename = sha1_file_name(sha1);
	int fd;

	fd = open(filename, O_WRONLY | O_CREAT | O_EXCL, 0666);
	if (fd < 0)
		return (errno == EEXIST) ? 0 : -1;
	write(fd, buf, size);
	close(fd);
	return 0;
}

int add_cache_entry(struct cache_entry *ce, int ok_to_add)

int cache_name_pos(const char *name, int namelen)
{
	int first, last;

	first = 0;
	last = active_nr;
	while (last > first) {
		int next = (last + first) >> 1;
		struct cache_entry *ce = active_cache[next];
		int cmp = cache_name_compare(name, namelen, ce->name, ce->namelen);
		if (!cmp)
			return next;
		if (cmp < 0) {
			last = next;
			continue;
		}
		first = next+1;
	}
	return -first-1;
}

int add_cache_entry(struct cache_entry *ce, int ok_to_add)
{
	int pos;

	pos = cache_name_pos(ce->name, ce->namelen);

	/* existing match? Just replace it */
	if (pos >= 0) {
		active_cache[pos] = ce;
		return 0;
	}
	pos = -pos-1;

	if (!ok_to_add)
		return -1;

	/* Make sure the array is big enough .. */
	if (active_nr == active_alloc) {
		active_alloc = alloc_nr(active_alloc);
		active_cache = realloc(active_cache, active_alloc * sizeof(struct cache_entry *));
	}

	/* Add it in.. */
	active_nr++;
	if (active_nr > pos)
		memmove(active_cache + pos + 1, active_cache + pos, (active_nr - pos - 1) * sizeof(ce));
	active_cache[pos] = ce;
	return 0;
}

 

 

工作流程

1) working directory -> index

You update the index with information from the working directory withthe gitlink:git-update-index command. Yougenerally update the index information by just specifying the filenameyou want to update, like so:

git-update-index filename

2) index -> object database

You write your current index file to a “tree” object with the program

git-write-tree
that doesn’t come with any options – it will just write out thecurrent index into the set of tree objects that describe that state,and it will return the name of the resulting top-level tree. You canuse that tree to re-generate the index at any time by going in theother direction
3) object database -> index

You read a “tree” file from the object database, and use that topopulate (and overwrite – don’t do this if your index contains anyunsaved state that you might want to restore later!) your currentindex. Normal operation is just

git-read-tree <sha1 of tree>
and your index file will now be equivalent to the tree that you savedearlier. However, that is only your ‘index’ file: your workingdirectory contents have not been modified.
4) index -> working directory

You update your working directory from the index by “checking out”files. This is not a very common operation, since normally you’d justkeep your files updated, and rather than write to your workingdirectory, you’d tell the index files about the changes in yourworking directory (i.e. `git-update-index`).

However, if you decide to jump to a new version, or check out somebodyelse’s version, or just restore a previous tree, you’d populate yourindex file with read-tree, and then you need to check out the resultwith

git-checkout-index filename
or, if you want to check out all of the index, use `-a`.
5) Tying it all together

To commit a tree you have instantiated with “git-write-tree”, you’dcreate a “commit” object that refers to that tree and the historybehind it – most notably the “parent” commits that preceded it inhistory.

You create a commit object by giving it the tree that describes thestate at the time of the commit, and a list of parents:

git-commit-tree <tree> -p <parent> [-p <parent2> ..]

6) Examining the data

You can examine the data represented in the object database and theindex with various helper tools. For every object, you can usegitlink:git-cat-file[1] to examine details about theobject:

git-cat-file -t <objectname>
shows the type of the object, and once you have the type (which isusually implicit in where you find the object), you can use
git-cat-file blob|tree|commit|tag <objectname>

7) Merging multiple trees

To get the “base” for the merge, you first look up the common parentof two commits with

git-merge-base <commit1> <commit2>
which will return you the commit they are both based on.To do the merge, do
git-read-tree -m -u <origtree> <yourtree> <targettree>
which will do all trivial merge operations for you directly in theindex file, and you can just write the result out with
git-write-tree
 

 

脚本分析

git-merge-one-file-script

#!/bin/sh
#
# This is the git merge script, called with
#
#   $1 - original file SHA1 (or empty)
#   $2 - file in branch1 SHA1 (or empty)
#   $3 - file in branch2 SHA1 (or empty)
#   $4 - pathname in repository
#
#
# Handle some trivial cases.. The _really_ trivial cases have
# been handled already by read-tree, but that one doesn't
# do any merges that migth change the tree layout
#

# if the directory is newly added in a branch, it might not exist
# in the current tree
dir=$(dirname "$4")
mkdir -p "$dir"

case "${1:-.}${2:-.}${3:-.}" in
#
# deleted in both
#
"$1..")
	echo "ERROR: $4 is removed in both branches"
	echo "ERROR: This is a potential rename conflict"
	exit 1;;
#
# deleted in one and unchanged in the other
#
"$1.." | "$1.$1" | "$1$1.")
	rm -f -- "$4"
	echo "Removing $4"
	git-update-cache --remove -- "$4"
	exit 0
	;;

#
# added in one
#
".$2." | "..$3" )
	echo "Adding $4 with perm $6$7"
	mv $(unpack-file "$2$3") $4
	chmod "$6$7" $4
	git-update-cache --add -- $4
	exit 0
	;;
#
# Added in both (check for same permissions)
#
".$2$2")
	if [ "$6" != "$7" ]; then
		echo "ERROR: File $4 added in both branches, permissions conflict $6->$7"
		exit 1
	fi
	echo "Adding $4 with perm $6"
	mv $(unpack-file "$2") $4
	chmod "$6" $4
	git-update-cache --add -- $4
	exit 0;;
#
# Modified in both, but differently ;(
#
"$1$2$3")
	echo "Auto-merging $4"
	orig=$(git-unpack-file $1)
	src1=$(git-unpack-file $2)
	src2=$(git-unpack-file $3)
	merge "$src2" "$orig" "$src1"
	ret=$?
	if [ "$6" != "$7" ]; then
		echo "ERROR: Permissions $5->$6->$7 don't match merging $src2"
		if [ $ret -ne 0 ]; then
			echo "ERROR: Leaving conflict merge in $src2"
		fi
		exit 1
	fi
	chmod -- "$6" "$src2"
	if [ $ret -ne 0 ]; then
		echo "ERROR: Leaving conflict merge in $src2"
		exit 1
	fi
	cp -- "$src2" "$4" && chmod -- "$6" "$4" &&  git-update-cache --add -- "$4" && exit 0
	;;

*)
	echo "Not handling case $1 -> $2 -> $3"
	;;
esac
exit 1

git-pull-script

#!/bin/sh
#
# use "$1" or something in a real script, this 
# just hard-codes it.
#
merge_repo=$1

rm -f .git/MERGE_HEAD .git/ORIG_HEAD
cp .git/HEAD .git/ORIG_HEAD

echo "Getting object database"
rsync -avz --ignore-existing $merge_repo/objects/. ${SHA1_FILE_DIRECTORY:-.git/objects}/.

echo "Getting remote head"
rsync -L $merge_repo/HEAD .git/MERGE_HEAD || exit 1

head=$(cat .git/HEAD)
merge_head=$(cat .git/MERGE_HEAD)
common=$(git-merge-base $head $merge_head)
if [ -z "$common" ]; then
	echo "Unable to find common commit between" $merge_head $head
	exit 1
fi

# Get the trees associated with those commits
common_tree=$(git-cat-file commit $common | sed 's/tree //;q')
head_tree=$(git-cat-file commit $head | sed 's/tree //;q')
merge_tree=$(git-cat-file commit $merge_head | sed 's/tree //;q')

if [ "$common" == "$merge_head" ]; then
	echo "Already up-to-date. Yeeah!"
	exit 0
fi
if [ "$common" == "$head" ]; then
	echo "Updating from $head to $merge_head."
	echo "Destroying all noncommitted data!"
	echo "Kill me within 3 seconds.."
	sleep 3
	git-read-tree -m $merge_tree && git-checkout-cache -f -a && git-update-cache --refresh
	echo $merge_head > .git/HEAD
	exit 0
fi
echo "Trying to merge $merge_head into $head"
git-read-tree -m $common_tree $head_tree $merge_tree
merge_msg="Merge of $merge_repo"
result_tree=$(git-write-tree  2> /dev/null)
if [ $? -ne 0 ]; then
	echo "Simple merge failed, trying Automatic merge"
	git-merge-cache git-merge-one-file-script -a
	merge_msg="Automatic merge of $merge_repo"
	result_tree=$(git-write-tree) || exit 1
fi
result_commit=$(echo "$merge_msg" | git-commit-tree $result_tree -p $head -p $merge_head)
echo "Committed merge $result_commit"
echo $result_commit > .git/HEAD
git-checkout-cache -f -a && git-update-cache --refresh







1. Git概念 
1.1. Git库中由三部分组成 
       Git 仓库就是那个.git 目录，其中存放的是我们所提交的文档索引内容，Git 可基于文档索引内容对其所管理的文档进行内容追踪，从而实现文档的版本控制。.git目录位于工作目录内。 
1） 工作目录：用户本地的目录； 
2） Index（索引）：将工作目录下所有文件（包含子目录）生成快照，存放到一个临时的存储区域，Git 称该区域为索引。 
3） 仓库：将索引通过commit命令提交至仓库中，每一次提交都意味着版本在进行一次更新。 
clip_image002 
1.2. 使用Git时的初始化事项 
1.2.1. Git初始化配置 
1） 配置使用git仓库的人员姓名 
       git config --global user.name "Your Name Comes Here" 
2） 配置使用git仓库的人员email 
       git config --global user.email you@yourdomain.example.com 
1.2.2. Git文档忽略机制 
工作目录中有一些文件是不希望接受Git 管理的，譬如程序编译时生成的中间文件等等。Git 提供了文档忽略机制，可以将工作目录中不希望接受Git 管理的文档信息写到同一目录下的.gitignore 文件中。 
例如：工作目录下有个zh目录，如果不想把它加入到Git管理中，则执行： 
       echo “zh” &gt; .gitignore 
       git add . 
有关gitignore 文件的诸多细节知识可阅读其使用手册：man gitignore 
1.3. Git与Repo的比较 
       Git操作一般对应一个仓库，而Repo操作一般对应一个项目，即一个项目会由若干仓库组成。 
例如，在操作整个Recket项目时使用Repo，而操作其中的某个仓库时使用Git。在包含隐藏目录.git的目录下执行git操作。
2. Git help 
       Git help 获取git基本命令 
（如果要知道某个特定命令的使用方法，例如：使用Git help clone，来获取git clone的使用方法）
3. Git本地操作基本命令 
3.1. Git init 
或者使用git init-db。 
创建一个空的Git库。在当前目录中产生一个.git 的子目录。以后，所有的文件变化信息都会保存到这个目录下，而不像CVS那样，会在每个目录和子目录下都创建一个CVS目录。 
在.git目录下有一个config文件，可以修改其中的配置信息。 
3.2. Git add 
将当前工作目录中更改或者新增的文件加入到Git的索引中，加入到Git的索引中就表示记入了版本历史中，这也是提交之前所需要执行的一步。 
可以递归添加，即如果后面跟的是一个目录作为参数，则会递归添加整个目录中的所有子目录和文件。例如： 
       git add dir1 （ 添加dir1这个目录，目录下的所有文件都被加入 ） 
       Git add f1 f2 （ 添加f1，f2文件） 
       git add .      ( 添加当前目录下的所有文件和子目录 ) 
3.3. Git rm 
从当前的工作目录中和索引中删除文件。 
可以递归删除，即如果后面跟的是一个目录做为参数，则会递归删除整个目录中的所有子目录和文件。例如： 
       git rm –r * （进入某个目录中，执行此语句，会删除该目录下的所有文件和子目录） 
       git rm f1    (删除文件f1，包含本地目录和index中的此文件记录) 
       git rm --ached f1 (删除文件f1，不会删除本地目录文件，只删除index中的文件记录；将已经git add的文件remove到cache中,这样commit的时候不会提交这个文件, 适用于一下子添加了很多文件, 却又想排除其中个别几个文件的情况.) 
3.4. Git commit 
提交当前工作目录的修改内容。 
直接调用git commit命令，会提示填写注释。通过如下方式在命令行就填写提交注释：git commit -m "Initial commit of gittutor reposistory"。 注意，和CVS不同，git的提交注释必须不能为空，否则就会提交失败。 
       git commit还有一个 -a的参数，可以将那些没有通过git add标识的变化一并强行提交，但是不建议使用这种方式。 
每一次提交，git就会为全局代码建立一个唯一的commit标识代码，用户可以通过git reset命令恢复到任意一次提交时的代码。 
       git commit –-amend –m “message” （在一个commit id上不断修改提交的内容） 
3.5. Git status 
查看版本库的状态。可以得知哪些文件发生了变化，哪些文件还没有添加到git库中等等。 建议每次commit前都要通过该命令确认库状态。 
最常见的误操作是， 修改了一个文件， 没有调用git add通知git库该文件已经发生了变化就直接调用commit操作， 从而导致该文件并没有真正的提交。这时如果开发者以为已经提交了该文件，就继续修改甚至删除这个文件，那么修改的内容就没有通过版本管理起来。如果每次在 提交前，使用git status查看一下，就可以发现这种错误。因此，如果调用了git status命令，一定要格外注意那些提示为 “Changed but not updated:”的文件。 这些文件都是与上次commit相比发生了变化，但是却没有通过git add标识的文件。 
3.6. Git log 
查看历史日志，包含每次的版本变化。每次版本变化对应一个commit id。 
       Git log -1 
       -1的意思是只显示一个commit，如果想显示5个，就-5。不指定的话，git log会从该commit一直往后显示。 
       Git log --stat –summary （显示每次版本的详细变化） 
在项目日志信息中，每条日志的首行（就是那一串字符）为版本更新提交所进行的命名，我们可以将该命名理解为项目版本号。项目版本号应该是唯一的，默认由 Git 自动生成，用以标示项目的某一次更新。如果我们将项目版本号用作git-show 命令的参数，即可查看该次项目版本的更新细节。例如： 
1) Git log 
clip_image004 
2）Git show 
clip_image006 
实际上，上述命令并非是真正的进行版本号自定义，只是制造了一个tag对象而已，这在进行项目版本对外发布时比较有用。 
3.7. Git merge 
把服务器上下载下来的代码和本地代码合并。或者进行分支合并。 
例如：当前在master分支上，若想将分支dev上的合并到master上，则git merge dev 
注意：git merge nov/eclair_eocket （是将服务器git库的eclair_eocket分支合并到本地分支上） 
       git rebase nov/eclair_eocket （是将服务器git库的eclair_eocket分支映射到本地的一个临时分支上，然后将本地分支上的变化合并到这个临时分支，然后再用这个临时分支初始化本地分支） 
3.8. Git diff 
把本地的代码和index中的代码进行比较，或者是把index中的代码和本地仓库中的代码进行比较。 
1） Git diff 
比较工作目录和Index中的代码。 
2） Git diff - - cached 
比较index和本地仓库中的代码。 
3.9. Git checkout 
3.9.1. 切换到分支 
1) 创建一个新分支，并切换到该分支上 
       Git checkout –b 新分支名 
2）切换到某个已经建立的本地分支local_branch 
       Git checkout local_branch 
（使用cat .git/HEAD后，显示refs:refs/heads/ local_branch） 
3) 切换到服务器上的某个分支remote_branch 
       Git checkout remote_branch 
（远程分支remote_branch可以通过 git branch –r 列出） 
4) 切换到某个commit id 
       Git checkout commit_id 
（使用cat .git/HEAD后，显示commit_id） 
5) 切换到某个tag 
       Git checkout tag 
（使用cat .git/HEAD后，显示tag） 
注意： 除了1）和2）外，其余三种都只是切换到了一个临时的( no branch )状态 （this head is detached），这时用 git branch 可以看到处于（no branch）上， cat .git/HEAD 看到指向相应的commit id。 这个（no branch）只是临时存在的，并不是一个真正建立的branch。 如果此时执行2），则这个（no branch）就自动消失了；如果执行1）， 则创建新分支 new branch，并把这个(no branch)挂到这个新分支上，此时cat .git/refs/heads/new_branch 可以看到已经指向了刚才那个commit id。 
3.9.2. 用已有分支初始化新分支 
执行下面的命令，在切换到某个已经建立的local branch或者某个remote branch或者某个commit id 或者某个tag的同时，创建新分支new_branch，并且挂到这个新分支上。 
1） 切换到某个已经建立的本地分支local_branch，并且使用此分支初始化一个新分支new_branch。 
       git checkout –b new_branch local_branch 
2) 切换到某个远程分支remote_branch，并且用此分支初始化一个新分支new_branch。 
       Git checkout –b new_branch remote_branch 
3) 切换到某个commit id，并建立新分支new_branch 
       Git checkout –b new_branch commit_id 
4) 切换到某个tag，并建立新分支new_branch 
       Git checkout –b new_branch tag 
3.9.3. 还原代码 
例如 “git checkout app/model/user.rb” 就会将user.rb文件从上一个已提交的版本中更新回来，未提交的工作目录中的内容全部会被覆盖。
3.10. Git-ls-files 
查看当前的git库中有那些文件。 
3.11. Git mv 
重命名一个文件、目录或者链接。 
例如：Git mv helloworld.c helloworld1.c （把文件helloworld.c 重命名为 helloworld1.c） 
3.12. Git branch 
3.12.1. 总述 
在 git 版本库中创建分支的成本几乎为零，所以，不必吝啬多创建几个分支。当第一次执行git init时，系统就会创建一个名为“master”的分支。 而其它分支则通过手工创建。 
下面列举一些常见的分支策略： 
创建一个属于自己的个人工作分支，以避免对主分支 master 造成太多的干扰，也方便与他人交流协作； 
当进行高风险的工作时，创建一个试验性的分支； 
合并别人的工作的时候，最好是创建一个临时的分支用来合并，合并完成后再“fetch”到自己的分支。 
对分支进行增、删、查等操作。 
注意：分支信息一般在.git/refs/目录下，其中heads目录下为本地分支，remotes为对应服务器上的分支，tags为标签。 
3.12.2. 查看分支 
       git branch 列出本地git库中的所有分支。在列出的分支中，若分支名前有*，则表示此分支为当前分支。 
       git branch –r 列出服务器git库的所有分支。 
（可以继续使用命令 “ git checkout -b 本地分支名 服务器分支名”来获取服务器上某个分支的代码文件）。 
3.12.3. 查看当前在哪个分支上 
       cat .git/HEAD 
3.12.4. 创建一个分支 
1） git branch 分支名 
虽然创建了分支，但是不会将当前工作分支切换到新创建的分支上，因此，还需要命令“git checkout 分支名” 来切换， 
2） git checout –b 分支名 
不但创建了分支，还将当前工作分支切换到了该分支上。 
3.12.5. 切换到某个分支：git checkout 分支名 
切换到主分支：git checkout master 
3.12.6. 删除分支 
       git branch –D 分支名 
注意： 删除后，发生在该分支的所有变化都无法恢复。强制删除此分支。 
3.12.7. 比较两个分支上的文件的区别 
       git diff master 分支名 （比较主分支和另一个分支的区别） 
3.12.8. 查看分支历史 
       git-show-branch （查看当前分支的提交注释及信息） 
       git-show-branch -all（查看所有分支的提交注释及信息）例如： 
* [dev] d2 
! [master] m2 
-- 
* [dev] d2 
* [dev^] d1 
* [dev~2] d0 
*+ [master] m2 
在上述例子中， “--”之上的两行表示有两个分支dev和master， 且dev分支上最后一次提交的日志是“d2”,master分支上最后一次提交的日志是 “m2”。 “--”之下的几行表示了分支演化的历史，其中 dev表示发生在dev分支上的最后一次提交，dev^表示发生在dev分支上的倒数第二次提交。dev~2表示发生在dev分支上的倒数第三次提交。 
3.12.9. 查看当前分支的操作记录 
       git whatchanged 
3.12.10. 合并分支 
法一： 
       git merge “注释” 合并的目标分支 合并的来源分支 
如果合并有冲突，git会有提示。 
例如：git checkout master   （切换到master分支） 
       git merge HEAD dev~2 (合并master分支和dev~2分支)或者：git merge master dev~2 
法二： 
       git pull 合并的目标分支 合并的来源分支 
例如: git checkout master （切换到master分支） 
       git pull . dev~2（合并当前分支和dev~2分支） 
3.13. Git rebase 
一般在将服务器最新内容合并到本地时使用，例如：在版本C时从服务器上获取内容到本地，修改了本地内容，此时想把本地修改的内容提交到服务器上；但发现服务器上的版本已经变为G了，此时就需要先执行Git rebase，将服务器上的最新版本合并到本地。例如： 
用下面两幅图解释会比较清楚一些，rebase命令执行后，实际上是将分支点从C移到了G，这样分支也就具有了从C到G的功能。 
clip_image002[6] 
3.14. Git reset 
库的逆转与恢复除了用来进行一些废弃的研发代码的重置外，还有一个重要的作用。比如我们从远程clone了一个代码库，在本地开发后，准备提交回远程。但是本地代码库在开发时，有功能性的commit，也有出于备份目的的commit等等。总之，commit的日志中有大量无用log，我们并不想把这些 log在提交回远程时也提交到库中。 因此，就要用到git reset。 
       git reset的概念比较复杂。它的命令形式：git reset [--mixed | --soft | --hard] [<commit-ish>] 
命令的选项： 
       --mixed 这个是默认的选项。如git reset [--mixed] dev^(dev^的定义可以参见2.6.5)。它的作用仅是重置分支状态到dev1^, 但是却不改变任何工作文件的内容。即，从dev1^到dev1的所有文件变化都保留了，但是dev1^到dev1之间的所有commit日志都被清除了， 而且，发生变化的文件内容也没有通过git add标识，如果您要重新commit，还需要对变化的文件做一次git add。 这样，commit后，就得到了一份非常干净的提交记录。 （回退了index和仓库中的内容） 
       --soft相当于做了git reset –mixed，后，又对变化的文件做了git add。如果用了该选项， 就可以直接commit了。（回退了仓库中的内容） 
       --hard这个命令就会导致所有信息的回退， 包括文件内容。 一般只有在重置废弃代码时，才用它。 执行后，文件内容也无法恢复回来了。（回退了工作目录、index和仓库中的内容） 
例如： 
切换到使用的分支上； 
       git reset HEAD^ 回退第一个记录 
       git reset HEAD~2 回退第二个记录 
如果想把工作目录下的文件也回退，则使用git reset - - hard HEAD^ 回退第一个记录 
       git reset - - hard HEAD~2 回退第二个记录 
还可以使用如下方法： 
将当前的工作目录完全回滚到指定的版本号，假设如下图，我们有A-G五次提交的版本，其中C的版本号是 bbaf6fb5060b4875b18ff9ff637ce118256d6f20，我们执行了'git reset bbaf6fb5060b4875b18ff9ff637ce118256d6f20'那么结果就只剩下了A-C三个提交的版本 
clip_image004[5] 
3.15. Git revert 
还原某次对版本的修改，例如：git revert commit_id （其中commit_id为commit代码时生成的一个唯一表示的字符串） 
例如：（3.6中）git revert dfb02e6e4f2f7b573337763e5c0013802e392818 （执行此操作，则还原上一次commit的操作） 
3.16. Git config 
利用这个命令可以新增、更改Git的各种设置，例如 “git config branch.master.remote origin” 就将master的远程版本库设置为别名叫做origin版本库。 
3.17. Git show 
显示对象的不同类型。 
3.18. Git tag 
创建、列出、删除或者验证一个标签对象（使用GPG签名的）。 
可以将某个具体的版本打上一个标签，这样就不需要记忆复杂的版本号哈希值字符串了，例如你可以使用 “git tag revert_version bbaf6fb5060b4875b18ff9ff637ce118256d6f20” 来标记这个被你还原的版本，那么以后你想查看该版本时，就可以使用 revert_version标签名，而不是哈希值了。
4. Git服务器操作命令（与服务器交互） 
4.1. Git clone 
取出服务器的仓库的代码到本地建立的目录中（与服务器交互） 
通过git clone获取远端git库后，.git/config中的开发者信息不会被一起clone过来。仍然需要为本地库的.git/config文件添加开发者信息。此外，开发者还需要自己添加   . gitignore文件。 
通过git clone获取的远端git库，只包含了远端git库的当前工作分支。如果想获取其它分支信息，需要使用 “git branch –r” 来查看， 如果需要将远程的其它分支代码也获取过来，可以使用命令 “ git checkout -b 本地分支名 远程分支名”，其中，远程分支名为 “git branch –r” 所列出的分支名， 一般是诸如“origin/分支名”的样子。如果本地分支名已经存在， 则不需要“-b”参数。 
例如： 
clip_image006[5] 
4.2. Git pull 
从服务器的仓库中获取代码，和本地代码合并。（与服务器交互，从服务器上下载最新代码，等同于： Git fetch + Git merge） 
从其它的版本库（既可以是远程的也可以是本地的）将代码更新到本地，例如：“git pull origin master ”就是将origin这个版本库的代码更新到本地的master主分支。 
       git pull可以从任意一个git库获取某个分支的内容。用法如下： 
git pull username@ipaddr:远端repository名远端分支名 本地分支名。这条命令将从远端git库的远端分支名获取到本地git库的一个本地分支中。其中，如果不写本地分支名，则默认pull到本地当前分支。 
需要注意的是，git pull也可以用来合并分支。 和git merge的作用相同。 因此，如果你的本地分支已经有内容，则git pull会合并这些文件，如果有冲突会报警。 
例如： 
clip_image008
clip_image010
clip_image012
clip_image014 
4.3. Git push 
将本地commit的代码更新到远程版本库中，例如 “git push origin”就会将本地的代码更新到名为orgin的远程版本库中。 
       git push和git pull正好想反，是将本地某个分支的内容提交到远端某个分支上。用法： git pushusername@ipaddr:远端repository名本地分支名 远端分支名。这条命令将本地git库的一个本地分支push到远端git库的远端分支名中。 
需要格外注意的是，git push好像不会自动合并文件。因此，如果git push时，发生了冲突，就会被后push的文件内容强行覆盖，而且没有什么提示。 这在合作开发时是很危险的事情。 
例如： 
clip_image016 
4.4. Git fetch 
从服务器的仓库中下载代码。（与服务器交互，从服务器上下载最新代码） 
相当于从远程获取最新版本到本地，不会自动merge，比Git pull更安全些。 
使用此方法来获取服务器上的更新。 
例如：如果使用git checkout nov/eclair_rocket （nov/eclair_rocket为服务器上的分支名），则是获取上次使用git fetch命令时从服务器上下载的代码；如果先使用 git fetch ，再使用git checkout nov/eclair_rocket，则是先从服务器上获取最新的更新信息，然后从服务器上下载最新的代码。
conceptcon
关注
  • 4
    点赞
  • 踩
  • 8
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
专栏目录
Git使用详细教程
weixin_30663391的博客
11-25 1万+
　一：Git是什么？ 　　Git是目前世界上最先进的分布式版本控制系统。 　　二：SVN与Git的最主要的区别？ 　　SVN是集中式版本控制系统，版本库是集中放在中央服务器的，而干活的时候，用的都是自己的电脑，所以首先要从中央服务器哪里得到最新的版本，然后干活，干完后，需要把自己做完的活推送到中央服务器。集中式版本控制系统是必须联网才能工作，如果在局域网还可以，带宽够大，速度够快，如果在互联...
github上的contributors：在github上显示有关贡献者的统计信息
01-30
Github上的贡献者 最初的想法是在拉取请求页面（例如上显示它是否是参与者的第一个PR。 非常感谢@ Pocket-titan和@djrosenbaum致力于徽标 :framed_picture: ！ 用法 您可以从github.com上的任何页面开始，当您导航到特定的issue / pull请求（例如 ）时，它将内联注入信息（例如＃用户对该特定回购单进行的PR数量）。 您可以点击:counterclockwise_arrows_button:以更新数据（如果数据已更改）（数据已缓存在chrome存储中）。 如果需要，如果您想使用30 / min的速率限制而不是10 / min，则可能需要创建或获取使用public_repo权限的“访问令牌”。 如果要在私有存储库上使用它，则需要添加存储repo权限。 我建议为此在本地安装。 权限 “ *”：能够将数据注入github 与"https://github.com/*/*/pull/*匹配，这是正确的，但是如果您从本开始，则该脚本将永远不会被注入，因为github使用pushState更改了网址现在，它将匹配https://gi
Git基本使用（很详细）
qq_45796592的博客
02-11 5万+
详细的git教程，一直到连接远程仓库
超详细git代码总结
最新发布
2301_78459015的博客
05-12 262
git add。
Git教程(快速上手，超详细)
热门推荐
weixin_48152652的博客
04-18 9万+
文章目录版本控制Git环境配置Git基本理论Git项目搭建Git文件操作使用码云IDEA集成GitGit分支 版本控制 版本迭代:每次更新就会有新的版本，旧的版本需要保留。所以我们需要一个版本控制工具帮助我们处理这个问题 版本控制（Revision control）是一种在开发的过程中用于管理我们对文件,目录或工程等内容的修改历史，方便查看更改历史记录,备份以便恢复以前的版本的软件工程技术。 简单说就是用于管理多人协同开发项目的技术。 常见的版本控制工具 主流的版本控制器有如下这些: Git(分布
Git使用教程：最详细、最傻瓜、最浅显、真正手把手教！
JoBo的博客
01-26 1万+
Git使用教程：最详细、最傻瓜、最浅显、真正手把手教！ 转 作者：爱编程_ 地址：https://blog.csdn.net/h8y0bDJVUkwE1LboZlE/article/details/86635415 导读：因为教程详细，所以行文有些长，新手边看边操作效果出乎你的预料。...
Git 源代码管理
weixin_42199602的博客
07-14 2617
GitGit 是目前世界上最先进的分布式版本控制系统（没有之一）作用源代码管理为什么要进行源代码管理?便于多人协同开发便于版本控制Git管理源代码特点1.Git是分布式管理.服务器和客户端都有版本控制能力,都能进行代码的提交、合并、...2.Git会在根目录下创建一个.git隐藏文件夹，作为本地代码仓库Git操作流程Git服务器 --&gt; 本地仓库 --&gt; 客户端 --&gt; 本地仓库...
VS2019中Git源代码管理实现总结
10-15
接下来，在VS2019中设置Git源代码插件，然后右键单击解决方案，选择“添加到源代码管理”。在“团队资源管理器”中，设置存储库的远程地址，点击“编辑”进行配置。提交更改前，可以使用“更改”查看差异，“提交”...
Githack:利用git目录结构读取源代码工具
03-24
GitHack是一个.git整合利用脚本，通过重定向的.git文件夹下的文件，重建还原工程源代码。 渗透测试人员，攻击者，可以进一步审核代码，挖掘：文件上传，SQL注射等安全漏洞。 脚本的工作原理 解析.git / index文件，...
git-src:git源码阅读
03-24
在这个名为"git-src:git源码阅读"的主题中，我们将深入探讨Git的核心概念、数据结构和主要功能，以及如何有效地阅读和分析Git的源代码。 1. **Git核心概念** - **仓库（Repository）**：Git仓库是存储项目历史的...
Git离线rpm安装包
04-26
Git是世界上最流行的分布式版本控制系统，它允许开发者跟踪和管理代码变更，协同开发项目。在某些没有网络连接或者网络环境受限的场景下，离线安装Git变得尤为重要。本篇将详细介绍如何使用提供的Git离线rpm安装包在...
GitHack改进版（git源码泄露恢复工具）
09-26
当源码泄露发生时，GitHack可以通过分析这些提交历史，帮助用户找回丢失或被误删的文件。以下是GitHack改进版的一些核心功能： 1. **文件恢复**：它能够从Git仓库中提取特定版本的文件，即使文件已被删除或覆盖，...
Git 使用教程：最详细、最正宗手把手教学（万字长文）
qq_16027093的博客
05-05 1万+
修复完成后，可以将更改提交到 bug 分支，并将其合并回开发分支和主分支。它们之间的区别在于，您可以对工作区中的任何文件进行修改，但只有将它们添加到暂存区并将其提交到版本库中，它们才会成为Git跟踪的部分。在 Git 中，推送分支指将本地的分支提交到远程仓库中，使得其他团队成员可以访问和获取该分支的代码。在 Git 中，抓取分支指从远程仓库拉取最新的代码和分支信息，并在本地创建相应的分支。通过使用 Git bug 分支，可以帮助团队更好地管理和修复代码中的错误和缺陷，同时保持代码库的稳定性和可靠性。
Git保姆级使用教程，超详细，带你了解常用Git命令！
weixin_45432729的博客
05-07 3633
Git（读音为/gɪt/）是一个开源的分布式版本控制系统，可以有效、高速地处理从很小到非常大的项目版本管理。也是Linus Torvalds为了帮助管理Linux内核开发而开发的一个开放源码的版本控制软件。在IDEA开发工具中可以集成Git：Git 是一个分布式版本控制工具，通常用来对软件开发过程中的源代码文件进行管理。本地仓库：开发人员自己电脑上的 Git 仓库远程仓库：远程服务器上的 Git 仓库解释说明：commit：提交,将本地文件和版本信息保存到本地仓库。
Git入门(建议收藏)
qq_56999918的博客
09-01 6358
中心服务器，仅仅是为了方便交换大家的修改，但是这个服务器的地位和我们每个人的PC是一样的。我们可以 把它当做一个开发者的pc就可以就是为了大家代码容易交流不关机用的。没有它大家一样可以工作，只不过“交换”修改不方便而已。git是一个开源的分布式版本控制系统，可以有效、高速地处理从很小到非常大的项目版本管理。Git是 Linus Torvalds 为了帮助管理Linux内核开发而开发的一个开放源码的版本控制软件。同生活中的许多伟大事物一样，Git诞生于一个极富纷争大举创新的年代。
Git教程（超详细，一文秒懂）
♚焕蓝·未来的博客
04-15 2万+
Git 是一个免费的、开源的分布式版本控制系统，可以快速高效地处理从小型到大型的各种项目。Git 易于学习， 占地面积小， 性能极快。 它具有廉价的本地库， 方便的暂存区域和多个工作流分支等特性。 其性能优于 Subversion、CVS、Perforce 和 ClearCase 等版本控制工具。
超详细Git讲解 ，看这一篇就够了
一个前端开发者
06-05 2972
版本控制软件的作用 , 版本控制系统的分类 , Git的特性 , 初始化 Git 仓库的命令, 查看文件状态的命令, 一次性将文件加入暂存区的命令, 将暂存区的文件提交到 Git 仓库的命令, 使用 Github 创建和维护远程仓库, 掌握 `Git` 分支的基本使用............
git gbp命令解析
06-07
- `import-orig`: 导入上游源代码到 Git 仓库中。 - `import-dsc`: 导入 Debian 源代码控制文件（.dsc 文件）到 Git 仓库中。 - `buildpackage`: 构建软件包并生成 .deb 文件。 - `tag`: 标记 Git 代码库中的版本，...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值