DEV Community: krisperu

Basic Intro to Rails Serializers

krisperu — Fri, 15 Apr 2022 19:23:50 +0000

When working with Rails, it is simple to create a JSON object. Using an index or show method, will provide a list of all the data available.

#The Rails index method
def index
    render json: Book.all
end

#Returns this JSON hash
[
    {
        "id": 1
        "title": "Pride and Prejudice",
        "author": "Jane Austen",
        "description": "Set in England in the early 19th century, Pride and Prejudice tells the story of Mr and Mrs Bennet's five unmarried daughters after the rich and eligible Mr Bingley and his status-conscious friend, Mr Darcy, have moved into their neighbourhood. While Bingley takes an immediate liking to the eldest Bennet daughter, Jane, Darcy has difficulty adapting to local society and repeatedly clashes with the second-eldest Bennet daughter, Elizabeth.", 
        "image": "https://d1w7fb2mkkr3kw.cloudfront.net/assets/images/book/lrg/9781/4351/9781435159631.jpg", 
        "year": 1813,
        "genre": "Romance",
        "isbn": 9780140430721,
        "publisher": "T. Egerton, Whitehall",
        "length": 259,  
        "reading_time": 1, 
        "rating": 5,
        "created_at": "2022-04-14T15:42:23.682Z",
        "updated_at": "2022-04-14T15:42:23.682Z"
    }
]

That is a lot of information! What happens in the scenario where I only need the title, author, and rating? I can always pass all the information and only use what I need. That could work! While continuing to work another scenario arises where only the Title, Image, and Rating are needed. Again, I can pass the whole object and only use the data required. But that is a lot of unnecessary information. Luckily, there is a way in Rails to pass only the information you need. Using .to_json will allow you to pass only certain information.

#Adding to_json to the show method
def show
    books = Book.find(params[:id])
    render json: book.to_json(only:[:id, :title, :image, :rating])
end

#Will return the following:
[
    { 
        "id": 1,
        "title": "Pride and Prejudice",
        "image": "https://d1w7fb2mkkr3kw.cloudfront.net/assets/images/book/lrg/9781/4351/9781435159631.jpg",
        "rating": 5
    }
]

That is much more efficient! But this method can quickly become overwhelming and crowded. If we want a method where we can observe good coding practice and have separation of concerns, we'll have to look at something different.

Serializers

Active Model Serializers (AMS) are a gem you can add to your project to customize how your JSON is rendered. It is a way to get the exact data you need while keeping separation of concerns.

To start, you need to install the gem.

gem 'active_model_serializers'

You can do this to on an active Rails project you are working on, just run bundle install after adding the gem, or add it during the setup portion, with all your gems.

After installing, you can generate the serializers using Rails generators.

rails g serializer book

This will generate a serializers folder in the app folder of your project. In the folder there will be a file called book_serializer.rb.

class BookSerializer < ActiveModel::Serializer
  attributes :id
end

You can add as many attributes as needed. For the example above where we only needed the id, title, image, and rating, we could have the following:

class BookSerializer < ActiveModel::Serializer
  attributes :id, :title, :image, :rating
end

#Will return the following:
[
    { 
        "id": 1,
        "title": "Pride and Prejudice",
        "image": "https://d1w7fb2mkkr3kw.cloudfront.net/assets/images/book/lrg/9781/4351/9781435159631.jpg",
        "rating": 5
    }
]

Fantastic! We got exactly what we needed, and good coding practices are observed with separation of concerns.

Once again, all the steps.

Install Active Model Serializers gem
Create a Serializer
Add required attributes

Custom Methods

We can also create custom methods for our serializers.

class BookSummarySerializer < ActiveModel::Serializer
  attributes :id, :summary, :author

  def summary
    "#{self.object.title} - #{self.object.description[0..49]}..."
  end

end

We create a method called summary and define what it does. In this case we are interpolating the title and the first 49 characters of the book description. After creating the method, we just add it to the list of attributes, and it will show up in the JSON.

#Will return the following:
[
    { 
        "id": 1,
        "summary": "Pride and Prejudice - Set in England in the early 19th century, Pride an...",
        "author": "Jane Austen"
    }
]

Let's go over those steps again.

Create a custom method in your serializer
Add the new method to your attributes

You can add as many custom methods as needed, but after a certain point, we can run into the issue of separation of concerns again. To separate our concerns, we can create a custom serializer.

Custom Serializers

To create a custom serializer for the method shown above, we need to start by creating the serializer. We can create a new file physically in our serializers folder, or we can use a generator again.

If you add a file by hand, make sure to observe proper syntax. Serializers need to be singular and named using snake_case. You will also need to add the class using PascalCase, and shovel it to your ActiveModel.
class BookSummarySerializer < ActiveModel::Serializer

After creating or generating the new serializer called BookSummarySerializer, we need to create the custom method, and add it to the attributes.

class BookSummarySerializer < ActiveModel::Serializer
  attributes :id, :summary, :author
end

def summary
  "#{self.object.title} - #{self.object.description[0..49]}..."
end

#Will return the following:
[
    { 
        "id": 1,
        "summary": "Pride and Prejudice - Set in England in the early 19th century, Pride an...",
        "author": "Jane Austen"
    }
]

After completing the custom serializer, it needs to be added to your controller. Rails will automatically check for a serializer with the same name as your controller, so if you want your custom serializer to show, you need to add it to your controller after rendering to JSON.

class BooksController < ApplicationController
    def index
        render json: Book.all
    end

    def show
        book = Book.find(params[:id])
        render json: book, serializer: BookSummarySerializer
    end
end

Steps to create a custom serializer:

Create a new serializer file with the custom name
Add all the needed information to your custom serializer
Add the custom serializer to the proper controller

Associated Data

If your data has associations created through models, you can access that data in your serializers as well. Building on our Book example, we can have an association where a book can have many reviews.
Book-<Reviews
You can show associated reviews of your books show in your JSON through serializers by simply adding the association.

If you have a many through relationship, you only need to write has_many for the info to show up.
Ex: Author -< Books >- Genre
An author has many books and has many genres through books. If you wanted to have the associated genres to your author on your JSON, you add the has_many :genres macro without needing to specify the "through" relationship.

class BookSerializer < ActiveModel::Serializer
  attributes :id, :title, :author

  has_many :reviews
end

#Will return the following:
[
    { 
        "id": 1,
        "title": "Pride and Prejudice",
        "author": "Jane Austen"
        "reviews": [
            { 
                "name": "Bob"
                "review": "Awesome classic!"
            },
            { 
                "name": "Nancy"
                "review": "Best book ever!"
            },
            { 
                "name": "Lea"
                "review": "Meh.. Not my speed."
            }
        ]
    }
]

Great! Now we have our book and all its related reviews!

Let's go over those steps again.

Have associations created in your models
Add required associations to your serializer

Deeply Nested Data

Let's look at a different example where we have a different relationship.
Author-< Book -< Review
The author has many books which have many reviews. If we wanted to have that information appear in our JSON, could we do that through serializers as well? Active Model Serializers only nest one level deep to protect from overcomplicating our data. If we still wanted the deeply nested data, we could overwrite AMS behavior.

We'll start by looking at our serializers.

#Author Serializer
class AuthourSerializer < ActiveModel::Serializer
  attributes :id, :first_name, :last_name

  has_many :books
end


#Book Serializer
class BookSerializer < ActiveModel::Serializer
  attributes :id, :title

  belongs_to :author
  has_many :reviews
end


#Review Serializer
class ReviewSerializer < ActiveModel::Serializer
    attributes :id, :name, :review
end

As we can see above, the author serializer includes its association to books, and the book serializer includes its association to author and reviews. For our deeply nested models to work, we need to include the associations in the proper serializers.

After creating the proper associations, we need to add information to our author controller so we can override the AMS behavior.

class AuthorController < ApplicationController
    def index
        render json: Book.all
    end

    def show
        author = Author.find(params[:id])
        render json: author, include: ['books', 'books.reviews']
    end
end

In the show method, after the render to JSON, there is code that tells Active Model Serializer that we want to render information for the author, and to also include information for the books associated with that author, and for the reviews associated with those books. Now our JSON will return the following:

[
    {
        "id": 1,
        "first_name": "Jane",
        "last_name": "Austen",
        "books": [
            {
                "id": 1,
                "title": "Pride and Prejudice",
                "reviews": [
                    { 
                        "name": "Bob"
                        "review": "Awesome classic!"
                    },
                    { 
                        "name": "Nancy"
                        "review": "Best book ever!"
                    },
                    { 
                        "name": "Lea"
                        "review": "Meh.. Not my speed."
                    }
                ]
            }
        ]
    }
]

Mission accomplished!
Let's go over the steps one more time.

Create serializers
Add the associations to the proper serializers
Include the information we want to render in the associated controller

Final Thoughts

Serializers are very powerful and useful. We can do so much with them and get our JSON exactly how we need it to be. One thing we should keep in mind, however, is that with each of the serializers, custom serializers, and custom methods we are adding complexity to our program. All the macros and methods start to add up quickly and can make things very complex.

Sources
Cover Image
Flatiron
Serializer Docs

How to Create an informative README.md

krisperu — Fri, 01 Apr 2022 20:00:31 +0000

Source

Why A ReadMe Important?

Have you ever tried to put together a piece of furniture without the instructions? Even with the instructions, it's nearly impossible to build at times. Creating a project without a ReadMe file is like selling someone a bunch of boards and screws and telling them to try to piece it together on their own.

A ReadMe is a file that contains a set of pertinent information about the files you are looking at. You can usually find them in a repo or in the project directory. They can come in many styles and types, but the most common is a markdown file.

While working on my latest project, I thought it would be useful to create a template of a ReadMe file for myself that I can come back to in the future. I've seen plenty or ReadMes throughout my experience, and they are not all created equal. I tried to take note of the ones that looked nice and gave me all the information I needed. A couple things I noticed all of the good ones had in common were that they were:

easy to follow
easy to read
informative
interactive
and had images/demonstrations

Guidelines

All ReadMes will vary depending on the content of the information they are describing, but most ReadMe files should contain these elements.

Title
This one is pretty self explanatory. Your project/code should have a title. Putting the title at the top of your file in big letters should be the first thing you do.
Description
A description should follow the title. Explain what the files are, what they create, what a user should expect to see if they run the project or apply the methods described. If applicable, add a user-stories. What can the user do if they run this project? You can also write about your inspiration behind the project. Why was it worth your time to write these files? What were you trying to achieve or need you were trying to fulfill.
Demonstration
A demonstration is a vital part of the ReadMe file. It doesn't have to be complicated or fancy to be great. Something as simple as adding a couple of screenshots makes a huge difference in your ReadMe. If you are more ambitious however, you can create gifs that show your project in action. You can even record a video demonstrating your project and all the code you spent so much time creating.
How to Install Your Project
Different projects require different bundles and gems to begin working, so this part of your read me is vital. If you don't put any other information, at least put this info in your read me. Creating easy-to-follow, step-by-step instructions will ensure that the most inexperienced user will be able to spin up your project.
Credits
Often times, multiple people will be collaborating with you on your project, or you will be collaborating on theirs. In both cases, everybody who participated in the program should get credit. Adding relevant information such as Github and LinkedIn accounts can facilitate opportunities or give you a place to reach out with any questions.
Table of Contents (Optional)
A table of contents can be helpful if you have a very long ReadMe. For example, if you take a look at the ReadMe for Faker, it is extremely long. Creating a table of contents makes the ReadMe dynamic, user friendly and easy to read.
License (Optional)
This section will inform the user whether or not they need to purchase a license to use your material. It will let you know if you can use the code commercially, privately or both.
Badges (Optional)
Badges are a simple way of showing users metadata related to your project. Such as the amount of forks or if certain tests are failing. Shields is a library you can use to create them. They are dynamic, so you don't have to worry about updating this section.
How to Contribute to the Project (Optional)
If you are open to contributions, a ReadMe would be a great place to let people know how they can contribute. You can give guidelines on how someone can contribute and inform the user of the what is acceptable.
Project Status (Optional)
Writing a project status can allow people to offer to help if you are experiencing a slump in regards to the project. It can also inform people whether something is in the works, or if they can expect a fully working product.

ReadeMe Template

# Project Title

Description of your project.

## User Stories

* A user will be able to do this thing
    * and this thing
* This thing too

# Demo

Put images ![image name](image Url), vidoes, and anything else needed to demo your project.


## Setup

Instructions on setup go here


## Credit

Created by: Name Here
Created by: Name Here
Created by: Name Here
[GitHub](GitHub Profile)
[LinkedIn](LinkedIn Profile)
email, etc...

Resources

I learned a lot and leaned heavily on these two articles. Feel free to peruse them for more information.

Free Code Camp
Make a Read Me

Class and Instance Methods in Ruby

krisperu — Fri, 18 Mar 2022 20:58:19 +0000

What is a Method

A method in Ruby is a block of code that performs tasks. They are one of the most basic and important building blocks in Ruby. They can take an input, return an output, make calculations and many other things.

def sing_queen
    "Don't stop me now"
end

Each method begins with the def keyword and end with an 'end'. The logic for the operation you are trying to execute is located in the body of the method. Each method requires a name which you can use to call the method as often as you need. Different parameters can be passed into the methods. Methods can add functionality to objects, classes and instances. A regular method adds functionality to an object, a class method adds functionality to classes, and instance methods add functionality to instances.

Class and Instance Methods

class Example
    def self.class_method
        "This is a class method"
    end

    def instance_method
        "This is an instance method"
    end 
end

If you wanted to call on the class method, this would be the result:

> Example.class_method
=> "This is a class method"

If you wanted to call on the instance method, you would get the following:

> Example.instance_method
=> undefined method "instance_method" for Example:class

You would get an error because you are trying to call an instance method on a class. To get it to work, you need to create an instance of the class.

> instance = Example.new
> instance.instance_method
=> "This is an instance method"

What would happen if you tried to call your class method on you instance?

> instance.class_method
=> undefined method `class_method' for #<Example:0x00007f8b609291c0>

You would be unable to do so.

Class

So, what is class? Class is an object type. It is like a blueprint to create individual objects. As an example, let's take a look at a song. Some variables for a song can be an artist, a genre, a name, and an album. These variables make each song unique. So, in this instance we can create a class called song, and inside the class define individual object methods for artist, genre, and album. The class variable is accessible from your objects. The class variable is a characteristic of that class. They are identified by the @@ sign and variable name "@@variable".

Instance

Instance variables are identifiable by the @ sign before their variable. You can only access an instance variable inside the object. You cannot call on an instance method or access the instance variable outside the object. Let's go back to our example of song. Many different songs exist, and they can vastly differ from each other, but they all share certain characteristics. Each song has a name, artist, genre, and album, these are the objects inside our class. But every separate song is an example of an instance. "Don't stop me now" is an example of an instance. Let's take a look at the code.

class Song
    attr_accessor :name, :artist, :genre, :album

   @@genres =[]

    def initialize(name, artist, genre, album)
        @name = name
        @artist = artist
        @genre = genre
        @album = album
        @@genres << genre
    end

    def self.genres
        @@genres.uniq
    end

    def name_declaration
        "Name: #{name}"
    end
end

newsong = Song.new("We Will Rock You", "Queen", "Rock", "News
 of the World").name_declaration

Here we are creating a new instance called "newsong" and assigning it the object variables previously declared. We can create as many of these as we like. We are also calling the instance method "name_declaration" on it. This will return the name of the song instance we just created.
We can create a new song instance without adding the instance method.

othersong = Song.new("Bohemian Rhapsody", "Queen", "Progressive Rock", "A Night at the Opera")

We can also observe the class variable in the example above. The genres class variable will contain all the genres of all the songs you create. The declaration of genres with the two @ signs before it identifies it as a class variable. The @@genres << genre line of code shovels each genre from each song into the empty array declared above. And the class method of self.genres will filter the genres to ensure the resulting array of genres doesn't have any duplicate data.

Final Thoughts

Whoever named the class method and instance method, made it easy to be able to understand which method applied to which type. The names don't leave much room for interpretation, which is a good thing in this case. The easier it is to understand something, the easier it will be to implement it. Understanding the difference between class and instance takes a little more effort, but when you can differentiate the two, it makes creating classes and instances more straightforward. Deciding whether you need a class or instance method becomes as easy as just looking at the name of what you are trying to manipulate.

Sources

Exploring .map .filter ...spread in React

krisperu — Mon, 07 Mar 2022 22:42:51 +0000

Methods

As I'm progressing through my study of React, I learned that we often use arrays of objects. From importing list to creating our own, I realized that I needed to brush up on the .map() .filter() and ...spread array methods, and learn how to implement them properly in React. First we need understand the difference between these three methods, then we can learn to implement them.

Before I implement any array methods I ask myself what I want the end result to be.

Do I want to add elements to my array? I might want to use the spread operator.
Do I want to delete elements in my array? The filter operator might be the way to go.
Do I want to change an element in my array? The map operator could help make that happen.

The Spread Operator

...Spread

The spread operator is a part of ES6 and is just used by React. It creates a copy of an existing array and "spreads" the elements, and adds them and any new elements and returns a new array. When using it, your return will be a new array with more elements than your original. The spread operator is nondestructive. Meaning after all manipulations are done, your original array will still be the same as before. You can also use the spread operator to nondestructively replace certain information in your array.

For my examples I will be using the following array of objects:

const users = [
    {
        id: 1,
        firstName: "Marie",
        lastName: "Curie",
        level: "Expert"
    },
    {
        id: 2,
        firstName: "Robert",
        lastName: "Oppenheimer",
        level: "Expert"
    },
    {
        id: 3,
        firstName: "Student",
        lastName: "Studentson",
        level: "Beginner"
    }
]

The following code shows and example of how the spread operator can be used.

const newUser = [
  {
    id: 4,
    firstName: "Thomas",
    lastName: "Eddison",
    level: "Proficient"
  }
]

const allUsers = [...users, newUser]

A new constant called newUser was declared. Then another new constant called allUsers was created to document a new array with all the users inside of it. If we return the array it will show all the users, new and original, in one array. When applying this array operator in React, it works the same way. You can add it in both the jsx and javascript syntax portions of your code.

function ourFunction(){
    const [accounts, setAccounts] = useState([])

    function addUser(person) {
        if(!accounts.includes(person)){
            setAccounts([...users, person])
        }
    }

    return(
        <DisplayUsers onAddClick={addUser}/>
    )
}

In this example we are creating a new array using setAccounts and adding the new user to it through the spread operator. The spread operator works in the same way as it did in the example above, but in react, it can be harder to see what is being done behind the scenes due to syntax. We are creating a new array that contains the original array of users and adding a new user to it ('person', in this case, is a prop that contains the new user information). Once that is added we are returning a new array of users that will be assigned to setAccounts.

The Map Operator

.map()

The map operator requires a callback function and a current element value to work. It takes every element in the array and "maps" it to something else. In our example above, we have an array called "Users", if we wanted to take each user and manipulate it separately, we would need to break the array into separate, usable pieces of data. To make this happen we use the map operator.

 function UserDetails() {
      const oneUser = users.map(userObj => {
          <UserCard 
             firstName={userObj.firstName}
             lastName={userObj.lastName}
             level={userObj.level}
          />
})
  return (
    <div>
       {UserDetails}
    </div>
  )
}

The map operator has taken each user, and created a separate element for each user and then passed the deconstructed props into the UserCard component. There is some React syntax happening here that I won't be getting into in this blog. But, the map operator has manipulated our existing array of users and was able to return us each user in turn so we can manipulate each one separately.
Since map is a nondestructive method, we need to state a new variable, to which we will assign our new array. Then we use the .map operator on our current element value: users. Inside the map operator we need to use a callback. In this callback we are declaring a new variable called userObj and using it to pass and deconstruct props into our userCard component. Now, when our user card component wants to create a separate user card for each user, it will take our mapped array and pull the information for each user separately, and repeat the process until there are no more users left.

The Filter Operator

.filter()

The filter operator checks each item against condition. If it's true it puts item back in array, if false it won't put them in the array. Similarly to the spread and map operators, the filter method is also a function of JavaScript, we aren't using React to filter. It is also a nondestructive way to manipulate arrays. We are going to use the filter method to return an array of users that are at "Expert" level.

<div>
  {users.filter(user => user.level === 'Expert').map(filteredUser => (
    <li>
      {filteredUser.firstName}
    </li>
  ))}
</div>

In the example above, our filter checks which users return return true and a new array is created containing only those values.
We apply the filter to our array called users and inside the filter operator we have a callback. In the callback we declare a variable called user and check if the user level, which we call on using dot notation, is equal to the "Expert" level. If our users satisfies our condition it is returned and the map operator is called on to return the users that satisfy our conditions. Another callback function inside our map operator returns a new array of first names that have passed our test. If none of the elements in our array pass the test, filter will return an empty array. The filter function will not work on an empty array.

The complete code for our filter operator is below.

import React from 'react'

const users = [
    {
        id: 1,
        firstName: "Marie",
        lastName: "Curie",
        level: "Expert"
    },
    {
        id: 2,
        firstName: "Robert",
        lastName: "Oppenheimer",
        level: "Expert"
    },
    {
        id: 3,
        firstName: "Student",
        lastName: "Studentson",
        level: "Beginner"
    }
]

function UserDetails() {
  return (
  <div>
      {users.filter(user => user.level === 'Expert').map(filteredUser => (
      <li>
        {filteredUser.firstName}
     </li>
     ))}
  </div>
  )
}

export default UserDetails

Final Thoughts

What I learned through my reading and investigating, is that the three array operators I focus on in this blog are actually used in JavaScript and are not different React operators or syntax. You can use them in vanilla Javascript and react in the same way. You can add react syntax and methods to make things easier and write less code, but the spread, map and filter operators will perform the same actions and work the same way in both scenarios.

Sources

Spread
Spread
Spread
Spread
Spread
Map Video
Map
Map
Filter
Filter

Basic Git Commands for Terminal

krisperu — Fri, 18 Feb 2022 21:04:17 +0000

What is GitHub

According to Kinsta "GitHub is a for-profit company that offers a cloud-based Git repository hosting service. Essentially, it makes it a lot easier for individuals and teams to use Git for version control and collaboration."

GitHub is a very popular Version Control System that is capable of doing a lot of things. From storing repo's to hosting blogs and webpages, there is a lot you can do with GitHub. When I started my journey to becoming a software engineer, I had never heard of GitHub. However, after beginning my education, I use it almost daily. I started by using it only by explicitly following the directions provided in my coursework, but with time I was expected to know more and be able to use it fairly comfortably. I am by no means an expert and still have a lot to learn about Github, but I thought I would write about some of the basic Git commands I have learned on my journey.

Useful Terms

repository (or repo, for short): A directory of files that are tracked by Git.
track: Track means that Git will record any changes to a file. These changes are often called differences or diffs. Git allows you to choose whether to commit a diff or not.
diff: Any changes made to your file(s) since the last commit are known as diffs. Another term is the diffset, which refers to all the changes that have been made on all the files of a repo since its last commit.
commit: A commit is like saving the changes you have made to your repo. To commit you need to write a message (usually a brief description of the changes made). You can track the commits to see what changes have been made.
log: A record of what happened in each commit.
local/remote: When forking from an existing repo, the original the remote. The repo on our personal system is referred to as the local repo.
fork: Creating a copy of an existing repo (including all branches) to our own local repo.

branch/default branch: A Git repo can support multiple branches that make it possible for multiple developers to be working on the code at the same time. When you initialize a new Git repo, a default branch is created where your work will be tracked by default. The name of the branch will often be main, but you will also see older repos that use master as the default branch.

Basic Commands

git init: This command initializes a new, empty repository. I can also be used to create a new Git repository. Without initializing the repo, you won't be able to use many other git commands, so this is usually done first.
git add: This command adds a file to your repository. Write the command and then the name and type of file you want to create. This command also stages changes to your repo that will be stored in the commit.
Example: $ git add style.css
git commit: Preforming a commit is usually done right after, or sometimes in conjunction with a git add command. It captures a snapshot of the project's currently staged changes. Commits will keep your code "safe" and stay the same unless you command to change it.
git pull: Git pull updates your current local branch and updates the remote tracking for all remote branches. It will fetch the new commits and merges from your remote GitHub repository and merges them to your local branch.
git checkout: This command has to do with branches. It is capable of switching branches you are in. By writing $ git checkout *branch name goes here*, you will switch between branches. You can also use this command to create a new branch by adding a -b. $git checkout -b *new branch name*
git fetch: This imports any changes made in your remote repo to your local repo.
git push: This pushes changes up to your remote repository. It transfers commits from your local repo to the remote one. This is the opposite of git fetch, it takes your local changes and adds them to the remote repository. This command has the potential to overwrite changes, so be cautious when using this command.
git merge: Git merge allows several branches to integrate into one branch.
git status: This checks status of your branch> It will let you know if there have been any commits or adds that need to be pushed up to the remote repo. It will tell you what has been staged, what hasn't, and what files are being tracked by git.
git remote: This command lists the remotes available in our Git repo.
git stash: git stash temporarily shelves (or stashes) changes you've made to your working copy so you can work on something else, and then come back and re-apply them later on. Stashing is handy if you need to quickly switch context and work on something else, but you're mid-way through a code change and aren't quite ready to commit.
git diff; Diffing is a function that takes two input data sets and outputs the changes between them. git diff is a multi-use Git command that when executed runs a diff function on Git data sources. These data sources can be commits, branches, files and more. This document will discuss common invocations of git diff and diffing work flow patterns. The git diff command is often used along with git status and git log to analyze the current state of a Git repo.

Conclusion

These are some of the most basic GitHub commands to use in your terminal while working on a project. There is much more you can do and a lot of minute details and applications for these basic Git commands.

Source: Bitbucket Tutorials

Source: freeCodeCamp

Source: Flatiron School Prework Course | Git Module