:/.{80,}

You can use the regex anywhere, actually, but this is a good one to store in the useful command list. Or, create an alias for it in your .vimrc file for quick access.

Step 1: Create an array

This is easily done by surround space separated items in parenthesis. For example:

files=( dir1/file1.php dir2/file2.php dir1/subdir/file3.php )

Note: Be aware of any spaces within the array items. If you have this, you’ll need to surround it in quotes. See appendix at the end of this post.

Step 2: Figure out what you want to do to each of the items in the array

The next part is figuring out what you want to do to each of the items in the array. Keep in mind, these items can be variables, filenames, text, numbers, whatever. For example, I want to see how large each of these files are along with other information. For this, I would run ls -lh filename.php

Unix~ ls -lh dir1/file1.php
-rw-r--r-- 1 user group 2.7K May  4 16:47 dir1/file1.php

Step 3: Iterate through the list of array items

Finally, let’s perform the action from step 2 on all of the items in our array. For this, the key is to use ${array[@]}, which says run through all (@ll) of the items in the array called “array”. Going along with the contrived, simple example set in the previous steps, the final command is:

for file in ${files[@]}; do ls -lh $file; done

The output from the above command is:

Unix~ for file in ${files[@]}; do ls -lh $file; done
-rw-r--r-- 1 user group 2.7K May  4 16:47 dir1/file1.php
-rw-rw-r-- 1 user group 2.8K Aug 25 15:23 dir2/file2.php
-rw-r--r-- 1 user group 2.4K Mar  7 19:57 dir1/subdir/file3.php

APPENDIX: Working with spaces in array items

If you have spaces within your array items, be sure to surround them with quotes like such:

test=( one "two 2" "three 3 tree" )

On top of that, you’ll need to surround ${test[@]} in quotes like such:

for i in "${test[@]}"; do echo $i; done

Here’s what you’ll get:

Unix~ for i in "${test[@]}"; do echo "==> $i"; done
==> one
==> two 2
==> three 3 tree

If you don’t use quotes, you’ll get this instead (BAD!):

for i in ${test[@]}; do echo "==> $i"; done
==> one
==> two
==> 2
==> three
==> 3
==> tree

We’ll first see what’s in the compressed tarball named sandbox.tar.gz by using the --list option of tar:

thelinuxdaily$ tar --list --file=sandbox.tar.gz
sandbox/
sandbox/delete_me/
sandbox/delete_me/hello.txt
sandbox/hello.txt
sandbox/hello2.txt
sandbox/hello3.txt
sandbox/save_me/
sandbox/save_me/hello.txt

Let’s try to delete the folder called sandbox/delete_me from the compressed tarball:

thelinuxdaily$ tar --delete --file=sandbox.tar.gz sandbox/delete_me
tar: Cannot update compressed archives
tar: Error is not recoverable: exiting now

See what happened? That means we need to uncompress it. In this case, it’s a .gz compression type, so we’ll use gunzip (if you were using bz2, you’d use bunzip2:

thelinuxdaily$ gunzip sandbox.tar.gz

Let’s try to delete the folder sandbox/delete_me again:

thelinuxdaily$ tar --delete --file=sandbox.tar sandbox/delete_me

We didn’t get an error message, so that’s good. Let’s see if it’s gone by using --list again:

thelinuxdaily$ tar --list --file=sandbox.tar
sandbox/
sandbox/hello.txt
sandbox/hello2.txt
sandbox/hello3.txt
sandbox/save_me/
sandbox/save_me/hello.txt
thelinuxdaily$ gzip sandbox.tar

Excellent! That’s what we needed to see. If you have any other tips, feel free to use the comments below.

sudo chown -R `id --user` /var/www/
sudo chgrp -R `id --user` /var/www/

If you don’t have sudo enabled on your distro, remove ‘sudo’ from the commands and login as root first before executing them with ‘su’.

You should now be able to write to all the files within /var/www/. My only other suggestion is that you can be a bit more selective about what directories and files are allowed write access by removing the recursive option “-R” from the command.

cat test.txt | split -l 10 - split_

If you’d like to use numeric suffixes instead of alphabetic, use the ‘-d’ option in split. There’s more tips and tricks where that came from in the split man page, so be sure to check it out.

^[a-zA-Z0-9_-.]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+$
^[a-zA-Z0-9_-.]+@[a-zA-Z0-9-]+.[com|edu|gov]+$

This is two different ways of doing the same thing. If you want tighter control on your validity, I would recommend specifying com, edu, gov or other domain names you consider valid like shown in the second example above.

A quick PHP script to demonstrate:

<?php

// hit this in a browser and specify the email in the URL:
// http://www.mywebsite.com/email_validate.php?email=foo@bar.com

$email=$_GET['email'];

//if (!eregi('^[a-zA-Z0-9_-.]+@[a-zA-Z0-9-]+.[a-zA-Z0-9-.]+$', $email)) {
if (!eregi('^[a-zA-Z0-9_-.]+@[a-zA-Z0-9-]+.[com|edu|gov]+$', $email)) {
        echo "<p>That is not a valid email address.</p>".
             "<p>Please return to the previous page and try again.</p>";
        exit;
}
else
        echo "<p>That is one sexy email address!</p>";
?>

#!/bin/sh

if [ $# -lt 1 ]; then
   echo "Usage: $0 <filename>"
   exit
fi

# Variables
#file=testfile.txt
file=$1

# First, change line number $linenum, then insert
# two spaces at the beginning of that same line
linenum=1
sed -i "${linenum}c This line was changed" $file
sed -i "${linenum}s/^/   /" $file

# Insert a line at $linenum, then insert text at
# the end of that same line.
linenum=2
sed -i "${linenum}i This line was inserted" $file
sed -i "${linenum}s/$/ end of line/" $file

# Match a particular pattern in the file and insert a line
# directly above the first match (will need massaging for
# multiple lines, perhaps using an array)
linenum=`grep -n pattern $file | head -n1 | cut -d: -f1`
linenum_above=`echo "$linenum - 1" | bc`
sed -i "${linenum_above}i This line was inserted" $file

echo "Resulting File:"
cat $file

As usual, take a look at the man pages for sed for more information.

sed -i '/pattern/d' filename

For example, say I want to remove all lines in the file garbage.txt that contain the text “foobar”. Here is my console output.

user@localhost $ cat garbage.txt
This is a plain text file that
contains lots of text
but most of it is foobar
and it's unnecessary
to include foobar in text.

user@localhost$ sed -i '/foobar/d' garbage.txt
user@localhost$ cat garbage.txt
This is a plain text file that
contains lots of text
and it's unnecessary

user@localhost$

base64 /dev/random | head -c 2000000 > random.txt

For the second method, let’s use this scenario: we need to quickly fill a file with the string “abcdefghijklmnopqrstuvwxyz 123456890n” repeated until the result is 2MB in size in order to test a parsing algorithm in our program. The following script will generate this file for us and call it result.txt. I have tested this script up to 20MB and it took only a few seconds, however, the larger the size, the longer this script will take to run (very inefficient for really large files). At first glance, it seems like a complicated script, but upon second glance you’ll notice that it’s mostly user defined variables and safe guard checks for user input.

#!/bin/sh

# Variables; 2000000 = 2MB
max_size=20000000
filename=result.txt
tmpfilename=tmp.txt
string="abcdefghijklmnopqrstuvwxyz 123456890n"

# File checks so we don't overwrite somebody's important files
if [ -e $tmpfilename ]; then
        echo "File: $tmpfilename exists!"
        echo "This script is going to use this as a temporary file, so either"
        echo "modify the script variable $tmpfilename or remove the file."
        exit 1
fi

if [ -e $filename ]; then
        echo "File: $filename exists!"
        echo "Remove it and restart this script"
        exit 1
else
        echo -e $string > $filename
fi

# Initialize the variable
size=$(stat -c %s $filename)

# Start the loop, increasing the size of the file 2x until reaching max_size
while [ $size -lt $max_size ]; do
        cat $filename > $tmpfilename
        cat $tmpfilename >> $filename
        size=$(stat -c %s $filename)
done

# Chop off any excess
head -c $max_size $filename > $tmpfilename
mv $tmpfilename $filename

I believe the first method is fantastic. It creates a file very quickly and it’s easy to understand. I can see room for improvement on the second method. If you have any suggestions, please feel free to share them with me! I would really love to hear it.