-
Notifications
You must be signed in to change notification settings - Fork 1
Git Tools client and Commands
Important
In a .gitignore
file, you can add comments by starting a line with a # character
. Git ignores any line that begins with #
, considering it as a comment. Here's an example:
# Ignore compiled files
*.exe
*.class
# Ignore log files
*.log
Distributed SCM GIT CHEAT SHEET
One of the nicest features of any Distributed SCM, Git included, is that it's distributed. This means that instead of doing a "checkout" of the current tip of the source code, you do a "clone" of the entire repository.
Feature Based Workflow. Create new branches for each new feature you're working on so you can seamlessly switch back and forth between them, then delete each branch when that feature gets merged into your main line.
Feature Based Workflow | Bug Fix Workflow |
---|---|
Configuration - Git Commands GIT CHEAT SHEET
To start using Git from your computer, you must enter your credentials to identify yourself as the author of your work. The username and email address should match the ones you use in GitLab.
- In your shell, add your user name:
git config --global user.name "your_username"
- Add your email address:
git config --global user.email "your_email_address@example.com"
- To check the configuration, run:
git config --global --list
- To add SSL cert: `git config --global http.sslCAInfo "Self signed SSL cert *.crt"
To unset user/password of Git/Bitbucket use following commands referred form stackoverflow
-
Open Git Bash.
-
Set a Git username:
$ git config --global user.name "Mona Lisa"
-
Confirm that you have set the Git username correctly:
$ git config --global user.name > Mona Lisa
# Set
git config --global user.name "your_username"
# Unset
git config --global --unset user.name
git config --global user.name "your_username2"
# Set and Reset
git config --global --unset user.password
git push (will prompt you for the password)
git status (will not prompt for password again)
# Git GUI
git config --global credential.helper wincred
$ git remote add origin https://github.com/Yash-777/SpringBoot_MicroService.git
error: remote origin already exists.
$ git branch -M main
$ git push -u origin main
remote: Permission to Yash-777/SpringBoot_MicroService.git denied to gitAdminSri.
fatal: unable to access 'https://github.com/Yash-777/SpringBoot_MicroService.git/': The requested URL returned error: 403
Pushing to https://github.com/Yash-777/SpringBoot_MicroService.git
$ git push https://Yash-777:**%40***@github.com/Yash-777/SpringBoot_MicroService.git --all
remote: Support for password authentication was removed on August 13, 2021.
remote: Please see https://docs.github.com/en/get-started/getting-started-with-git/about-remote-repositories#cloning-with-https-urls for information on currently recommended modes of authentication.
fatal: Authentication failed for 'https://github.com/Yash-777/SpringBoot_MicroService.git/'
For anyone having issues with passwords with special chars just omit the password and it will prompt you for it: Username and password in command for git push
$ git push https://Yash-777@github.com/Yash-777/SpringBoot_MicroService.git --all
Enumerating objects: 168, done.
Counting objects: 100% (168/168), done.
Delta compression using up to 8 threads
Compressing objects: 100% (132/132), done.
Writing objects: 100% (168/168), 107.50 KiB | 4.67 MiB/s, done.
Total 168 (delta 23), reused 0 (delta 0), pack-reused 0
remote: Resolving deltas: 100% (23/23), done.
To https://github.com/Yash-777/SpringBoot_MicroService.git
* [new branch] main -> main
For Windows 10 it is:
Control Panel > User Accounts > Manage your Credentials > Windows Credentials > Generic Credentials, search for the git credentials and edit
When you clone a repository, the files from the remote repository are downloaded to your computer, and a connection is created.
This connection requires you to add credentials. You can either use SSH or HTTPS. SSH is recommended.
Clone with SSH/HTTPS:
SSH: git clone git@gitlab.com:gitlab-tests/sample-project.git
HTTPS: git clone https://gitlab.com/gitlab-tests/sample-project.git
Clone to Specific Branch
git clone -b <feature-branch-Name> https://gitlab.com/gitlab-tests/sample-project.git
# With user as `Yash-777`
git clone -b <feature-branch-Name> https://Yash-777@gitlab.com/gitlab-tests/sample-project.git
Unlike the other systems, Git has something called the "staging area" or "index". This is an intermediate area where commits can be formatted and reviewed before completing the commit.
One thing that sets Git apart from other tools is that it's possible to quickly stage some of your files and commit them without committing all of the other modified files in your working directory or having to list them on the command line during the commit.
Git Status: Inspecting a repository
List the files you've changed and those you still need to add or commit
The git status
command displays the state of the working directory and the staging area. It lets you see which changes have been staged, which haven’t, and which files aren’t being tracked by Git. Status output does not show you any information regarding the committed project history. For this, you need to use git log
.
The git log
command displays committed snapshots. It lets you list the project history, filter it, and search for specific changes. While git status lets you inspect the working directory and the staging area, git log only operates on the committed history.
$ git log
commit 0000011111222223333344444555556666677777
Merge: 88888999999 aaaaabbbbbb
Author: user@example.com
Date: Tue Aug 31 21:19:41 2021 +0000
Stage | Commit | Stage + Commit |
---|---|---|
Add one or more files to staging (index)
git add <file-name OR folder-name>
- The
git add
command adds a change in the working directory to the staging area. It tells Git that you want to include updates to a particular file in the next commit. However, git add doesn't really affect the repository in any significant way—changes are not actually recorded until you rungit commit
.
git add <file> git add hello.py
git add <directory> git add .
The git add
command is used to promote or 'stage' changes to the project that will be stored in a commit. These two commands git commit
and git add
are two of the most frequently used.
Commit changes to head (but not yet to the remote repository)
git commit -m "Commit message of Staged files"
- The
git commit
command captures a snapshot of the project's currently staged changes.
Unstage all changes that have been added to the staging area. The
git reset
command is used to undo a commit or staged snapshotgit add
.
-
git reset
To unstage (remove) all files that have not been committed -
git reset HEAD~1
To undo the most recent commit
For example, to push your local commits to the main branch of the origin remote:
git push
git push origin feature-branch-main git push <remote> <name-of-branch>
- BitBucket/GitHub Create a pull request form
feature-branch
todevelop-branch
. This generates a Merge request by clicking on Merge changes get updatedFeature to Develop branch
.
Before merging you can view the differences by using the command git diff [source branch] [target branch]
- Use Rebase when updating your branch with main
- Use Merge when bringing changes from feature to main
When you rebase:
Git imports all the commits submitted to main after the moment you created your feature branch until the present moment. Git puts the commits you have in your feature branch on top of all the commits imported from main:
git stash
git pull --rebase origin develop-branch
git push -f origin feature-branch
git stash pop
Force-push
When you perform more complex operations, for example, squash commits, reset or rebase your branch, you must force an update to the remote branch. These operations imply rewriting the commit history of the branch. To force an update, pass the flag --force or -f to the push command. For example:
git push --force origin my-feature-branch
Forcing an update is not recommended when you’re working on shared branches.
Alternatively, you can pass the flag --force-with-lease instead, as it is safer. This flag preserves any new commits added to the remote branch by other people: git push --force-with-lease origin my-feature-branch
project/
│
├── src/
│ ├── main/
│ │ ├── java/
│ │ │ └── com/
│ │ │ └── example/
│ │ │ └── MyClass.java
│ │ └── resources/
│ │ └── config/
│ │ └── config.properties
│
└── docs/
└── README.md
Checkout changes made to specific files from the current branch
or specified branch
.
couple of common methods | commands |
---|---|
Checkout specific files from another branch |
git checkout <branch_name> -- <file_path> git checkout MyWorld -- src/main/java/com/example/MyClass.java
|
Reset specific files to the state in the last commit |
git checkout -- <file_path> git checkout -- src/main/java/com/example/MyClass.java
|
Important
# To check out a specific file from a stash in Git. Replace
<stash_index>with the index of the stash you want to access (e.g., 0 for the most recent stash, 1 for the second most recent, and so on). Replace
<file_path> with the path to the file you want to retrieve from the stash.
git checkout stash@{<stash_index>} -- <file_path>
git checkout stash@{0} -- src/main/java/com/example/MyClass.java
git checkout stash@{4} -- src/main/java/com/example/MyClass.java
We use git stash to store our changes when they are not ready to be committed, but we must change to a different branch.
# Use any Stash command.
git stash
git stash save
git stash save "this is a message to display on the list"
# Apply stash to keep working on it:
git stash apply
# To clean our stack, manually remove them
git stash drop
# Apply and drop on one command:
git stash pop
Important
Discard Local Changes: Use git reset --hard HEAD
to discard all local changes and revert your working directory to the state of the last commit. This command will move the HEAD pointer of your current branch back two commits, effectively resetting your working directory to the state it was in at the second last commit. It will also discard any local changes you have made since that commit.
Ensure Clean State: Use git clean -fd
to remove untracked files and directories from the working tree. This will ensure that your working directory is clean and matches the HEAD revision of the branch.
git reset HEAD --hard # To remove all not committed changes!
git clean -fd # To remove all untracked (non-git) files and folders!
// To reset your working directory to the state of the second last commit (HEAD~2)
git reset --hard HEAD~2
git checkout feature-branch
git cherry-pick commit-id-of-repository [get particular commit changes to the branch]
git commit -amend --reset-author [change the identity of this commit to your name and current date]
git push [push changes to current branch]
In Git, you can cherry-pick a commit (a set of changes) from an existing branch, and apply those changes to another branch. Cherry-picks can help you
-
Cherry-pick a commit
git cherry-pick -m 2 7a39eb0
Important
Cherry picking is the act of picking a commit from a branch and applying it to another. git cherry-pick can be useful for undoing changes. For example, say a commit is accidently made to the wrong branch. You can switch to the correct branch and cherry-pick the commit to where it should belong.
- Git Clone vs Check out stackoverflow
- Git Fetch vs Pull vs Push
Shrink a Git Repository by removing some files log history from the .git Folder based on their last updated time.
$ git remote prune origin && git repack && git prune-packed && git reflog expire --expire=1.month.ago && git gc --aggressive
Git Tutorial: git status vs. git log
- create a new branch from the current one (
git switch -c rebase-to-<new-version>
) - rebase the patches (
git rebase -i --onto <component>-<new-version> <component>-<version>
)
-
At its core, Git is a set of command line utility programs that are designed to execute on a Unix style command-line environment. Modern operating systems like Linux and macOS both include built-in Unix command line terminals. This makes Linux and macOS complementary operating systems when working with Git. Microsoft Windows instead uses Windows command prompt, a non-Unix terminal environment.
- To Stage only selected files use
Ctrl + T
form Git GUI. - If the password is saved and want to change password of your user-Repository the use
git config --global credential.helper wincred
- To Stage only selected files use
-
In a class-based object-oriented language, in general, state is carried by instances, methods are carried by classes, and inheritance is only of structure and behavior.
Method signature: It consists of method name and parameter list (number/type/order of the parameters). methodName(parametersList y)
. An instance method in a subclass with the same signature
and return type
as an instance method in the super-class overrides the super-class's method.
Java OOP concepts
Class - Collection of a common features of a group of object [static/instance Fields, blocks and Methods]
Object - Instance of a class (instance fields)
Abstraction - Process of hiding complex info and providing required info like API, Marker Interfaces ...
Encapsulation(Security) - Class Binding up with data members(fields) and member functions.
Inheritance (Reusability by placing common code in single class)
1. Multilevel - {A -> B -> C} 2. Multiple - Diamond problem {A <- (B) -> C} [Java not supports] 3. Cyclic {A <-> B} [Java not supports]
* Is-A Relation - Class A extends B
* Hash-A Relation - Class A { B obj = new B(); } - (Composition/Aggregation)
Polymorphism (Flexibility) 1. Compile-Time Overloading 2. Runtime Overriding [Greek - "many forms"]
int[] arr = {1,2,3}; int arrLength = arr.length; // Fixed length of sequential blocks to hold same data type
String str = "Yash"; int strLength = str.length(); // Immutable Object value can't be changed.
List<?> collections = new ArrayList<String>(); int collectionGroupSize = collections.size();
Map<?, ?> mapEntry = new HashMap<String, String>();
Set<?> keySet = mapEntry.keySet(); // Set of Key's
Set<?> entrySet = mapEntry.entrySet(); // Set of Entries [Key, Value]
// Immutable Objects once created they can't be modified. final class Integer/String/Employee
Integer val = Integer.valueOf("100"); String str2 = String.valueOf(100); // Immutable classes
final class Employee { // All Wrapper classes, java.util.UUID, java.io.File ...
private final String empName; // Field as Final(values can be assigned only once) Only getter functions.
public Employee(String name) { this.empName = name; }
}
Native Java Code for Hashtable.h
, Hashtable.cpp
SQL API
.
You can check your current JDK and JRE versions on your command prompt respectively,
- JDK
javac -version [C:\Program Files\Java\jdk1.8.0_121\bin]
o/p:javac 1.8.0_121
- JRE
java -version
[C:\Program Files\Java\jdk1.8.0_121\bin]
o/P:java version "1.8.0_102"
JAVA_HOME - Must be set to JDK otherwise maven projects leads to compilation error. [ERROR] No compiler is provided in this environment. Perhaps you are running on a JRE rather than a JDK?
C:\Softwares\OpenJDK\
, 7-zip
Fatal error compiling: invalid target release: JRE and JDK must be of same version
1.8.0.XXX
Disable TLS 1.0 and 1.1
security-libs/javax.net.ssl
: TLS 1.0 and 1.1 are versions of the TLS protocol that are no longer considered secure and have been superseded by more secure and modern versions (TLS 1.2 and 1.3).
Core Java
-
Java Programming Language Basics
- Object, Class, Encapsulation, Interface, Inheritance, Polymorphism (Method Overloading, Overriding)
- JVM Architecture, Memory Areas
- JVM Class Loader SubSystem
- Core Java Interview Questions & Programs
- Interview Concepts
Stack Posts
- Comparable vs Comparator
- Collections and Arrays
-
String, StringBuffer, and StringBuilder
- String reverse
- Remove single char
- File data to String
- Unicode equality check Spacing entities
- split(String regex, int limit)
- Longest String of an array
-
Object Serialization
- Interface's Serializable vs Externalizable
- Transient Keyword
-
implements Runnable
vsextends Thread
- JSON
- Files,
Logging API
- Append text to Existing file
- Counting number of words in a file
- Properties
- Properties with reference key