Creating a new empty branch for a new project
We are using a git repository to store our project. We have our branches departing from the original branch. But now we want to create a small new project to track some documentation. For that we would want to create a new empty branch to start storing our files, and I would want other users of the network to clone that branch.
How can we do that?
I tried some things, but they didn't work.
$ mkdir proj_doc; cd proj_doc
$ git init
$ git add .
$ git commit -m 'first commit'
$ git br proj_doc
$ git co proj_doc
$ git br -d master
$ git push origin proj_doc
It seems to push the branch ok, but when I do a fetch or pull, it downloads information from other branches, and then I also get some extra files from other projects. What's the best solution?
submodule in the original project, e.g. docs/ pointing to that other repo. Or, if you want to merge the code later, add it as a remote.
.gitignore'd files, and also constantly switch between the two roots (branches). So I'm also for the new repo approach, in a new folder, having the same remotes, and pushing to another branch.
You can create a branch as an orphan:
git checkout --orphan <branchname>
This will create a new branch with no parents. Then, you can clear the working directory with:
git rm --cached -r .
and add the documentation files, commit them and push them up to github.
A pull or fetch will always update the local information about all the remote branches. If you only want to pull/fetch the information for a single remote branch, you need to specify it.
The correct answer is to create an orphan branch. I explain how to do this in detail on my blog.(Archived link)
... Before starting, upgrade to the latest version of GIT. To make sure you’re running the latest version, run which git If it spits out an old version, you may need to augment your PATH with the folder containing the version you just installed. Ok, we’re ready. After doing a cd into the folder containing your git checkout, create an orphan branch. For this example, I’ll name the branch “mybranch”. git checkout --orphan mybranch Delete everything in the orphan branch git rm -rf . Make some changes vi README.txt Add and commit the changes git add README.txt git commit -m "Adding readme file" That’s it. If you run git log you’ll notice that the commit history starts from scratch. To switch back to your master branch, just run git checkout master You can return to the orphan branch by running git checkout mybranch
Make an empty new branch like this:
true | git mktree | xargs git commit-tree | xargs git branch proj-doc
If your proj-doc files are already in a commit under a single subdir you can make the new branch this way:
git commit-tree thatcommit:path/to/dir | xargs git branch proj-doc
which might be more convenient than git branch --orphan if that would leave you with a lot of git rm and git mving to do.
Try
git branch --set-upstream proj-doc origin/proj-doc
and see if that helps with your fetching-too-much problem. Also if you really only want to fetch a single branch it's safest to just specify it on the commandline.
git checkout --orphan new-branch; git reset --hard
xargs?
git branch --set-uptream-to you can push the empty branch on remote using git push --set-upstream origin proj-doc:projdoc (from you current branch).
If your git version does not have the --orphan option, this method should be used:
git symbolic-ref HEAD refs/heads/<newbranch>
rm .git/index
git clean -fdx
After doing some work:
git add -A
git commit -m <message>
git push origin <newbranch>
git clean can delete files you don't want to delete! Run git clean -ndx first to see what files it will delete before you run it for real with the -f option.
Let's say you have a master branch with files/directories:
> git branch
master
> ls -la # (files and dirs which you may keep in master)
.git
directory1
directory2
file_1
..
file_n
Step by step how to make an empty branch:
git checkout —orphan new_branch_name Make sure you are in the right directory before executing the following command: ls -la |awk '{print $9}' |grep -v git |xargs -I _ rm -rf ./_ git rm -rf . touch new_file git add new_file git commit -m 'added first file in the new branch' git push origin new_branch_name
In step 2, we simply remove all the files locally to avoid confusion with the files on your new branch and those ones you keep in master branch. Then, we unlink all those files in step 3. Finally, step 4 and after are working with our new empty branch.
Once you're done, you can easily switch between your branches:
git checkout master
git checkout new_branch
The best solution is to create a new branch with --orphan option as shown below
git checkout --orphan <branch name>
By this you will be able to create a new branch and directly checkout to the new branch. It will be a parentless branch.
By default the --orphan option doesn't remove the files in the working directory, so you can delete the working directory files by this:
git rm --cached -r
In details what the --orphan does:
--orphan
The index and the working tree are adjusted as if you had previously run git checkout
This can be useful when you want to publish the tree from a commit without exposing its full history. You might want to do this to publish an open source branch of a project whose current tree is "clean", but whose full history contains proprietary or otherwise encumbered bits of code.
If you want to start a disconnected history that records a set of paths that is totally different from the one of
2022 Update
As of Git 2.23, you can use git switch --orphan <new branch> to create an empty branch with no history. Unlike git checkout --orphan, all tracked files will be removed.
Once you actually have commits on this branch, it can be pushed to the remote repository:
git switch --orphan <new branch>
git commit --allow-empty -m "Initial commit on orphan branch"
git push -u origin <new branch>
On base this answer from Hiery Nomus.
You can create a branch as an orphan:
git checkout --orphan <branchname>
This will create a new branch with no parents. Then, you can clear the working directory with:
git rm --cached -r .
And then you just commit branch with empty commit and then push
git commit -m <commit message> --allow-empty
git push origin <newbranch>
i found this help:
git checkout --orphan empty.branch.name
git rm --cached -r .
echo "init empty branch" > README.md
git add README.md
git commit -m "init empty branch"
I found it here
If you use git 2.23 or above you may be used to git switch and git restore instead of git checkout
So if you need to have an empty branch try this:
git switch --orphan YourNewBranch
That's it :))
Follow WeChat
Success story sharing
Want to stay one step ahead of the latest teleworks?
Subscribe Now相似问题
- Undoing a git rebase
- Showing which files have changed between two revisions
- How do I force "git pull" to overwrite local files?
- How do I create a remote Git branch?
- Move the most recent commit(s) to a new branch with Git
- How do I delete a Git branch locally and remotely?
- How do I push a new local branch to a remote Git repository and track it too?
- How do I rename a local Git branch?
- Git fetch remote branch
git checkout --orphan <branch>; I don't see any listing of <branch> ingit branch.git checkout --orphanone can usegit reset --hardto delete left over files.git checkout --orphan <branch>is because it does not have any commits yet. After the first commitgit branchprints the new branch.