DEV Community: Jalaj

Managing Two GitHub Accounts on Your Mac

Jalaj — Wed, 01 Nov 2023 11:15:08 +0000

If you find yourself juggling between work and personal GitHub accounts on your Mac, you're not alone. This guide will walk you through the steps to set up and manage two separate GitHub accounts with ease. I've tested these steps on MacOS Ventura M1, but they should work for most Mac users. If you're using Linux, you may need to adapt the commands accordingly. Apologies to Windows users as this guide is tailored for macOS.

Quick Tip: For a summary of the steps, scroll to the bottom for a TL;DR.

Setting up SSH Keys

We need to set up two SSH keys, one for work and another one for the personal account. Give them clear names, like jalaj-work-github and jalaj-personal-github.

Here's how you can create SSH keys for both accounts:

ssh-keygen -t rsa -C "jalaj@work.com" -f "jalaj-work-github"

After running this command, you'll be prompted to enter a passphrase. You can choose something memorable or leave it empty to avoid entering it every time you push or pull.

Similarly, create an SSH key for your personal account:

ssh-keygen -t rsa -C "jalaj@personal.com" -f "jalaj-personal-github"

After running these commands, navigate to the SSH directory by using the command:

cd ~/.ssh

Run the ls command to verify that you have four files:

jalaj-work-github
jalaj-work-github.pub
jalaj-personal-github
jalaj-personal-github.pub

One is a public file, and the other is private. Now, copy the content of the .pub file and add it to the SSH keys section of the respective GitHub account.

Here's how to copy the content to your clipboard:

pbcopy < jalaj-work-github.pub

Now, go to GitHub and set up the SSH key. You can do that by following the steps mentioned in the github docs to add SSH key to your account

After completing this step, add the private keys to the Apple Keychain. Assuming you are still in the ~/.ssh directory, use the following command:

ssh-add --apple-use-keychain jalaj-work-github

Replace "jalaj-work-github" with the actual file path.

Do the same for the other account.

Configuring SSH

Now, create a configuration file for SSH to know which configuration to use based on the origin.

In the ~/.ssh directory, create a file named config if it doesn't already exist:

touch config && code config # or vi config

Add the following content to the config file:

Host github.com-work
  HostName github.com
  User git
  IdentityFile ~/.ssh/jalaj-work-github

Host github.com-personal
  HostName github.com
  User git
  IdentityFile ~/.ssh/jalaj-personal-github

After adding this, whenever you pull a repo or create a new repo, you need to update the remote URL for the repo to match the host value in the config.

Here's a one-liner to do just that:

git remote set-url origin git@github.com-personal:username/reponame.git

Breaking it down:

"git@github.com-personal" is the host added in the config file.
"username" is your GitHub username.
"reponame" is your GitHub repository name.

Setting Up User Information

To let Git know your email and username to attach to the commits, you have two options: manual setup for each repo or using Git config files.

For the manual setup for each repo, run these commands:

git config --local user.email "jalaj@personal.com"
git config --local user.name "jalaj"

You need to remember to do this for every repo on your system.

To make this easier, you can set a global config for work/personal GitHub accounts and manually configure the other one:

git config --global user.email "jalaj@work.com"
git config --global user.name "jalaj"

For an even easier approach, you can use Git config files.

First, open or create a ~/.gitconfig file in the root directory, and create two other files: ~/.gitconfig-work and ~/.gitconfig-personal:

touch ~/.gitconfig ~/.gitconfig-work ~/.gitconfig-personal

Open ~/.gitconfig-work in your favorite editor and add the following values:

[user]
 name = jalaj
 email = jalaj@work.com

Do the same for the ~/.gitconfig-personal file.

Now, open ~/.gitconfig and add the following condition:

[includeIf "gitdir:~/projects/personal/"]
  path = ~/.gitconfig-personal
[includeIf "gitdir:~/projects/work/"]
  path = ~/.gitconfig-work

This configuration loads the correct config file based on the directory where your project resides. Feel free to change the directory to match your work and personal projects.

With all these steps, you can now use both personal and work GitHub accounts on a single system, and everything will work automatically due to the one-time setup you've completed.

Summary

SSH Key Setup

Generate two SSH keys: one for work and one for personal accounts.
- ssh-keygen -t rsa -C "jalaj@work.com" -f "jalaj-work-github"
- ssh-keygen -t rsa -C "jalaj@personal.com" -f "jalaj-personal-github"
Copy the content of the .pub files to your GitHub accounts.

Keychain Configuration

Add the private keys to Apple Keychain.
- ssh-add --apple-use-keychain jalaj-work-github
- Repeat for the other account.

SSH Configuration

Create a config file in ~/.ssh with host-specific settings.
- Define Hosts for both work and personal GitHub accounts.
- Specify the IdentityFile for each.

Update Git Remotes

For existing repositories, update the remote URL to match the host value in the config file.
- git remote set-url origin git@github.com-personal:username/reponame.git

User Information

Set your email and username for commits.
- For each repository, use:
- git config --local user.email "jalaj@personal.com"
- git config --local user.name "jalaj"
- Or set a global config:
- git config --global user.email "jalaj@work.com"
- git config --global user.name "jalaj"

Advanced Git Config (Optional)

Create and configure ~/.gitconfig, ~/.gitconfig-work, and ~/.gitconfig-personal files to manage user information for different projects based on their directory.

With these steps, you can effectively manage both your personal and work GitHub accounts on your Mac. If you have any questions or doubts, feel free to reach out, and you can also contact me on Twitter. Thanks for reading!

Everything About JavaScript String.prototype.replace() Method

Jalaj — Thu, 16 Apr 2020 08:15:22 +0000

Replacing text in a string is a very common task and with the help of replace() method available on String.prototype, we can do it very easily.

Syntax

const newString = str.replace(regExp|substring , newSubstring|function)

The replace() method takes two arguments, first argument can be a string or regular expression and the second argument can either be a replacement string or a function whose return value will then be taken as replacement string.

Strings are immutable in JavaScript. That's why replace() returns a new string

The simplest use-case of this method is just by providing a string to match as first argument and a replacement string as second argument.

let str = 'I Love Java';

console.log(str.replace('Java', 'JavaScript')); // Expected Output: I Love JavaScript

Replace operations can be easily chained.

let str = 'I Love Java';
let str2 = str.replace('Java', 'JavaScript')
              .replace('JavaScript', 'Pizza');
console.log(str2); // I Love Pizza

In the replace string we can use special replacement patterns, for example we can use $& to insert the match.

let myStr = 'Java is Awesome'
console.log(myStr.replace('Java', '$&Script')) // JavaScript is Awesome

Some other replacement patterns:

$$ - Inserts a "$".
$` - Inserts the portion of the string that precedes the matched substring.
$' - Inserts the portion of the string that follows the matched substring.

There is also a pattern $n which inserts the nth match, but for this to work we have to use regular expression to match the string as explained in the next section.

Using Regular Expressions as first argument in `replace()`

Matching an exact string is good, but most of the times we find ourselves needing to match a pattern instead. It can easily be done by using a regular expression as the first argument.

In the following example, the regular expression is defined in replace().

let str = 'A Quick Brown Fox'
let newstr = str.replace(/brown/i, 'white')
console.log(newstr) // A Quick white Fox

In the above regular expression we used i flag. This flag ignores the case.

Checkout this guide by MDN to learn more about regular expresssions.

Let's take another example to show the use of $n replacement pattern.

let str = 'Regular Expressions';
let regex = /(\w+)\s(\w+)/;
let newstr = str.replace(regex, '$1 $2 are evil');
console.log(newstr); // Regular Expressions are evil

/(\w+)\s(\w+)/ - This regex matches two words separated by a space character.
$1 will be equal to whatever first capturing group (regex inside the parenthesis) captures, in our case its the string 'Regular'.
Similarly $2 will be equal to the result to second capturing group which is 'Expressions'.
In the end we use $1 , $2 to create new string.

Using a Function as a second argument in `replace()`

We can use a function as a second argument for replace(), this function is known as Replacer Function. This function is invoked after the match has been performed. This function's result (return value) will be used as the replacement string.

The various possible arguments of this function are discussed below:

match - The matched string.
p1, p2, ... - The nth string found by a parenthesized capture group, provided the first argument to replace() was a RegExp object. For example, if /(\w+)(\d+)/, was given, p1 is the match for \w+, and p2 for \d+.
offset - The offset (index) of the matched string within the whole string being examined. (For example, if the whole string was 'abcd', and the matched string was 'bc', then this argument will be 1.)
originalString - The full string.

Let's see it in action through an example.

function replacerFunction(match, p1, p2, offset, originalString) {
    return (p1 - 1) + (p2);
} 

let myStr = '99 Bottles Of Bear On The Wall';
let regex = /(\d{2})(\w*)/;
let newStr = myStr.replace(regex, replacerFunction);

console.log(newStr); // 98 Bottles Of Bear On The Wall

In above example our first capture group matches the digit '99' and second one matches the rest of the string. After that the replacer function return the modified result.

Let's see how to create a very-very simple and silly url slug generator using replace().

let title = 'My Awesome Post';

let urlSlug = title.replace(/(\w+)\s(\w+)\s(\w+)/, function (match, p1, p2, p3) {
  return `${p1}-${p2}-${p3}`;
});

console.log(urlSlug); // My-Awesome-Post

Aaaand That's all. I hope you learned something useful from this post. If anything is not clear, let me know in comments. :)