Search Your Question

Showing posts with label GItPod. Show all posts
Showing posts with label GItPod. Show all posts

GIT Interview Questions 2

  1. GIT Commit command
    The command that is used to write a commit message is “git commit -a”
    Now explain about -a flag by saying -a on the command line instructs git to commit the new content of all tracked files that have been modified. Also, mention you can use “git add <file>” before git commit -a if new files need to be committed for the first time.

  2. How can you fix a broken commit?
    In order to fix any broken commit, use the command “git commit --amend”. When you run this command, you can fix the broken commit message in the editor.

  3.  Basic Git commands:

    CommandFunction
    git rm [file]deletes the file from your working directory and stages the deletion.
    git log list the version history for the current branch.

    git show [commit]  

    shows the metadata and content changes of the specified commit.

    git tag [commitID] 

    used to give tags to the specified commit.

    git checkout [branch name]

    git checkout -b [branch name]

    used to switch from one branch to another.

    creates a new branch and also switches to it.



  4. In Git how do you revert a commit that has already been pushed and made public?
    There can be two approaches to tackle this question and make sure that you include both because any of the below options can be used depending on the situation:

    Remove or fix the bad file in a new commit and then push it to the remote repository. This is the most obvious way to fix an error. Once you have made necessary changes to the file, then commit it to the remote repository using the command: git commit -m “commit message”

    Also, you can create a new commit that undoes all changes that were made in the bad commit. To do this use the command

    git revert <name of bad commit>

  5. What is the difference between git pull and git fetch?
    Git pull command pulls new changes or commits from a particular branch from your central repository and updates your target branch in your local repository.

    Git fetch is also used for the same purpose but it works in a slightly different way. When you perform a git fetch, it pulls all new commits from the desired branch and stores it in a new branch in your local repository. If you want to reflect these changes in your target branch, git fetch must be followed with a git merge. Your target branch will only be updated after merging the target branch and fetched branch. Just to make it easy for you, remember the equation below:

    Git pull = git fetch + git merge

  6. What is git stash?
    Often, when you’ve been working on part of your project, things are in a messy state and you want to switch branches for some time to work on something else. The problem is, you don’t want to do a commit of half-done work just so you can get back to this point later. The answer to this issue is Git stash.

    Stashing takes your working directory that is, your modified tracked files and staged changes and saves it on a stack of unfinished changes that you can reapply at any time.

  7. What is the function of ‘git stash apply’?
    If you want to continue working where you had left your work then ‘git stash apply‘ command is used to bring back the saved changes onto your current working directory.

  8. What is git stash drop?
    Git ‘stash drop’ command is used to remove the stashed item. It will remove the last added stash item by default, and it can also remove a specific item if you include it as an argument.

    Now give an example.

    If you want to remove a particular stash item from the list of stashed items you can use the below commands:
  • git stash list: It will display the list of stashed items like:
  • stash@{0}: WIP on master: 049d078 added the index file
  • stash@{1}: WIP on master: c264051 Revert “added file_size”
  • stash@{2}: WIP on master: 21d80a5 added number to log

    If you want to remove an item named stash@{0} use command git stash drop stash@{0}.

  1. Can you explain the Gitflow workflow?
    To record the history of the project, Gitflow workflow employs two parallel long-running branches – master and develop:

    Master – this branch is always ready to be released on LIVE, with everything fully tested and approved (production-ready).

    Hotfix – these branches are used to quickly patch production releases. These branches are a lot like release branches and feature branches except they’re based on master instead of develop.

    Develop – this is the branch to which all feature branches are merged and where all tests are performed. Only when everything’s been thoroughly checked and fixed it can be merged to the master.

    Feature – each new feature should reside in its own branch, which can be pushed to the develop branch as their parent one.

  2. What is Git fork? What is the difference between fork, branch, and clone?
    A fork is a copy of a repository. Normally you fork a repository so that you are able to freely experiment with changes without affecting the original project. Most commonly, forks are used to either propose changes to someone else’s project or to use someone else’s project as a starting point for your own idea.

    git cloning means pointing to an existing repository and make a copy of that repository in a new directory, at some other location. The original repository can be located on the local file system or on remote machine accessible supported protocols. The git clone command is used to create a copy of an existing Git repository.

    In very simple words, git branches are individual projects within a git repository. Different branches within a repository can have completely different files and folders, or it could have everything the same except for some lines of code in a file.

  3. What is the difference between rebasing and merge in Git?
    In Git, the rebase command is used to integrate changes from one branch into another. It is an alternative to the “merge” command. The difference between rebasing and merge is that rebase rewrites the commit history in order to produce a straight, linear succession of commits.

    Merging is Git’s way of putting a forked history back together again. The git merge command helps you take the independent lines of development created by git branch and integrate them into a single branch.

  4. What is git cherry-pick?
    The command git cherry-pick is normally used to introduce particular commits from one branch within a repository onto a different branch. Another common use is to forward- or back-port commits from a maintenance branch to a development branch. This is in contrast with other ways such as merge and rebase which normally apply many commits onto another branch.

    Consider:

    git cherry-pick <commit-hash>

  5. How do you squash the last N commits into a single commit?
    There are two options to squash the last N commits into a single commit include both of the below-mentioned options in your answer
    If you want to write the new commit message from scratch use the following command

    git reset –soft HEAD~N &&git commit

    If you want to start editing the new commit message with a concatenation of the existing commit messages then you need to extract those messages and pass them to Git commit for that I will use

    git reset –soft HEAD~N &&git commit –edit -m”$(git log –format=%B –reverse .HEAD@{N})”

  6. How do I rename a local Git branch?
    Here are the steps to rename the branch:

    Switch to the branch which needs to be renamed

    git branch -m <new_name>
    git push origin :<old_name>
    git push origin <new_name>:refs/heads/<new_name>

Difference between pod install and pod update

Ans : 

pod install

This is to be used the first time you want to retrieve the pods for the project, but also every time you edit your Podfile to add, update or remove a pod.

Every time the pod install command is run — and downloads and install new pods — it writes the version it has installed, for each pods, in the Podfile.lock file. This file keeps track of the installed version of each pod and locks those versions.
When you run pod install, it only resolves dependencies for pods that are not already listed in the Podfile.lock.
For pods listed in the Podfile.lock, it downloads the explicit version listed in the Podfile.lock without trying to check if a newer version is available
For pods not listed in the Podfile.lock yet, it searches for the version that matches what is described in the Podfile (like in pod 'MyPod', '~>1.2')

pod outdated

When you run pod outdated, CocoaPods will list all pods which have newer versions than the ones listed in the Podfile.lock (the versions currently installed for each pod). This means that if you run pod update PODNAME on those pods, they will be updated — as long as the new version still matches the restrictions like pod 'MyPod', '~>x.y' set in your Podfile.

pod update

When you run pod update PODNAME, CocoaPods will try to find an updated version of the pod PODNAME, without taking into account the version listed in Podfile.lock. It will update the pod to the latest version possible (as long as it matches the version restrictions in your Podfile).

If you run pod update with no pod name, CocoaPods will update every pod listed in your Podfile to the latest version possible.


What will happened if I delete pod.lock file?

Ans : After first time run pod install, Podfile.lock will be generated.

The purpose of Podfile.lock is tracking of every version of every library that Cocoapods has installed for you, especially working together with a team.

In team there are two guys working, Narendra and Amit.

  • Narendra has made project and install library named Demo Library Version 1.3.3
  • After some days, Demo Library is updated to 1.4.0. and Narendra not hit command pod update  as he is happy with 1.3.3
  • Amit copy narendra's project and hit command pod install, then 1.4.0 will be installed(if Podfile.lock is not there).
  • So here is how Podfile.lock work, record the version of what Narendra had installed, then cocoapods will check what version Narendra had installed and then install on Amit's project. (1.3.0)
  • But if Amit hit command pod update, then in pod.lock file, version changed to 1.4.0 .
So Podfile.lock file should not be deleted if we work on team. And so Podfile.lock file should be checked while using source control.


Everyone should take care while hitting command pod install and pod update. Choose wisely between those. While update pod update, we should ask to our teammate.

Another nice feature is cocoapods will create a snapshot of every library while using source control.

Understand from : Video

When we use pod deinit?

Ans. :

To remove pods from a project completely you need to install two thing first...those are follows(Assuming you have already cocoa-pods installed in your system.)...
  1. Cocoapods-Deintegrate Plugin
  2. Cocoapods-Clean Plugin
Installation
  1. Cocoapods-Deintegrate Plugin
    Use this following command on your terminal to install it.
    sudo gem install cocoapods-deintegrate
  2. Cocoapods-Clean Plugin
    Use this following command on your terminal to install it.
    sudo gem install cocoapods-clean
Usage
First of all goto your project folder by using the as usual command like..
cd (path of the project) //Remove the braces after cd
Now use those two plugins to remove it completely as follows..
  1. Cocoapods-Deintegrate Plugin
    Use this following command on your terminal to deintegrate the pods from your project first.
     pod deintegrate
Deintegrating Pods
  1. Cocoapods-Clean Plugin
    After deintegration of pod from your project use this following command on your terminal to clean it completely.
     pod clean
    After completing the above tasks there should be the Podfile still remaining on your project directory..Just delete that manually or use this following command on the terminal..
     rm Podfile
Thats it...Now you have your project free from pods...Cleaned.
Removing Cocoapods from the system.
Any way try to use the following command on your terminal to uninstall/remove the coca-pods from your system.
sudo gem uninstall cocoapods
It will remove the coca-pods automatically.
Thanks. Hope this helped.

GIT for Interview

1. Difference between Distributed & Central version control system.
A. GIT is distributed version control system.
     SVN is central version control system.

Central Version Control System : It is located in one place and people can check out from central location to make their changes and then check everything back in but some times it is problematic if central repository is corrupted or central system is not connected through network. For that we have to take backup manually in local machine.

Distributed Version Control System : Everybody has local repository. Your local repository has all information that remote repository has and till last sync done between local and remote repository. So sometimes, if remote repository is not able to be connected through internet, then we can see every changes as it is also saved in local repository. So every developer has repository in locally. So it is called in distributed version control system.


 2. Check version of GIT installed on your machine.
A. git --version

3. Setting configuration
A.
Set username : git config --global user.name "Manan Shah"
Set email : git config --global user.email "manan0shah@gmail.com"
Check configuration setting : git config --list

4. Get git function help
A.

git help <verb>
git verb --help

i.e git help config
     git config --help

     git help add
     git add -help

5. Setup git in your project
A. Goto finder/folder of project which we want to track, using terminal using cd command and write following command
 git init

6. To check status of untracked files in our repository
A. git status

7. Ignore files which we want to keep untracked. Like personal settings, preferences, etc
A. Create a gitignore file : touch .gitingore
     Write down list of files which we want to ignore to track as below :
     .ds_store
     .xcodeproj
     *.py  (wild card used to ignore files which has py extension)

After this, git status

--------------------------------------------

There are 3 area in area we have knowledge about.
1. Working directory
2. Staging Area
3. Git directory

(image from Pro Git" book : https://git-scm.com/book/en/v2)

1. Working directory : Untracked files reside in working directory. -> Files in red colour in terminal
2. Staging Area : When we use command git add . , then this files added to staging area. Which can be committed. -> Files in green colour in terminal
3. Git directory : When we commit our changes, then it goes to git directory. That can be push to remote directory. git commit -m "message for this commit like changes in setting"

Note : If we want to uncommit changes or remote files from staging area to working directory, then Use git reset 

We can check all commit log using command : git log

------------------------------------------

Cloning git repo

git clone <url_of_remote_git> <local_directory>

git clone https://....../remote_repo.git .    (. means in current folder)

-----------------------------------------

Viewing remote repository info

git remote -v  : Give information about your local repository path for fetch, push

git branch -a : Give list of all local and remote branches

-----------------------------------------

Pushing code

git diff : tells difference between remote and local files changes
git pull origin master : pull all changes made from remote repo to local
git push origin master : push all changes from local to remote repo

-----------------------------------------

Merge branch

Suppose, we have worked on calc branch and we need to merge calc branch into master branch.

git checkout master :  Switch to master branch or in which we have to merge
git pull origin master : Pull all changes in master branch from remote server
git branch --merged : Check branch name in which code is to be merged
git merge calc : Merge calc branch with master branch. It shows number of changes. If any conflicts are there, then  we have to solve it using editing code.
git push origin master : Push merged code to remote master branch

-----------------------------------------

Deleting branch

git branch -d calc : Delete calc branch locally
git branch -a : To check whether branch is deleted or not.
git push origin --delete calc : To delete calc branch remotely

-----------------------------------------------------------------------------------------------------------------

Different parameters for adding files to staging area  :

1. git add -A or git add --all (Default): adding all files from leading directory into staging area
2. git add -A my_dir/ or git add my_dir/ : adding only files located in my_dir into staging area
3. git add -u : adding only modified files into staging area
4. git add -u my_dir/ : adding only updated files located in my_dir into staging area
5. git add . : adding all files in current directory into staging area
6. git add .gitignore : Add only specific file into staging area.

Difference between git add -A and git add . : git add -a add all files in leading directory and git add . only add files from current directory.

-----------------------------------------------------------------------------------------------------------------

Switch to branch without commiting

git stash save "worked on save function" : It will save this branch at this point without commited. And this branch at initial stage.
git stash list : List all stashes here
stash@{0} : On add : worked on save function
git stash apply stash@{0} : Come to our point back using this command. stash will not be dropped.
git stash pop : Come to our point back & drop stash from list.
git stash drop stash@{0} : drop stash@{0}
git stash clear : Clear all stash in list

If we want to do changes from one branch to another branch, then this is most wanted method.

Suppose, I have changed code in master branch.  But I want it to CalC branch. Then,
git stash save "add function" :  save stash on master branch
git checkout CalC :  Switched to CalC branch
git stash pop : apply changes
git add . : add files to staging area
git commit -m "intr" : commit & push


Note : New stash come at top position. Always at 0th position. @{0}.

-----------------------------------------------------------------------------------------------------------------

Git difftool & mergetool

git diff : It shows modification with red(Previous) and green(Current) colour content between previous and current file on terminal window. It is very hard to see where we have changed or what word we have changed. Because git diff shows full line instead of changed word.

So instead of using, there are many diff tool and merge tool available. I,e DiffMerge
Using this tool, we can easily find changes and solve if any conflicts are there just because it is graphically represent instead of just terminal.
For that we have to download and install that tool and configuration with our git. After configuration, check configuration using git config --global --list

Check
diff.tool = diffmerge
merge.tool = diffmerge

happened or not?

Now,
to run that diff tool ,
git difftool : It required permission to open diff tool, press Y to open difftool, and we can see modification clearly with color and word by word.

We can take changes according to we required by simply click on which changes and from which file(previous or current).

git mergetool : To merge branch. If any conflict occur, we can easily solve using this type tool due to visual representation.



-----------------------------------------------------------------------------------------------------------------

To change last commit message,
git commit --amend -m "new message" : It will change message of last commit message.

Hight thank full to Corey Schafer

I took help from following videos  :

1. Git Tutorial for Beginners: Command-Line Fundamentals
2. Git Tutorial: Fixing Common Mistakes and Undoing Bad Commits
3. Git Tutorial: Using the Stash Command
4. Git Tutorial: Diff and Merge Tools
5. Git Tutorial: Change DiffMerge Font-Size on Mac OSX
6. Git Tutorial: Difference between "add -A", "add -u", "add .", and "add *"

If you have any doubts for git, please comment on this blog.