When you are working on the Linux command line and you come across a large file or a large number of files in which you need to replace a certain text with another, finding and pasting over each instance of the text can be a bit time consuming. Well, worry no more. Linux has just the solution for you. Here’s a way to find and replace a string of text in one or more files automatically.
For the purpose of this exercise we will use a Linux command line tool called “sed”. ”sed” is a very powerful and versatile tool, and a lot can be written about its capabilities. We are using a very limited aspect of “sed” here. I would definitely recommend that you read up a little more on “sed” if you find this aspect of it interesting.
We are going to use the following syntax to find and replace a string of text in a file:
# sed -i 's/[orginal_text]/[new_text]/' filename.txt
Say you have a file called “database.txt” with numerous instances of the IP address of your database server in it. You have just switched to a new database server and need to update it with the new server’s IP address. The old IP address is 192.168.1.16 and the new one is 192.168.1.22. Here’s how you go about it:
Now open the file “database.inc” and check to see if the new IP address has taken place of your old one. Here’s the breakup of the above command. First you call the “sed” command. Then you pass it the parameter “-s” which stands for “in place of”. Now we use a little bit of regular expressions, commonly known as “regex” for the next bit. The “s” in the quoted string stands for “substitute”, and the “g” at the end stands for “global”. Between them they result in a “global substitution of the the string of text you place in between them.
You can optionally skip the “g” at the end. This means that the substitution will not be global, which practically translates to the substitution of only the first instance of the string in a line. So if you had a line with multiple instances of the text you are trying to replace, here’s what will happen
Here comes the real magic. Now, say you want to change a string of text not just in a single file, but in the entire directory you are in. There are a number of text files in which you need to find and replace the “wine” with “champagne”.
# find . -maxdepth 1 -name "*.txt" -type f -exec sed -i 's/wine/champagne/' {} \
We use the find command to get a list of all the text files in the current directory. That’s the “find . -maxdepth 1 -name “*.txt” -type f” part. “find . maxdepth 1″ tell the computer to look in the current directory and go no deeper than the current directory. The ‘-name ”*.txt”‘ part tells find to only list files with the extension of “.txt”. Then the “-type f” section specifies that “find” should only pick exactly matching files. Finally the “-exec” part tells “find” to execute the command that follows, which, in this case, is the “sed” command to replace the text – “sed -i ‘s/wine/champagne/’ {} \”.
I realize that the above command seems complicated. However, once you use it a little bit you will realize that it is probably worth noting it down and using it. Now try changing a string of text in multiple levels of directories.
In case of date format checking in PHP just use this function:
function checkDateFormat($date)
{
//match the format of the date
if (preg_match ("/^([0-9]{4})-([0-9]{2})-([0-9]{2})$/", $date, $parts))
{
//check weather the date is valid of not
if(checkdate($parts[2],$parts[3],$parts[1]))
return true;
else
return false;
}
else
return false;
}
In case of MySQL error 2006 (HY000) at line: ### MySQL server has gone away which may occur while restoring a big DB dump just add (or increase, if exists) max_allowed_packet parameter of MySQL config (usually in /etc/my.cnf).
Git features The Stash, which is as much as a good place to store uncommitted changes. When you stash you changes, the will be stored, and your working copy will be reverted to HEAD (the last commit revision) of your code.
When you restore your stash, you changes are reapplied and you continue working on your code.
Stash your current changes
$ git stash save
Saved "WIP on master: f12345..."
List current stashes
Yes, you can have more than one!! The stash works like a stack. Every time you save a new stash, it's put on top of the stack.
$ git stash list
stash@{0}: WIP on master: f12345..."
Note the stash@{0} part? That's your stash ID, you'll need it to restore it later on. Let's do that now. The stash ID changes with every stash you make. stash@{0} refers to the last stash you made.
Apply a stash
$ git stash apply stash@{0}
You may notice the stash is still there after you have applied it. You can drop it if you don't need it any more.
$ git stash drop stash@{0}
Or, because the stash acts like a stack, you can pop off the last stash you saved:
$ git stash pop
If you want to wipe all your stashes away, run the 'clear' command:
$ git stash clear
It may very well be that you don't use stashes that often. If you just want to quickly stash your changes to restore them later, you can leave out the stash ID.
To ignore whitespace (Ruby is whitespace insensitive)
git config --global apply.whitespace nowarn
Some nice aliases:
gb = git branch
gba = git branch -a
gc = git commit -v
gd = git diff | mate
gl = git pull
gp = git push
gst = git status
Start using git
git init
Ignoring files
Add a file in the root directory called .gitignore and add some files to it: (comments begin with hash)
*.log db/schema.rb db/schema.sql
Git automatically ignores empty directories. If you want to have a log/ directory, but want to ignore all the files in it, add the following lines to the root .gitignore: (lines beginning with ‘!’ are exceptions)
log/* !.gitignore
Then add an empty .gitignore in the empty directory:
touch log/.gitignore
Scheduling the addition of all files to the next commit
git add .
Checking the status of your repository
git status
Committing files
git commit -m "First import"
Seeing what files have been committed
git ls-files
Scheduling deletion of a file
git rm [file name]
Committing all changes in a repository
git commit -a
Scheduling the addition of an individual file to the next commit
git add [file name]
Viewing the difference as you commit
git commit -v
Commit and type the message on the command line
git commit -m "This is the message describing the commit"
Commit and automatically get any other changes
git commit -a
A “normal” commit command
git commit -a -v
Viewing a log of your commits
git log
Viewing a log of your commits with a graph to show the changes
git log --stat
Viewing a log with pagination
git log -v
Visualizing git changes
gitk --all
Creating a new tag and pushing it to the remote branch
The state of your file system will change after executing this command.
git checkout [name of the branch you want to switch to]
OR
git co [name of the branch you want to switch to]
Making sure changes on master appear in your branch
git rebase master
Merging a branch back into the master branch
First, switch back to the master branch:
git co master
Check to see what changes you’re about to merge together, compare the two branches:
git diff master xyz
If you’re in a branch that’s not the xyz branch and want to merge the xyz branch into it:
git merge xyz
Reverting changes to before said merge
git reset --hard ORIG_HEAD
Resolving conflicts
Remove the markings, add the file, then commit.
Creating a branch (and switching to the new branch) in one line
git checkout -b [name of new branch]
Creating a stash (like a clipboard) of changes to allow you to switch branches without committing
git stash save "Put a message here to remind you of what you're saving to the clipboard"
Switching from the current branch to another
git co [branch you want to switch to]
Do whatever
Then switch back to the stashed branch
git co [the stashed branch]
Viewing a list of stashes
git stash list
Loading back the stash
git stash apply
Now you can continue to work where you were previously.
Deleting a branch (that has been merged back at some point)
git branch -d [name of branch you want to delete]
Deleting an unmerged branch
git branch -D [name of branch you want to delete]
Deleting a stash
git stash clear
Setting up a repository for use on a remote server
Copy up your repository. e.g.:
scp -r my_project deploy@yourbox.com:my_project
Move your files on the remote server to /var/git/my_project
For security make the owner of this project git
On the repository server:
sudo chown -R git:git my_project
Then (for security) restrict the “deploy” user to doing git-related things in /etc/passwd with a git-shell.
Checking out a git repository from a remote to your local storage
git clone git@yourbox.com:/var/git/my_project
Viewing extra info about a remote repository
cat .git/config
By virtue of having cloned the remote repository, your local repository becomes the slave and will track and synchronize with the remote master branch.
Updating a local branch from the remote server
git pull
Downloading a copy of an entire repository (e.g. laptop) without merging into your local branch
git fetch laptop
Merging two local branches (ie. your local xyz branch with your local master branch)USE MERGE
git merge laptop/xyz
This merged the (already copied laptop repository’s xyz branch) with the current branch you’re sitting in.
Viewing metadata about a remote repository
git remote show laptop
Pushing a committed local change from one local branch to another remote branch
git push laptop xyz
Creating a tracking branch (i.e. to link a local branch to a remote branch)
git branch --track local_branch remote_branch
You do not need to specify the local branch if you are already sitting in it.
git pull
Note: You can track(link) different local branches to different remote machines. For example, you can track your friend’s “upgrade” branch with your “bobs_upgrade” branch, and simultaneously you can track the origin’s “master” branch (of your main webserver) with your local “master” branch.
By convention, ‘origin’ is the local name given to the remote centralized server which is the waySVN is usually set up on a remote server.
Seeing which local branches are tracking a remote branch
git remote show origin
Working with a remote Subversion repository (but with git locally)
git-svn clone [http location of an svn repository]
Now you can work with the checked out directory as though it was a git repository. (cuz it is)
Pushing (committing) changes to a remote Subversion repository
git-svn dcommit
Updating a local git repository from a remote Subversion repository
git-svn rebase
NOTE: make sure you have your perl bindings to your local svn installation.