Forem: Iryna Trush

21 essential Git Commands Explained in 11 minutes

Iryna Trush — Thu, 20 Feb 2025 06:26:55 +0000

Since graduating from my coding bootcamp, I've worked on multiple solo projects and collaborated on many more. And no matter what language I was using – whether it was TypeScript or Python – one thing remained the same: Git.

Git is essential to my workflow, helping me organize projects and collaborate efficiently.

In this tutorial, I will walk you through 21 essential Git commands that'll instantly boost your productivity and streamline your development workflow.

Before we start, a few things you should know:

Git is not GitHub. Git is a version control system, while GitHub is a platform that hosts Git repositories. They work together, but are distinct tools.
What is a version control system? It is a tool that records every change made to a set of files (like your code), allowing you to revert to earlier versions, compare changes, and collaborate more effectively.
In this tutorial, you will find 21 commands that will provide a good starting point for learning Git, but Git is more complex than that. In the Resources section, you will find excellent further reading—the same resources I used when I was first learning Git.
In Git, files go through three main stages:

Unstaged (Modified): This is when you've made changes to a file in your working directory, but Git isn't tracking those specific changes yet.

Staged: You've used the git add command to tell Git that you want to include these changes in the next commit. Think of it as preparing your changes to be saved.

Committed: You've used the git commit command to save the changes in the staging area to your Git repository. This creates a permanent record of those changes.

Initializing and Cloning
Staging and Committing Changes
Working with Remote Repositories and Merging
Branching
Inspecting and Comparing
Undoing Changes
Other Commands
Resources

Initializing and Cloning

Initializing a new repository or cloning an existing one are likely the very first things you'll do with Git. These commands let you start a new version-controlled project or join an existing one by getting a local copy.

1. `git init`

Purpose: Initializes a new Git repository.

Use Case: You are starting a new project and want to use Git for version control. This command creates the necessary Git infrastructure in your project directory.

Command:

git init

Often used with:

git add .  # Adds all files in the directory to the staging area.
git commit -m "Initial commit"  # Creates the first commit.

2. `git clone`

Purpose: Clones an existing repository into a new directory.

Use Case: You want to work on a project that's already hosted on a remote repository like GitHub. This command copies the entire repository to your local machine.

Command:

git clone https://github.com/user/repo.git

Often used with:

cd <repository-name>  # Changes the directory to the cloned repository.
git remote -v  # Verifies the remote repository URL.

Staging and Committing Changes

Staging and committing in Git records your changes. Staging prepares a snapshot, and committing saves it. These commands are crucial for saving your work, creating project history, and reverting to previous states.

3. `git add`

Purpose: Adds changes in the working directory to the staging area, preparing them for the next commit.

Use Case: You've made changes to some files and are ready to save them. You use git add to select which of those changes you want to include in the next commit.

You can add all changes by using a single dot (.), or you can add specific file or files. See example:

Command:

git add .  # Adds all changes in the current directory and its subdirectories
git add *.txt   # Adds all files ending in .txt
git add file1.txt file2.txt  # Adds specific files

Often used with:

git status  # Common to use before `git add` to see what files have changed and which ones are untracked.
git commit -m "Commit message"  # Commits the staged changes.

4. `git commit`

Purpose: Records the changes currently in the staging area to the repository. This creates a permanent record of your work.

Use Case: You've staged the changes you want to save, and now you're ready to create a snapshot of your project at this point in time.

Command:

git commit -m "Descriptive commit message"
git commit -a -m "Commit message" # Stages all changes and commits in one command (use with caution)

Best practice: Always write clear, descriptive commit messages. This significantly improves collaboration and makes it easier to understand the history of your project. Although the -a option can be used as a shortcut, explicitly staging changes with git add provides more control and is generally preferred.

Often used with:

git log  # View the project's commit history. Often used to review your commits.
git push  # Upload your local commits to a remote repository (e.g., GitHub, GitLab). Typically used after committing.

5. `git push`

Purpose: Updates the remote repository with local commits.

Use Case: You want to upload local changes to a remote repository like GitHub.

git push origin main # Push local commits to main branch

Often used with:

git remote add origin <remote_url>  # Adds the remote repository.
git pull origin main  # Ensures you have the latest changes before pushing.

Working with Remote Repositories and Merging

Collaboration is key in software development. To work with others and keep your codebase up-to-date, you need to interact with remote repositories. Fetching changes, merging updates, and managing remote connections are essential to teamwork, allowing you to share your work, integrate contributions from others, and maintain a synchronized project. Here are some important commands you should know:

6. `git fetch`

Purpose: Downloads changes from a remote repository to your local repository.

Think of it as getting the latest information from the remote, but not yet applying it.

Use Case: You want to see what changes have been made on the remote before deciding whether or not to incorporate them into your work. This is a good way to review changes before merging.

Command:

git fetch origin # Get changes from the 'origin' remote, but doesn't merge them.

Often used with:

git merge origin/<branch_name>  # Merges the fetched changes.
git remote -v  # Verifies the remote repository.

7. `git merge`

Purpose: Takes the changes from the specified branch and applies them to your current branch.

If there are conflicts (e.g., the same lines of code were modified in both branches), you'll need to resolve them manually.

Use Case: You want to incorporate the latest changes from the remote into your working branch. Or, you've finished working on a feature branch and want to merge it back into the main branch.

Command:

git merge new-feature  # Merge the 'new-feature' branch into the current branch.

Often used with:

git checkout <branch_name>  # Switches to the target branch.
git branch -d <branch_name>  # Deletes a merged branch.

8. `git pull`

Purpose: Downloads changes from the remote and immediately integrates them into your current branch.

git pull is essentially a shortcut for git fetch followed by git merge. When you run git pull origin main(for example), Git does the following behind the scenes:

git fetch origin: Fetches the latest changes from the main branch on the origin remote and updates your local origin/main branch.
git merge origin/main: Merges the changes from your local origin/main branch into your currently active branch (e.g., your local main branch).

Use Case: You want to quickly update your current branch with the latest changes from the remote. This is commonly used when you're working on a shared branch and want to keep your local copy synchronized.

Command:

git pull origin main  # Pulls changes from the 'main' branch of the 'origin' remote.

Often used with:

git log origin/main  # View the commit history of the remote 'main' branch to see what changes have been made.

git diff origin/main # See the specific differences between your local 'main' branch and the remote 'main' branch before pulling. This helps you understand exactly what will change.

9. `git rebase`

Purpose: Integrates changes from one branch into another by rewriting the commit history to create a linear sequence of commits.

git rebaseis an alternative command to git merge. The major difference between the two is that git merge applies the fetched changes on top of your current branch, creating an additional merge commit.

Rebase, on the other hand, applies the fetched changes as a new base for your branch and then replays your changes on top of that new base.

Afterward, it rewrites the history, incorporating any merge changes into your latest commit. This allows you to avoid unnecessary merge commits and is therefore often preferred for maintaining a clean and less verbose history.

Rebase is frequently used as the default strategy for git pull by setting git config --global pull.rebase true.

Use Case: You want to integrate changes from one branch into another by rewriting history.

Command:

git checkout feature-branch  # Switch to the feature branch that you want to rebase. 
git rebase main # Rebase the 'feature-branch' onto 'main'. This replays the commits from 'feature-branch' on top of 'main'.

Often used with:


git log  # Checks the commit history after rebasing.

10. `git remote`

Purpose: Manages set of tracked repositories.

Use Case: You want to add, remove, and list remote repositories.

Command:

git remote add origin https://github.com/user/repo.git

Often used with:

git remote -v  # Lists remote repositories and their URLs.
git fetch <remote_name>  # Fetches changes from a remote repository.

Branching

Branching is a powerful Git tool that lets you create parallel lines of development. It allows you to isolate changes, experiment safely, and manage different versions of your project effectively, before merging those changes.

11. `git branch`

Purpose: Manages branches.

Usage: Use git branch to create, list, switch between, delete, and rename branches. This is crucial for managing concurrent development, isolating features, and keeping the main branch stable.

Command:

git branch
# Lists all branches

git branch new-feature
# Creates a new branch named "new-feature"

git checkout -b <branch_name> 
# Creates a new branch and switches to it.

Often used with:

git checkout <branch_name>  # Switches to a branch.
git merge <branch_name>  # Merges a branch.

12. `git checkout`

Purpose: Switches branches or restores working tree files.

Use Case: You want to navigate between different branches.

Command:

git checkout new-feature # Switches the current branch to 'new-feature'.
#Any changes made after this point will be committed to the 'new-feature' branch.

Often used with:

git branch <branch_name>  # Creates a new branch.

Inspecting and Comparing

Git provides powerful tools for inspecting and comparing your repository. Understanding commit logs, differences between versions, and details of specific changes is key to navigating your project's history, debugging issues, and understanding the evolution of your codebase.

13. `git log`

Purpose: Shows the commit logs.

Use Case: At its most basic, git log lets you see the order in which changes were made to the project. This is crucial for understanding how the project has evolved over time, which features were added when, and what bug fixes were implemented.

Note: When the output of git log is too long, Git uses a pager (often less or sometimes vim) to display it.

If less is used, press q to exit.
If vim is used, press Esc, then type :q and press Enter to exit.

Command:

git log

Often used with:

git show <commit_hash>  # Shows details of a specific commit.
git diff <commit_hash1> <commit_hash2>  # Shows differences between two commits.

14. `git diff`

Purpose: Displays changes between commits/working tree.

Use Case: You want to compare changes in the repository.

Command:

git diff  # Shows changes between the working directory and the staging area.

Often used with:

git add .  # Stages all changes in the current directory, preparing them for a commit.
git commit -m "Commit message"  # Commits the changes.

15. `git show`

Purpose: Shows various types of objects.

Use Case: You want to display information about a specific commit, tag, or file.

Command:

git show <commit-id>  # Displays information about the specified commit.

Often used with:

git log  # Finds the commit ID.
git diff <commit-id1> <commit-id2>  # Compares changes between commits.

Undoing Changes

Git is designed to let you undo changes effectively. Knowing how to reset commits, unstage files, or stash changes is crucial for recovering from errors, cleaning up your working directory, and confidently experimenting without fear of permanently breaking things.

16. `git reset`

Purpose: Resets the current HEAD to the specified state.

This command is powerful and has different effects depending on the options used, particularly on the staging area and working directory. It's crucial to understand these differences to avoid accidental data loss.

Use Case: You want to undo changes, but how you undo them is determined by the specific reset type.

Key Differences and Potential Data Loss:

Option	HEAD Pointer	Staging Area	Working Directory	Data Loss Potential
`--soft`	Moves	Unchanged	Unchanged	No
`--mixed`	Moves	Resets to match the new HEAD	Modified: unstaged changes from the old HEAD	Low
`--hard`	Moves	Resets to match the new HEAD	Resets to match the new HEAD (loses unstaged changes)	High

Command:

git reset HEAD file-name  # Unstages a specific file
git reset --hard HEAD  # Discards all changes in the working directory and staging area

Often used with:

git status  # Checks the status after resetting.
git checkout .  # Discards changes in the working directory.

17. `git stash`

Purpose: Temporarily saves uncommitted changes.

Use Case: When you want to switch branches but don't want to commit changes yet and don't want to lose them, git stashwill help.

Command:

git stash
# Saves changes
git stash pop
# Restores saved changes

Often used with:


git checkout <branch_name>  # Switches to another branch.
git stash list  # Lists all stashed changes.

Other Commands

18. `git tag`

Purpose: Creates, lists, deletes or verifies a tag object signed with GPG.

Use Case: You want to mark specific points in history as important (e.g., releases).

Command:

git tag -a v1.0 -m "Version 1.0 release"

Often used with:


git tag  # Lists all tags.
git show v1.0  # Shows details of the v1.0 tag.
git push origin --tags  # Pushes tags to the remote repository.

19. `git rm`

Purpose: Removes files from the working tree and from the index (staging area).

Use Case: You want to delete files from the repository.

Command:

git rm file-name  # Removes the file from the working directory and stages the deletion for the next commit.

Often used with:

git commit -m "Removed file-name"  # Commits the removal.
git status  # Checks the status after removing the file.
git add .  # Stages the removal.

20. `git status`

Purpose: Displays the state of the working directory and staging area.

Use Case: The git status command is essential for understanding the current state of your Git repository. It provides a summary of changes you've made to your project files, distinguishing between those that are tracked by Git, those that are staged for commit, and those that are untracked.

Command:

git status # Shows the current status of the working directory and staging area

Often used with:

git add .  # Stages changes.
git commit -m "Commit message"  # Commits changes.

21. `git reflog`

Purpose: Records updates to the tip of branches and other symbolic refs.

It's a history of where your HEAD and branch pointers have been, allowing you to recover from accidental changes or understand your past actions. Think of it as a local history of your Git actions that is not shared with others when pushing to a remote repository.

Use Case:

Recovering lost commits: If you accidentally delete a branch or overwrite changes, reflog can help you find the commit hash before the mistake.
Understanding your steps: Reflog shows you the sequence of commands you've executed, which can be useful for debugging or retracing your steps.
Identifying the source of a change: If you see unexpected changes, reflog can help you pinpoint when and how they were introduced.

Command:

git reflog show [ref]  # Shows reflog for [ref] (default: current branch)
git reflog show --all # Shows reflog for all refs.

Often used with:

git checkout <commit-hash> # Go to a reflog commit.

Resources

git help: The fastest way to get help with a specific Git command. Just type git help <command> in your terminal.
Official Git Documentation: https://git-scm.com/ - For in-depth information and advanced topics.
Pro Git Book: https://git-scm.com/book/en/v2 - A great resource for learning Git from scratch or deepening your understanding.

Tip: Start with the Pro Git book if you're new to Git.

Final Thoughts

Learning Git was a game-changer for me. These are the commands I use most often, and they've significantly improved my productivity. I hope they improve yours too.

Essential JavaScript Events for Developers

Iryna Trush — Thu, 17 Oct 2024 22:56:15 +0000

Building interactive applications relies heavily on understanding how to handle user interactions. Here is a list of seven essential JavaScript events that every developer should know:

*Code snippets are written in React and TypeScript.

1. `onClick`

Purpose: Triggers when an element is clicked.
Usage: Commonly used for buttons, links, and other clickable elements to handle user actions like form submissions, opening modals, etc.


<button onClick={handleClick}> Click Me </button>

const handleClick = () => {
  console.log("Button clicked!");
};

2. `onChange`

Purpose: Triggered when the value of an input element changes.
Usage: Essential for form inputs to update the component's state as the user types.


import { useState } from "react";

function MyComponent() {
  const [inputValue, setInputValue] = useState(""); // Define state for input value

  const handleInputChange = (event: React.ChangeEvent<HTMLInputElement>) => {
    setInputValue(event.target.value); // Update the state with the new input value
  };

  return (
    <input
      type="text"
      value={inputValue}
      onChange={handleInputChange} // Handle the change event
    />
  );
}

export default MyComponent;

Note the use of React.ChangeEvent in the handleInputChange function.
It is very important to use the correct event type. Here are some of the most common event types:

React.ChangeEvent for onChange on input elements.
React.FormEvent for onSubmit on forms.
React.KeyboardEvent for onKeyDown on input elements.
React.MouseEvent for onMouseEnter and onMouseLeave on div elements.

3. `onBlur`

Purpose: Triggers when an element loses focus.
Usage: Often used for form validation after the user moves away from an input field.

<input type="text" onBlur={handleBlur} />

const handleBlur = () => {
  console.log("Input lost focus");
};

4. `onFocus`

Purpose: Triggers when an element gains focus.
Usage: Useful for actions when an input field is focused, like showing a tooltip or highlighting the field.

<input type="text" onFocus={handleFocus} />

const handleFocus = () => {
  console.log("Input gained focus");
};

5. `onSubmit`

Purpose: Triggers when a form is submitted.
Usage: Handles form submissions, typically preventing the default form submission behavior to process it with JavaScript.
Important: The onSubmit event should be attached to the <form>element, not the submit button. This ensures correct handling regardless of whether the user clicks the submit button or presses Enter. The button element has type="submit", which triggers the form's onSubmit event when clicked.

<form onSubmit={handleSubmit}>
  <input type="text" value={inputValue} onChange={handleInputChange} />
  <button type="submit"> Submit </button>
</form>

const handleSubmit = (event: React.FormEvent<HTMLFormElement>) => {
  event.preventDefault();
  console.log("Form submitted");
};

6. `onKeyDown`

Purpose: Triggers when a key is pressed down.
Usage: Handles keyboard events, such as submitting a form when the Enter key is pressed.

<input type="text" onKeyDown={handleKeyDown} />

const handleKeyDown = (event: React.KeyboardEvent<HTMLInputElement>) => {
  if (event.key === "Enter") {
    console.log("Enter key pressed");
  }
};

7. `onMouseEnter` and `onMouseLeave`

Purpose: Triggers when the mouse pointer enters or leaves an element.
Usage: Handles hover effects, like showing a tooltip or changing an element's style.

<div onMouseEnter={handleMouseEnter} onMouseLeave={handleMouseLeave}>
  Hover over me
</div>

const handleMouseEnter = () => {
  console.log("Mouse entered");
};

const handleMouseLeave = () => {
  console.log("Mouse left");
};

Building a language learning app and need an API? Read How to use Free dictionary API

How to use Free dictionary API

Iryna Trush — Tue, 24 Sep 2024 21:41:59 +0000

Cover photo by Christopher Gower on Unsplash

The Free Dictionary API is a powerful tool that enables developers to easily integrate lexical data into their projects. It provides access to a comprehensive collection of English word definitions, phonetic transcriptions, and related linguistic information.

Whether you're building a language learning application, enhancing a spell-checking feature, or requiring dictionary data for any other purpose, the Free Dictionary API offers a straightforward solution for retrieving and utilizing this valuable resource.

In this API documentation:

Overview
Endpoint
Examples
Project
Additional resources

Overview:

Developed by meetDeveloper and reaching 2.6k stars on GitHub, the Free Dictionary API offers a simple way to integrate dictionary data into your applications.

Note: API supports only GET requests.

Key Features:

Free to use
No usage limits
No authorization or API keys required

Endpoint

https://api.dictionaryapi.dev/api/v2/entries/en/<word>

This endpoint retrieves dictionary information for the specified English word.
The API has two versions: v1 and v2. The primary difference lies in the response structure. Current version is v2.

Query Parameters

word (string, required): The word you want to look up.

Response Format

The API returns a JSON array containing a single object with detailed information about the word, including:

If the request is successful:

word (string): The queried word.
phonetic (string): The phonetic transcription of the word.
phonetics (array): An array of phonetic objects, each with:
- text (string): The phonetic transcription.
- audio (string): A URL to an audio pronunciation (may be empty).
meanings (array): An array of objects representing different meanings of the word, each with:
- partOfSpeech (string): The part of speech (e.g., noun, verb).
- definitions (array): An array of definition objects, each with:
- definition (string): The definition of the word.
- synonyms (array): An array of synonyms.
- antonyms (array): An array of antonyms.
license (object): Information about the license under which the data is provided.
sourceUrls (array): An array of URLs to the sources of the data.

If the request is not successful:

title (string): A message indicating that no definitions were found for the word
message (string): Message that the definitions for the word was not found
resolution(string): Suggestion to use search again or web.

Examples:

Example Request 1 (successful):

const word = "documentation";
fetch(`https://api.dictionaryapi.dev/api/v2/entries/en/${word}`)
  .then(response => response.json())
  .then(data => console.log(data));

Example Response 1:

[
  {
    "word": "documentation",
    "phonetic": "/ˌdɒkjʊmənˈteɪʃən/",
    "phonetics": [
      {
        "text": "/ˌdɒkjʊmənˈteɪʃən/",
        "audio": ""
      },
      {
        "text": "/ˌdɑkjəmənˈteɪʃən/",
        "audio": ""
      }
    ],
    "meanings": [
      {
        "partOfSpeech": "noun",
        "definitions": [
          {
            "definition": "Something transposed from a thought to a document; the written account of an idea.",
            "synonyms": [],
            "antonyms": []
          },
          {
            "definition": "Documentary evidence and sources.",
            "synonyms": [],
            "antonyms": []
          },
          {
            "definition": "Documents that explain the operation of a particular machine or software program.",
            "synonyms": [],
            "antonyms": []
          },
          {
            "definition": "Comments that explain the usage of individual functions, libraries and blocks of code.",
            "synonyms": [],
            "antonyms": []
          }
        ],
        "synonyms": [],
        "antonyms": []
      }
    ],
    "license": {
      "name": "CC BY-SA 3.0",
      "url": "https://creativecommons.org/licenses/by-sa/3.0"
    },
    "sourceUrls": [
      "https://en.wiktionary.org/wiki/documentation"
    ]
  }
]

Example Request 2 :

const word = "Software engineer";
fetch(`https://api.dictionaryapi.dev/api/v2/entries/en/${word}`)
  .then(response => response.json())
  .then(data => console.log(data));

Example Response 2 (not successful):

{
  "title": "No Definitions Found",
  "message": "Sorry pal, we couldn't find definitions for the word you were looking for.",
  "resolution": "You can try the search again at later time or head to the web instead."
}

Success and Error codes

This API does not currently return specific success or error codes.

Code it up

Now that you understand how to use an API, it's time for practice.

Let's build a simple dictionary lookup web application using HTML, CSS, and JavaScript. This application will allow users to enter a word into a search bar, click a button, and see the word's definition.

First, we'll create the HTML structure. We'll need an input field for the user to enter the word, a button to trigger the search, and a <div> to display the results.

      <input
        type="text"
        id="input"
        class="search-input"
        placeholder="Enter a word"
        aria-label="Enter a word to look up"
      />
      <button id="btn" class="btn" aria-label="Look up the word">
        Look up
      </button>
      <div id="result" class="result"></div>
    </div>

Next, we will write the JavaScript code to handle the user input, fetch the word meaning from the Free Dictionary API, and display the results:

We'll start by getting references to the HTML elements using
document.getElementById:

const btn = document.getElementById("btn");
const wordInput = document.getElementById("input");
const displayResultDiv = document.getElementById("result");

Next step - add an event listener to the button to handle the click event. When the button is clicked, we'll retrieve the word entered by the user and call the getMeaning function.

btn.addEventListener("click", () => {
  const word = wordInput.value.trim();
  if (word) {
    getMeaning(word);
  } else {
    displayResultDiv.textContent = "Please enter a word.";
  }
});

Now, let's implement the getMeaning function to fetch the definition from the Free Dictionary API:

const getMeaning = async (word) => {
  try {
    const response = await fetch(
      `https://api.dictionaryapi.dev/api/v2/entries/en/${word}`
    );
    if (!response.ok) {
      throw new Error("Sorry. Word not found");
    }
    const data = await response.json();
    displayMeaning(data);
  } catch (error) {
    displayResultDiv.textContent = error.message;
  } finally {
    wordInput.value = "";
  }
};

This function fetches the word's definition from the API. If the word is found, it calls the displayMeaning function to display the results. If an error occurs (e.g., the word isn't found), it displays an error message. The finally block clears the input field after the search, regardless of success or failure.

Finally, let's create the displayMeaning function to format and display the definition:

const displayMeaning = (data) => {
  const wordData = data[0];
  const phonetics = wordData.phonetics
    .map(
      (p) =>
        `<div class="result-item">${p.text} <audio class="result-audio" controls src="${p.audio}"></audio></div>`
    )
    .join("");
  const meanings = wordData.meanings
    .map((meaning) => {
      const definitions = meaning.definitions
        .map((def) => `<li>${def.definition}</li>`)
        .join("");
      return `<div class="result-item"><strong>${meaning.partOfSpeech}</strong><ul>${definitions}</ul></div>`;
    })
    .join("");

  displayResultDiv.innerHTML = `
    <h2 class="result-title">${wordData.word}</h2>
    <div>${phonetics}</div>
    <div>${meanings}</div>
    <div class="result-item"><a href="${wordData.sourceUrls[0]}" target="_blank">Source</a></div>
  `;
};

This function extracts the relevant information from the API response, formats it into HTML, and sets the innerHTML of the displayResultDiv. It handles phonetics (including optional audio) and definitions, and provides a link to the source.

This completes the core functionality of the dictionary lookup application. You can further enhance it with CSS styling and error handling. A complete demo, including CSS, can be found at this link to the project.

Additional resources

To try the API or support the Free Dictionary API, go to Free Dictionary API website.

Forem: Iryna Trush

21 essential Git Commands Explained in 11 minutes

Table of Contents

Initializing and Cloning

1. git init

2. git clone

Staging and Committing Changes

3. git add

4. git commit

5. git push

Working with Remote Repositories and Merging

6. git fetch

7. git merge

8. git pull

9. git rebase

10. git remote

Branching

11. git branch

12. git checkout

Inspecting and Comparing

13. git log

14. git diff

15. git show

Undoing Changes

16. git reset

17. git stash

Other Commands

18. git tag

19. git rm

20. git status

21. git reflog

Resources

Final Thoughts

Essential JavaScript Events for Developers

1. onClick

2. onChange

3. onBlur

4. onFocus

5. onSubmit

6. onKeyDown

7. onMouseEnter and onMouseLeave

How to use Free dictionary API

In this API documentation:

Overview:

Key Features:

Endpoint

Query Parameters

Response Format

If the request is successful:

If the request is not successful:

Examples:

Example Request 1 (successful):

Example Response 1:

Example Request 2 :

Example Response 2 (not successful):

Success and Error codes

Code it up

Additional resources

1. `git init`

2. `git clone`

3. `git add`

4. `git commit`

5. `git push`

6. `git fetch`

7. `git merge`

8. `git pull`

9. `git rebase`

10. `git remote`

11. `git branch`

12. `git checkout`

13. `git log`

14. `git diff`

15. `git show`

16. `git reset`

17. `git stash`

18. `git tag`

19. `git rm`

20. `git status`

21. `git reflog`

1. `onClick`

2. `onChange`

3. `onBlur`

4. `onFocus`

5. `onSubmit`

6. `onKeyDown`

7. `onMouseEnter` and `onMouseLeave`