Basic GitHub Commands Guide SlowYou.io - torarnehave1/slowyouio GitHub Wiki

Below is a detailed markdown guide designed to help beginners understand how to use basic GitHub commands. This guide includes the most commonly used Git commands and their purposes, formatted to be clear and instructional.

This document provides an overview of basic Git commands that are essential for version control and collaboration in software projects.

Before you start using Git, you need to set it up on your local machine. Here’s how to do it:

git config --global user.name "Your Name"
git config --global user.email "[email protected]"

These commands set your Git username and email, respectively. This information is important because every Git commit uses this information to identify you as the author.

A repository (or "repo") is where your project's files and their history are stored.

1. Initialize a new repository:

   git init

   This command creates a new local Git repository in the current directory.

2. Clone an existing repository:

   git clone https://github.com/username/repository.git

   Replace https://github.com/username/repository.git with the URL of the repository you want to clone. This command makes a complete copy of the repository in a new directory on your local machine.

The basic Git workflow involves making changes to your project, staging those changes, and committing them to your project history. Here’s how to do it:

1. Check the status of your files:

   git status

   This command lists the status of the files in your current directory. It shows which files have changes that are not yet staged.

2. Stage files for a commit:

   git add <filename>

   Replace <filename> with the file you want to stage. Use git add . to stage all changed files.

3. Commit staged files to the repository:

   git commit -m "Commit message"

   Replace "Commit message" with a brief note about the changes included in the commit.

Branches are used to develop features isolated from each other. The master branch is the "default" branch when you create a repository. Use other branches for development and merge them back to the master branch upon completion.

1. Create a new branch:

   git branch <branch-name>

   Replace <branch-name> with the name of the branch you want to create.

2. Switch to a different branch:

   git checkout <branch-name>

   This command lets you switch from one branch to another.

3. Merge a branch into the active branch:

   git merge <branch-name>

   Replace <branch-name> with the branch you want to merge into your active branch.

Once you have committed your changes, you need to push them to the GitHub repository.

git push origin <branch-name>

Replace <branch-name> with the branch you want to push. This command sends your committed changes to GitHub.

To fetch and merge changes from the remote repository to your local machine:

git pull

This command fetches changes from the remote repository of your current branch and merges them into your local directory.

To see the commit history of your repository:

git log

This command shows the detailed commit history for the current branch.

Using these basic Git commands, you can handle a variety of tasks in your development workflow, from simple commits to complex merges. Practice these commands to get comfortable with them, as mastery of Git is essential for efficient collaboration in software development projects.

Yes, you can disconnect a local folder from a GitHub repository and attach a new local folder to a different repository. This process involves modifying the Git remote settings in your local repositories. Here's how you can do it step by step:

1. Open your terminal and navigate to the local folder you want to disconnect:

   cd path/to/your/local/folder

2. Remove the existing Git remote. This is the link between your local folder and the GitHub repository:

   git remote remove origin

   The origin is a shorthand name for the remote repository your local repository was pointing to. By removing it, you sever the link to the GitHub repository but retain the local Git history and configuration.

3. Optional: Delete the local Git repository (if you want to completely remove all Git tracking from the local folder):

   rm -rf .git

   This command deletes the .git directory which contains all the Git tracking data. Be careful with this step as it will erase all version history in the local folder.

To attach a new local folder to a GitHub repository, follow these steps:

1. Create a new local folder or navigate to an existing one:

   cd path/to/your/new/local/folder

2. Initialize a new Git repository if the folder is not already a Git repository:

   git init

3. Add the GitHub repository as a remote to your local repository. First, find or create a new repository on GitHub and copy its URL. Then, execute the following command:

   git remote add origin https://github.com/username/repository.git

git pull https://github.com/torarnehave1/slowyou.net main

Replace https://github.com/username/repository.git with the actual URL of your GitHub repository.

4. Verify that the remote has been added:

   git remote -v

   This command shows the URLs that Git has stored for the shortcut names origin. It should display the URL of your new GitHub repository associated with fetch and push actions.

5. Pull any existing content from the GitHub repository or start adding your own content:

   git pull origin main --allow-unrelated-histories

   Use this command if you want to merge the history of an existing repository with your local one, especially when the repositories are unrelated. Alternatively, if the GitHub repository is empty, you can start adding new files:

   touch README.md
   git add .
   git commit -m "Initial commit"

6. Push your local changes to the GitHub repository:

   git push -u origin main

   This command pushes your local branch to the main branch on GitHub and sets it to track the remote branch.

By following these steps, you can effectively manage which local directories are connected to which GitHub repositories, allowing for flexible project management and version control configurations.