如何在提交前撤消'git add'?

[英]How to undo 'git add' before commit?


I mistakenly added files to git using the command:

我使用命令错误地将文件添加到git:

git add myfile.txt

I have not yet run git commit. Is there a way to undo this, so these files won't be included in the commit?

我还没有运行git commit。有没有办法撤消这个,所以这些文件不会包含在提交中?


There are 48 answers so far (some deleted). Please don't add a new one unless you have some new information.

到目前为止有48个答案(有些已删除)。除非您有一些新信息,否则请不要添加新的。

33 个解决方案

#1


8721  

You can undo git add before commit with

您可以在提交之前撤消git add

git reset <file>

which will remove it from the current index (the "about to be committed" list) without changing anything else.

这将从当前索引(“即将提交”列表)中删除它而不更改任何其他内容。

You can use

您可以使用

git reset

without any file name to unstage all due changes. This can come in handy when there are too many files to be listed one by one in a reasonable amount of time.

没有任何文件名来取消所有应有的更改。当在合理的时间内逐个列出太多文件时,这可以派上用场。

In old versions of Git, the above commands are equivalent to git reset HEAD <file> and git reset HEAD respectively, and will fail if HEAD is undefined (because you haven't yet made any commits in your repo) or ambiguous (because you created a branch called HEAD, which is a stupid thing that you shouldn't do). This was changed in Git 1.8.2, though, so in modern versions of Git you can use the commands above even prior to making your first commit:

在旧版本的Git中,上面的命令分别等同于git reset HEAD 和git reset HEAD,如果HEAD未定义(因为你还没有在你的repo中进行任何提交)或者模糊(因为你),它将会失败创建了一个名为HEAD的分支,这是一个你不应该做的愚蠢的事情。但是在Git 1.8.2中已经改变了,所以在现代版本的Git中,你甚至可以在第一次提交之前使用上面的命令:

"git reset" (without options or parameters) used to error out when you do not have any commits in your history, but it now gives you an empty index (to match non-existent commit you are not even on).

当您在历史记录中没有任何提交时,“git reset”(没有选项或参数)用于出错,但它现在为您提供一个空索引(以匹配不存在的提交,您甚至没有)。

#2


1997  

You want:

git rm --cached <added_file_to_undo>

Reasoning:

When I was new to this, I first tried

当我刚接触这个时,我首先尝试过

git reset .

(to undo my entire initial add), only to get this (not so) helpful message:

(撤消我的整个初始添加),只是为了得到这个(不那么)有用的消息:

fatal: Failed to resolve 'HEAD' as a valid ref.

It turns out that this is because the HEAD ref (branch?) doesn't exist until after the first commit. That is, you'll run into the same beginner's problem as me if your workflow, like mine, was something like:

事实证明,这是因为HEAD ref(branch?)直到第一次提交后才存在。也就是说,如果你的工作流程像我一样,你会遇到和我一样的初学者问题:

  1. cd to my great new project directory to try out Git, the new hotness
  2. cd到我伟大的新项目目录,尝试Git,新的热点

  3. git init
  4. git add .
  5. git add。

  6. git status

    ... lots of crap scrolls by ...

    ......很多废话卷轴......

    => Damn, I didn't want to add all of that.

    =>该死,我不想加上所有这些。

  7. google "undo git add"

    谷歌“撤消git添加”

    => find Stack Overflow - yay

    =>查找Stack Overflow - yay

  8. git reset .

    git重置。

    => fatal: Failed to resolve 'HEAD' as a valid ref.

    =>致命:无法将'HEAD'解析为有效的参考号。

It further turns out that there's a bug logged against the unhelpfulness of this in the mailing list.

事实证明,在邮件列表中存在一个针对此无益的错误。

And that the correct solution was right there in the Git status output (which, yes, I glossed over as 'crap)

并且正确的解决方案就在Git状态输出中(是的,我把它作为'废话'掩盖了)

...
# Changes to be committed:
#   (use "git rm --cached <file>..." to unstage)
...

And the solution indeed is to use git rm --cached FILE.

而解决方案确实是使用git rm --cached FILE。

Note the warnings elsewhere here - git rm deletes your local working copy of the file, but not if you use --cached. Here's the result of git help rm:

请注意此处其他地方的警告 - git rm删除文件的本地工作副本,但如果使用--cached则不会删除。这是git help rm的结果:

--cached Use this option to unstage and remove paths only from the index. Working tree files, whether modified or not, will be left.

--cached使用此选项仅从索引中取消暂存和删除路径。将保留工作树文件,无论是否已修改。

I proceed to use

我继续使用

git rm --cached .

to remove everything and start again. Didn't work though, because while add . is recursive, turns out rm needs -r to recurse. Sigh.

删除所有内容并重新开始。虽然没有工作,因为虽然添加。是递归的,结果是rm需要-r来递归。叹。

git rm -r --cached .

Okay, now I'm back to where I started. Next time I'm going to use -n to do a dry run and see what will be added:

好的,现在我回到了我开始的地方。下次我要使用-n进行干运行,看看会添加什么:

git add -n .

I zipped up everything to a safe place before trusting git help rm about the --cached not destroying anything (and what if I misspelled it).

我把所有东西都拉到一个安全的地方,然后相信git帮助rm关于--cached没有破坏任何东西(如果我拼错它会怎么样)。

#3


495  

If you type:

如果您输入:

git status

git will tell you what is staged, etc, including instructions on how to unstage:

git会告诉你什么是上演的,包括如何取消演出的说明:

use "git reset HEAD <file>..." to unstage

I find git does a pretty good job of nudging me to do the right thing in situations like this.

我发现git在推动我在这样的情况下做正确的事情方面做得非常好。

Note: Recent git versions (1.8.4.x) have changed this message:

注意:最近的git版本(1.8.4.x)已更改此消息:

(use "git rm --cached <file>..." to unstage)

#4


227  

To clarify: git add moves changes from the current working directory to the staging area (index).

为了澄清:git add将更改从当前工作目录移动到暂存区域(索引)。

This process is called staging. So the most natural command to stage the changes (changed files) is the obvious one:

此过程称为分段。所以,最自然的命令来进行更改(更改文件)是显而易见的:

git stage

git add is just an easier to type alias for git stage

git add更容易为git stage输入别名

Pity there is no git unstage nor git unadd commands. The relevant one is harder to guess or remember, but is pretty obvious:

可惜没有git unstage也没有git unadd命令。相关的一个更难猜测或记住,但很明显:

git reset HEAD --

We can easily create an alias for this:

我们可以轻松地为此创建一个别名:

git config --global alias.unadd 'reset HEAD --'
git config --global alias.unstage 'reset HEAD --'

And finally, we have new commands:

最后,我们有了新的命令:

git add file1
git stage file2
git unadd file2
git unstage file1

Personally I use even shorter aliases:

我个人使用更短的别名:

git a #for staging
git u #for unstaging

#5


146  

An addition to the accepted answer, if your mistakenly added file was huge, you'll probably notice that, even after removing it from the index with 'git reset', it still seems to occupy space in the .git directory. This is nothing to be worried about, the file is indeed still in the repository, but only as a "loose object", it will not be copied to other repositories (via clone, push), and the space will be eventually reclaimed - though perhaps not very soon. If you are anxious, you can run:

对于已接受的答案的补充,如果您错误添加的文件很大,您可能会注意到,即使在使用'git reset'将其从索引中删除之后,它仍然会占用.git目录中的空间。这没什么可担心的,文件确实仍在存储库中,但只是作为“松散对象”,它不会被复制到其他存储库(通过克隆,推送),并且该空间最终将被回收 - 尽管也许不是很快。如果您感到焦虑,可以运行:

git gc --prune=now

Update (what follows is my attempt to clear some confusion that can arise from the most up-voted answers):

更新(以下是我尝试清除最多投票答案可能引起的混淆):

So, which is the real undo of git add?

那么,哪个是git add的真正撤消?

git reset HEAD <file> ?

git reset HEAD ?

or

git rm --cached <file>?

git rm --cached ?

Strictly speaking, and if I'm not mistaken: none.

严格来说,如果我没有弄错:没有。

git add cannot be undone - safely, in general.

git add无法撤消 - 通常是安全的。

Let's recall first what git add <file> actually does:

让我们先回顾一下git add 实际上做了什么:

  1. If <file> was not previously tracked, git add adds it to the cache, with its current content.

    如果先前未跟踪 ,则git add会将其添加到缓存中,并使用其当前内容。

  2. If <file> was already tracked, git add saves the current content (snapshot, version) to the cache. In GIT, this action is still called add, (not mere update it), because two different versions (snapshots) of a file are regarded as two different items: hence, we are indeed adding a new item to the cache, to be eventually commited later.

    如果已经跟踪了 ,则git add会将当前内容(快照,版本)保存到缓存中。在GIT中,这个动作仍称为add,(不仅仅是更新它),因为文件的两个不同版本(快照)被视为两个不同的项目:因此,我们确实在缓存中添加了一个新项目,最终稍后提交。

In light of this, the question is slightly ambiguous:

鉴于此,问题有点含糊:

I mistakenly added files using the command...

我错误地使用命令添加文件...

The OP's scenario seems to be the first one (untracked file), we want the "undo" to remove the file (not just the current contents) from the tracked items. If this is the case, then it's ok to run git rm --cached <file>.

OP的场景似乎是第一个(未跟踪文件),我们希望“撤消”从被跟踪的项目中删除文件(而不仅仅是当前内容)。如果是这种情况,则可以运行git rm --cached

And we could also run git reset HEAD <file>. This is in general preferable, because it works in both scenarios: it also does the undo when we wrongly added a version of an already tracked item.

我们也可以运行git reset HEAD 。这通常是可取的,因为它适用于两种情况:当我们错误地添加已经跟踪的项目的版本时,它也会执行撤消操作。

But there are two caveats.

但有两点需要注意。

First: There is (as pointed out in the answer) only one scenario in which git reset HEAD doesn't work, but git rm --cached does: a new repository (no commits). But, really, this a practically irrelevant case.

第一:(在答案中指出)只有一个场景,其中git reset HEAD不起作用,但是git rm --cached:新的存储库(没有提交)。但是,实际上,这是一个几乎无关紧要的案例。

Second: Be aware that git reset HEAD can't magically recover the previously cached file contents, it just resyncs it from the HEAD. If our misguided git add overwrote a previous staged uncommitted version, we can't recover it. That's why, strictly speaking, we cannot undo [*].

第二:请注意,git reset HEAD无法神奇地恢复以前缓存的文件内容,它只是从HEAD重新同步它。如果我们被误导的git add覆盖了以前暂存的未提交版本,我们就无法恢复它。这就是为什么,严格来说,我们无法撤消[*]。

Example:

$ git init
$ echo "version 1" > file.txt
$ git add file.txt   # first add  of file.txt
$ git commit -m 'first commit'
$ echo "version 2" > file.txt
$ git add  file.txt   # stage (don't commit) "version 2" of file.txt
$ git diff --cached file.txt
-version 1
+version 2
$ echo "version 3" > file.txt   
$ git diff  file.txt
-version 2
+version 3
$ git add  file.txt    # oops we didn't mean this
$ git reset HEAD file.txt  # undo ?
$ git diff --cached file.txt  # no dif, of course. stage == HEAD
$ git diff file.txt   # we have lost irrevocably "version 2"
-version 1
+version 3

Of course, this is not very critical if we just follow the usual lazy workflow of doing 'git add' only for adding new files (case 1), and we update new contents via the commit, git commit -a command.

当然,如果我们只是按照通常的懒惰工作流程来执行'git add'仅用于添加新文件(案例1),并且我们通过commit,git commit -a命令更新新内容,这不是非常关键。


* (Edit: the above is practically correct, but still there can be some slightly hackish/convoluted ways for recovering changes that were staged but not committed and then overwritten - see the comments by Johannes Matokic and iolsmit)

*(编辑:以上几乎是正确的,但仍然可能有一些稍微ha / /的复杂方式来恢复已上演但未提交然后被覆盖的更改 - 请参阅Johannes Matokic和iolsmit的评论)

#6


89  

git rm --cached . -r

will "un-add" everything you've added from your current directory recursively

将以递归方式“取消添加”您从当前目录添加的所有内容

#7


83  

Run

git gui

and remove all the files manually or by selecting all of them and clicking on the unstage from commit button.

并手动删除所有文件或选择所有文件并单击“提交”按钮。

#8


78  

Git has commands for every action imaginable, but needs extensive knowledge to get things right and because of that it is counter-intuitive at best...

Git拥有可以想象的每一个动作的命令,但需要广泛的知识来使事情正确,因此它最好是反直觉的......

What you did before:

你之前做过的事:

  • Changed a file and used git add ., or git add <file>.
  • 更改了文件并使用了git add。或git add

What you want:

你想要什么:

  • Remove the file from the index, but keep it versioned and left with uncommitted changes in working copy:

    从索引中删除该文件,但保留其版本并留下工作副本中未提交的更改:

    git reset head <file>
    
  • Reset the file to the last state from HEAD, undoing changes and removing them from the index:

    将文件重置为HEAD的最后一个状态,撤消更改并将其从索引中删除:

    # Think `svn revert <file>` IIRC.
    git reset HEAD <file>
    git checkout <file>
    
    # If you have a `<branch>` named like `<file>`, use:
    git checkout -- <file>
    

    This is needed since git reset --hard HEAD won't work with single files.

    这是必需的,因为git reset --hard HEAD不能用于单个文件。

  • Remove <file> from index and versioning, keeping the un-versioned file with changes in working copy:

    从索引和版本控制中删除 ,使未版本化的文件保留工作副本中的更改:

    git rm --cached <file>
    
  • Remove <file> from working copy and versioning completely:

    完全从工作副本和版本控制中删除 :

    git rm <file>
    

#9


70  

Undo a file which already added is quite easy using git, for resetting myfile.txt which already added, use:

使用git撤消已添加的文件非常简单,重置已添加的myfile.txt,使用:

git reset HEAD myfile.txt

Explain:

After you staged unwanted file(s), to undo, you can do git reset, Head is head of your file in local and the last parameter is the name of your file.

在您暂存不需要的文件后,要撤消,您可以执行git reset,Head是您本地文件的头部,最后一个参数是您的文件名称。

I create the steps in the image below in more details for you, including all steps which may happen in these cases:

我将在下面的图片中为您创建更多详细信息,包括在这些情况下可能发生的所有步骤:

git reset HEAD

#10


69  

The question is not clearly posed. The reason is that git add has two meanings:

问题没有明确提出。原因是git add有两个含义:

  1. adding a new file to the staging area, then undo with git rm --cached file.
  2. 将新文件添加到暂存区域,然后使用git rm --cached文件撤消。

  3. adding a modified file to the staging area, then undo with git reset HEAD file.
  4. 将修改后的文件添加到暂存区域,然后使用git reset HEAD文件撤消。

if in doubt, use

如果有疑问,请使用

git reset HEAD file

Because it does the expected thing in both cases.

因为它在两种情况下都做了预期的事情。

Warning: if you do git rm --cached file on a file that was modified (a file that existed before in the repository), then the file will be removed on git commit! It will still exist in your file system, but if anybody else pulls your commit, the file will be deleted from their work tree.

警告:如果您对已修改的文件(以前存储在存储库中的文件)执行git rm --cached文件,则该文件将在git commit上删除!它仍然存在于您的文件系统中,但如果有其他人提取您的提交,该文件将从其工作树中删除。

git status will tell you if the file was a new file or modified:

git status将告诉您文件是新文件还是已修改:

On branch master
Changes to be committed:
  (use "git reset HEAD <file>..." to unstage)

    new file:   my_new_file.txt
    modified:   my_modified_file.txt

#11


58  

If you're on your initial commit and you can't use git reset, just declare "Git bankruptcy" and delete the .git folder and start over

如果您正在进行初始提交并且无法使用git reset,只需声明“Git破产”并删除.git文件夹并重新开始

#12


54  

As per many of the other answers you can use git reset

根据许多其他答案,您可以使用git reset

BUT:

I found this great little post that actually adds the Git command (well an alias) for git unadd: see git unadd for details or..

我发现这个伟大的小帖子实际上为git unadd添加了Git命令(以及别名):有关详细信息,请参阅git unadd或..

Simply,

git config --global alias.unadd "reset HEAD"

Now you can

现在你可以

git unadd foo.txt bar.txt

#13


47  

git remove or git rm can be used for this, with the --cached flag. Try:

使用--cached标志可以使用git remove或git rm。尝试:

git help rm

#14


41  

Use git add -i to remove just-added files from your upcoming commit. Example:

使用git add -i从即将到来的提交中删除刚刚添加的文件。例:

Adding the file you didn't want:

添加您不想要的文件:

$ git add foo
$ git status
# On branch master
# Changes to be committed:
#   (use "git reset HEAD <file>..." to unstage)
#
#       new file:   foo
#
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]#

Going into interactive add to undo your add (the commands typed at git here are "r" (revert), "1" (first entry in the list revert shows), 'return' to drop out of revert mode, and "q" (quit):

进入交互式添加以撤消你的添加(在这里输入git的命令是“r”(恢复),“1”(列表恢复中的第一个条目显示),“返回”退出恢复模式,以及“q” (放弃):

$ git add -i
           staged     unstaged path
  1:        +1/-0      nothing foo

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> r
           staged     unstaged path
  1:        +1/-0      nothing [f]oo
Revert>> 1
           staged     unstaged path
* 1:        +1/-0      nothing [f]oo
Revert>> 
note: foo is untracked now.
reverted one path

*** Commands ***
  1: [s]tatus     2: [u]pdate     3: [r]evert     4: [a]dd untracked
  5: [p]atch      6: [d]iff       7: [q]uit       8: [h]elp
What now> q
Bye.
$

That's it! Here's your proof, showing that "foo" is back on the untracked list:

而已!这是你的证明,显示“foo”回到未跟踪列表:

$ git status
# On branch master
# Untracked files:
#   (use "git add <file>..." to include in what will be committed)
# [...]
#       foo
nothing added to commit but untracked files present (use "git add" to track)
$

#15


35  

Here's a way to avoid this vexing problem when you start a new project:

这是一种在开始新项目时避免这个棘手问题的方法:

  • Create the main directory for your new project.
  • 为新项目创建主目录。

  • Run git init.
  • 运行git init。

  • Now create a .gitignore file (even if it's empty).
  • 现在创建一个.gitignore文件(即使它是空的)。

  • Commit your .gitignore file.
  • 提交你的.gitignore文件。

Git makes it really hard to do git reset if you don't have any commits. If you create a tiny initial commit just for the sake of having one, after that you can git add -A and git reset as many times as you want in order to get everything right.

如果你没有任何提交,Git会让git重置变得非常困难。如果你创建一个微小的初始提交只是为了有一个,之后你可以git添加-A和git重置多次你想要的一切正确。

Another advantage of this method is that if you run into line-ending troubles later and need to refresh all your files, it's easy:

这种方法的另一个优点是,如果您以后遇到行结束问题并需要刷新所有文件,这很容易:

  • Check out that initial commit. This will remove all your files.
  • 查看初始提交。这将删除所有文件。

  • Then check out your most recent commit again. This will retrieve fresh copies of your files, using your current line-ending settings.
  • 然后再次检查您最近的提交。这将使用您当前的行结束设置检索文件的新副本。

#16


32  

Maybe Git has evolved since you posted your question.

也许自从你发布问题以来Git已经发展了。

$> git --version
git version 1.6.2.1

Now, you can try:

现在,您可以尝试:

git reset HEAD .

This should be what you are looking for.

这应该是你正在寻找的。

#17


32  

Note that if you fail to specify a revision then you have to include a separator. Example from my console:

请注意,如果您未能指定修订版,则必须包含分隔符。我的控制台示例:

git reset <path_to_file>
fatal: ambiguous argument '<path_to_file>': unknown revision or path not in the working tree.
Use '--' to separate paths from revisions

git reset -- <path_to_file>
Unstaged changes after reset:
M   <path_to_file>

(git version 1.7.5.4)

(git版本1.7.5.4)

#18


29  

To remove new files from the staging area (and only in case of a new file), as suggested above:

要从暂存区域中删除新文件(仅在新文件的情况下),如上所述:

git rm --cached FILE

Use rm --cached only for new files accidentally added.

仅对意外添加的新文件使用rm --cached。

#19


23  

To reset every file in a particular folder (and its subfolders), you can use the following command:

要重置特定文件夹(及其子文件夹)中的每个文件,可以使用以下命令:

git reset *

#20


23  

use the * command to handle multiple files at a time

使用*命令一次处理多个文件

git reset HEAD *.prj
git reset HEAD *.bmp
git reset HEAD *gdb*

etc

#21


21  

Just type git reset it will revert back and it is like you never typed git add . since your last commit. Make sure you have committed before.

只需键入git reset它就会恢复,就像你从未输入git add一样。自上次提交以来。确保你之前已经承诺。

#22


16  

Suppose I create a new file newFile.txt.

假设我创建了一个新文件newFile.txt。

enter image description here

Suppose I add the file accidently, git add newFile.txt

假设我意外添加了文件,git add newFile.txt

enter image description here

Now I want to undo this add, before commit, git reset newFile.txt

现在我要在提交之前撤消此添加,git reset newFile.txt

enter image description here

#23


14  

For a specific file:

对于特定文件:

  • git reset my_file.txt
  • git reset my_file.txt

  • git checkout my_file.txt
  • git checkout my_file.txt

For all added files:

对于所有添加的文件:

  • git reset .
  • git重置。

  • git checkout .
  • git checkout。

Note: checkout changes the code in the files and moves to the last updated (committed) state. reset doesn't change the codes; it just resets the header.

注意:checkout更改文件中的代码并移至上次更新(已提交)状态。重置不会改变代码;它只是重置标题。

#24


12  

This command will unstash your changes:

此命令将取消暂停您的更改:

git reset HEAD filename.txt

You can also use

你也可以使用

git add -p 

to add parts of files.

添加部分文件。

#25


12  

To undo git add use

要撤消git add use

git reset filename

git重置文件名

#26


11  

I'm surprised that no one mention interactive mode:

我很惊讶没有人提到交互模式:

git add -i

choose option 3 to un add files. In my case i often want to add more than one file, with interactive mode you can use numbers like this to add files. This will take all but 4: 1,2,3,5

选择选项3以取消添加文件。在我的情况下,我经常想要添加多个文件,使用交互模式,您可以使用这样的数字来添加文件。这将采取除4:1,2,3,5之外的所有

To choose a sequence just type 1-5 to take all from 1 to 5.

要选择一个序列,只需输入1-5即可从1到5。

Git staging files

Git临时文件

#27


8  

git reset filename.txt

Will remove a file named filename.txt from the current index, the "about to be committed" area, without changing anything else.

将从当前索引“即将被提交”区域中删除名为filename.txt的文件,而不更改任何其他内容。

#28


8  

git add myfile.txt # this will add your file into to be committed list

git add myfile.txt#这将把你的文件添加到提交列表中

Quite opposite to this command is,

与此命令完全相反的是,

git reset HEAD myfile.txt  # this will undo it. 

so, you will be in previous state. specified will be again in untracked list (previous state).

所以,你将处于以前的状态。指定将再次处于未跟踪列表(先前状态)。

it will reset your head with that specified file. so, if your head doesn't have it means, it will simply reset it

它将使用指定的文件重置您的头部。所以,如果你的头没有它的意思,它只会重置它

#29


8  

git reset filename.txt  

Will remove a file named filename.txt from the current index, the "about to be committed" area, without changing anything else.

将从当前索引“即将被提交”区域中删除名为filename.txt的文件,而不更改任何其他内容。

#30


7  

In SourceTree you can do this easily via the gui. You can check which command sourcetree uses to unstage a file.

在SourceTree中,您可以通过gui轻松完成此操作。您可以检查sourcetree使用哪个命令来取消暂存文件。

I created a new file and added it to git. Then I unstaged it using the SourceTree gui. This is the result:

我创建了一个新文件并将其添加到git中。然后我使用SourceTree gui取消了它。这是结果:

Unstaging files [08/12/15 10:43]
git -c diff.mnemonicprefix=false -c core.quotepath=false -c credential.helper=sourcetree reset -q -- path/to/file/filename.java

取消暂停文件[08/12/15 10:43] git -c diff.mnemonicprefix = false -c core.quotepath = false -c credential.helper = sourcetree reset -q - path / to / file / filename.java

SourceTree uses reset to unstage new files.

SourceTree使用reset来取消暂存新文件。


注意!

本站翻译的文章,版权归属于本站,未经许可禁止转摘,转摘请注明本文地址:https://www.itdaan.com/blog/2008/12/07/37dd068438fd427fe61c0a1fe29bd67e.html



 
粤ICP备14056181号  © 2014-2020 ITdaan.com