When starting a new project, one of the first things you'll find yourself needing to do is creating a new Git repository. This not only helps you share the project with coworkers, or publicly, but it's also a great way to track updates to a young project that is bound to go through significant changes in its early life. With a full history of those changes, and helpful features like branches, you can more easily test out different designs/implementations for the project without losing previous work.
As with anything in Git, there are a few ways to do what we want, depending on what you need. In this article we'll show a few ways to create a new repository.
Creating a Repository from Scratch
In order to start this new repo you'll want to use the
init command. To do this, go to your project directory and type the following:
$ git init Initialized empty Git repository in /Users/scott/projects/my-new-project/.git/
This can be done at any time in your project, whether there are already files there or not. Once you've added some files and feel like you're at a point in which you should commit your code, you can use the
add command to add your files to the new repo:
$ git add .
This will stage the files in your current working directory for the next commit. After staging our files, we can verify that they are ready to commit by using the
$ git status On branch master Initial commit Changes to be committed: (use "git rm --cached <file>..." to unstage) new file: index.js new file: package.json
Finally, you can commit the files to the new repo using
$ git commit -am "Initial commit" [master (root-commit) 37a82f5] Initial commit 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 index.js create mode 100644 package.json
Here we also use the flags
-m, which do the following:
-a: Commit all staged files
-m: Use the following string as the commit message
Creating a Repository for an Existing Project
Creating a repository for an existing project is virtually the same process as creating a repository for a new project. Just as in the last section, you'll want to execute the same general commands:
$ git init Initialized empty Git repository in /Users/scott/projects/my-new-project/.git/ $ git add . $ git commit -am "Initial commit" [master (root-commit) 37a82f5] Initial commit 2 files changed, 0 insertions(+), 0 deletions(-) create mode 100644 index.js create mode 100644 package.json
Note that the
git add . command will add all files in the current working directory, including those in subdirectories. However, it will also add some files or directories that you might not want, like
node_modules for a Node.js project. In order to avoid including unwanted files/directories like this, you should create and commit a
Backing up a little, our commands to create a repository for an existing project may look more like this:
$ git init Initialized empty Git repository in /Users/scott/projects/my-new-project/.git/ $ echo "node_modules/" > .gitignore $ echo "package-lock.json" >> .gitignore $ git add .
Now when these "ignored" items are present in your project you don't need to worry about accidentally staging and committing them. For example:
$ npm install $ ls -l total 40 -rw-r--r-- 1 scott staff 0 Sep 16 15:15 index.js drwxr-xr-x 4 scott staff 136 Sep 16 15:27 lib drwxr-xr-x 52 scott staff 1768 Sep 16 15:32 node_modules -rw-r--r-- 1 scott staff 14233 Sep 16 15:32 package-lock.json -rw-r--r-- 1 scott staff 362 Sep 16 15:32 package.json $ git add . $ git status On branch master Initial commit Changes to be committed: (use "git rm --cached <file>..." to unstage) new file: .gitignore new file: index.js new file: lib/api.js new file: lib/db.js new file: package.json $ git commit -am "Initial commit" [master (root-commit) 9646a88] Initial commit 5 files changed, 19 insertions(+) create mode 100644 .gitignore create mode 100644 index.js create mode 100644 lib/api.js create mode 100644 lib/db.js create mode 100644 package.json
Notice that our ignored file (package-lock.json) and directory (node_modules) are not included in staging, even after executing
git add ., or the commit.
.gitignore is not only recommended when creating a repo for an existing project, but we reference it here because you're more likely to need it for an existing project, as more mature projects tend to accumulate files that shouldn't be tracked or shared between users.
Cloning an Existing Project
Although you aren't technically creating a new repo, in this use-case you can clone an existing one, preventing you from needing to
git init one yourself. This is very common for when you're needing to make updates to an existing project, or maybe if you want to clone a skeleton project to help get you started.
In order to clone a repo, you'll want to use the
$ git clone <repo-url>
This will copy all of the contents of the repository to your current working directory under the name of the repository. For example:
$ git clone [email protected]:scottwrobinson/twentyjs.git Cloning into 'twentyjs'... remote: Enumerating objects: 48, done. remote: Total 48 (delta 0), reused 0 (delta 0), pack-reused 48 Receiving objects: 100% (48/48), 9.35 KiB | 0 bytes/s, done. Resolving deltas: 100% (22/22), done. $ ls -l total 0 drwxr-xr-x 9 scott staff 306 Sep 16 15:55 twentyjs
There are a number of other options and use-cases for this command, but they aren't in the scope of this article, so we won't cover them here. For more info, check out the article Git: Clone a Repository.