Some interesting DOM-related tools covered in this post are YAHOO.util.Element, YAHOO.util.DOM and YAHOO.util.Selector.

YAHOO.util.Dom

YAHOO.util.Element is basically a singleton instance that provides various DOM methods. Following are some of the methods that one may find useful. For more information, please refer to the API documentation.

Finding an Element by Id

To find an element by its Id, instead of document.getElementById, another way through YUI would be through YAHOO.util.Dom.get.

var element = YAHOO.util.Dom.get('some_element');

Finding Element(s) by Class Name

To find elements by class name,

var elements = YAHOO.util.Dom.getElementsByClassName('some_class');

YAHOO.util.Element

Before I discover how powerful is jQuery, I have relied on YAHOO.util.Element a lot in various tasks. Basically, YAHOO.util.Element wraps a HTMLElement and provide some methods to simplify the code used in certain DOM operations such as getting and setting attributes, manipulating element position etc. Detailed API documentation is here.

Creating a New Element

To create a new element, one typically pass in the result from document.createElement into the constructor as follows. For example, to create a new link element.

// create a new element
var element = new YAHOO.util.Element(document.createElement('a'));

// set the href
element.set('href', 'http://www.google.com/');

// insert caption
element.appendChild(document.createTextNode(
    'Click me to the search engine.'
));

element.appendTo(document.body);

Uses an existing Element

To wrap YUI Element component methods to an existing HTMLElement, pass in the element OR the element Id into the constructor.

var by_element = new YAHOO.util.Element(
    YAHOO.util.Dom.get('some_id')
);
var by_id = new YAHOO.util.Element('some_id');

Getting the original HTMLElement

Sooner or later one would find out that it is impossible to call some DOM methods through the YAHOO.util.Element instance, for instance the setAttribute method. Besides that, as of 2.6.0, the appendChild method also doesn’t seem to accept instance from YAHOO.util.Element. Therefore to get the wrapped element,

var some_container = new YAHOO.util.Element(container_element);
var the_yui_element = new YAHOO.util.Element(original_element);

// this will result in an error
some_container.appendChild(the_yui_element);

// but this won't
some_container.appendChild(the_yui_element.get('element'));

Hopefully instances of YAHOO.util.Element are also accepted by all methods requiring HTML element in future releases.

YAHOO.util.Selector

DOM Collection via CSS3 Selector

Those who are from jQuery may be interested in knowing that YUI also provides similar functionality via YAHOO.util.Selector. For those who are interested, the API documentation is here. As an example,

var elements = YAHOO.util.Selector.query('body p');

For those who are interested, the official site provides a great amount of information, guide, examples and tutorials. However, for those who are new to javascript, the tutorials may take them some time to get used to. However, after investing enough time in it, then the extensive API documentation will be extremely useful. I will document down some notes on YAHOO.util.Event, which is my favorite component next time.

YUI – DOM Manipulation is a post from: WhileIf Blog

First a not so useful script to find odd numbers (it’s just for the bench marking purposes)

error_reporting(-1);
$time = microtime(TRUE);
$mem = memory_get_usage();

$evens = $odds = array();
foreach (range(1, 500000) as $j) {
 try {
 if ($j % 2 != 0) {
 throw new Exception("odd number");
 } else {
 $even[] = $j;
 }
 } catch (Exception $e) {
 $odd[] = $j;
 }
}
echo "evens: " . count($evens) . ", odds " . count($odds);
print_r(array('memory' => (memory_get_usage() - $mem) / (1024 * 1024), 'microtime' => microtime(TRUE) - $time));

And now the same silly script without using exceptions.

error_reporting(-1);
$time = microtime(TRUE);
$mem = memory_get_usage();

$evens = $odds = array();
foreach (range(1, 500000) as $k) {
 if ($k % 2 != 0) {
 $odds[] = $j;
 } else {
 $evens[] = $j;
 }
}

echo "odds: " . count($odds) . ", evens " . count($evens);
print_r(array('memory' => (memory_get_usage() - $mem) / (1024 * 1024), 'microtime' => microtime(TRUE) - $time));

The outcomes are as follows:

with exceptions
memory: 15.329871597534
microtime: 2.1678985214796
without exceptions
memory: 15.216841537290
microtime: 0.2632134548652
As we can see the exploitation of memory is approximately the same. But the script turns out to be almost ten times faster without the use of exceptions.

I have performed these tests using apache on my PC with 2048 MB of memory and PHP 5.3
Now we are going to execute the tests with an almost similar host. This time the same configuration, but PHP 5.4 instead of 5.3.

PHP 5.4:

With exceptions
memory: 10.574567984512
microtime: 0.23456897254687
without exceptions
memory: 10.569843616487
microtime: 0.10698432145785
I’m very much impressed with the results. The memory usage here in PHP 5.4 is much efficient now and better run time too (nearly ten times faster).

The results indicate that my conclusion is that the use of exceptions in the flow of our scripts is not as bad as I thought. OK, in this example, the use of exceptions is not a good idea, but other exceptions, if used in complex scripts prove to be really useful. I must also take into account the tests when done over 100,000 iterations so as to get a general idea in the performance differences.

PHP – Checking Exceptions speed is a post from: WhileIf Blog

print_r(getrusage());
/* prints
Array
(
[ru_oublock] => 0
[ru_inblock] => 0
[ru_msgsnd] => 2
[ru_msgrcv] => 3
[ru_maxrss] => 12692
[ru_ixrss] => 764
[ru_idrss] => 3864
[ru_minflt] => 94
[ru_majflt] => 0
[ru_nsignals] => 1
[ru_nvcsw] => 67
[ru_nivcsw] => 4
[ru_nswap] => 0
[ru_utime.tv_usec] => 0
[ru_utime.tv_sec] => 0
[ru_stime.tv_usec] => 6269
[ru_stime.tv_sec] => 0
)

*/

That may look a bit cryptic unless you already have a system administration background. Here is the explanation of each value (you don’t need to memorize these):

ru_oublock: block output operations
ru_inblock: block input operations
ru_msgsnd: messages sent
ru_msgrcv: messages received
ru_maxrss: maximum resident set size
ru_ixrss: integral shared memory size
ru_idrss: integral unshared data size
ru_minflt: page reclaims
ru_majflt: page faults
ru_nsignals: signals received
ru_nvcsw: voluntary context switches
ru_nivcsw: involuntary context switches
ru_nswap: swaps
ru_utime.tv_usec: user time used (microseconds)
ru_utime.tv_sec: user time used (seconds)
ru_stime.tv_usec: system time used (microseconds)
ru_stime.tv_sec: system time used (seconds)

To see how much CPU power the script has consumed, we need to look at the ‘user time’ and ‘system time’ values. The seconds and microseconds portions are provided separately by default. You can divide the microseconds value by 1 million, and add it to the seconds value, to get the total seconds as a decimal number.

Let’s see an example:

// sleep for 3 seconds (non-busy)
sleep(3);

$data = getrusage();
echo "User time: ".
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 0.011552
System time: 0
*/

Even though the script took about 3 seconds to run, the CPU usage was very very low. Because during the sleep operation, the script actually does not consume CPU resources. There are many other tasks that may take real time, but may not use CPU time, like waiting for disk operations. So as you see, the CPU usage and the actual length of the runtime are not always the same.

Here is another example:

// loop 10 million times (busy)
for($i=0;$i<10000000;$i++) {

}

$data = getrusage();
echo "User time: ".
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 1.424592
System time: 0.004204
*/

That took about 1.4 seconds of CPU time, almost all of which was user time, since there were no system calls.

System Time is the amount of time the CPU spends performing system calls for the kernel on the program’s behalf. Here is an example of that:

$start = microtime(true);
// keep calling microtime for about 3 seconds
while(microtime(true) - $start < 3) {

}

$data = getrusage();
echo "User time: ".
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 1.088171
System time: 1.675315
*/

Now we have quite a bit of system time usage. This is because the script calls the microtime() function many times, which performs a request through the operating system to fetch the time.

Also you may notice the numbers do not quite add up to 3 seconds. This is because there were probably other processes on the server as well, and the script was not using 100% CPU for the whole duration of the 3 seconds.

For this, we are going to utilize the getrusage() function. Keep in mind that this is not available on Windows platforms.

print_r(getrusage());
/* prints
Array
(
[ru_oublock] => 0
[ru_inblock] => 0
[ru_msgsnd] => 2
[ru_msgrcv] => 3
[ru_maxrss] => 12692
[ru_ixrss] => 764
[ru_idrss] => 3864
[ru_minflt] => 94
[ru_majflt] => 0
[ru_nsignals] => 1
[ru_nvcsw] => 67
[ru_nivcsw] => 4
[ru_nswap] => 0
[ru_utime.tv_usec] => 0
[ru_utime.tv_sec] => 0
[ru_stime.tv_usec] => 6269
[ru_stime.tv_sec] => 0
)

*/

That may look a bit cryptic unless you already have a system administration background. Here is the explanation of each value (you don’t need to memorize these):

ru_oublock: block output operations
ru_inblock: block input operations
ru_msgsnd: messages sent
ru_msgrcv: messages received
ru_maxrss: maximum resident set size
ru_ixrss: integral shared memory size
ru_idrss: integral unshared data size
ru_minflt: page reclaims
ru_majflt: page faults
ru_nsignals: signals received
ru_nvcsw: voluntary context switches
ru_nivcsw: involuntary context switches
ru_nswap: swaps
ru_utime.tv_usec: user time used (microseconds)
ru_utime.tv_sec: user time used (seconds)
ru_stime.tv_usec: system time used (microseconds)
ru_stime.tv_sec: system time used (seconds)

To see how much CPU power the script has consumed, we need to look at the ‘user time’ and ‘system time’ values. The seconds and microseconds portions are provided separately by default. You can divide the microseconds value by 1 million, and add it to the seconds value, to get the total seconds as a decimal number.

Let’s see an example:

// sleep for 3 seconds (non-busy)
sleep(3);

$data = getrusage();
echo "User time: ".
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 0.011552
System time: 0
*/

Even though the script took about 3 seconds to run, the CPU usage was very very low. Because during the sleep operation, the script actually does not consume CPU resources. There are many other tasks that may take real time, but may not use CPU time, like waiting for disk operations. So as you see, the CPU usage and the actual length of the runtime are not always the same.

Here is another example:

// loop 10 million times (busy)
for($i=0;$i<10000000;$i++) {

}

$data = getrusage();
echo "User time: ".
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 1.424592
System time: 0.004204
*/

That took about 1.4 seconds of CPU time, almost all of which was user time, since there were no system calls.

System Time is the amount of time the CPU spends performing system calls for the kernel on the program’s behalf. Here is an example of that:

$start = microtime(true);
// keep calling microtime for about 3 seconds
while(microtime(true) - $start < 3) {

}

$data = getrusage();
echo "User time: ".
($data['ru_utime.tv_sec'] +
$data['ru_utime.tv_usec'] / 1000000);
echo "System time: ".
($data['ru_stime.tv_sec'] +
$data['ru_stime.tv_usec'] / 1000000);

/* prints
User time: 1.088171
System time: 1.675315
*/

Now we have quite a bit of system time usage. This is because the script calls the microtime() function many times, which performs a request through the operating system to fetch the time.

Also you may notice the numbers do not quite add up to 3 seconds. This is because there were probably other processes on the server as well, and the script was not using 100% CPU for the whole duration of the 3 seconds.

PHP – CPU Usage Information is a post from: WhileIf Blog

Below is a artificial example from the PHP documentation.

<?php

trait Hello
{
 public function sayHello()
 {
 echo 'Hello ';
 }
}

trait World
{
 public function sayWorld()
 {
 echo 'World';
 }
}

class MyHelloWorld
{
 use Hello, World;
 public function sayExclamationMark()
 {
 echo '!';
 }
}

$o = new MyHelloWorld();
$o->sayHello();
$o->sayWorld();
$o->sayExclamationMark();

?>

Which will output:
Hello World!

PHP 5.4 – Code reuse using Traits is a post from: WhileIf Blog

class Test
{
 public static function parseH4()
 {
 echo "H4 Parsed";
 }

 public static function parseH2()
 {
 echo "H2 Parsed";
 }

}

$t = new Test;
$method_prefix = "parse";

$t::{$method_prefix . "h4"}();
$t::{$method_prefix . "h2"}();

Although not a very creative use of the idea, the real power of the above will manifest itself when using dynamic method calls. Along with the support for expressions while calling static class methods, class member access on instantiation has also been added, as shown below.

class Test
{
 public function SayHello()
 {
 echo "Hello World!";
 }
}

(new Test)->SayHello();

Magic quotes has been completely removed. Applications dependent on this feature may need to be updated, to avoid security issues. get_magic_quotes_gpc() and get_magic_quotes_runtime() now always return FALSE. set_magic_quotes_runtime() raises an E_CORE_ERROR level error.

The following functions have been removed from PHP 5.4, so if you are developing any new applications which will probably be migrated to PHP 5.4, avoid using the following functions.

define_syslog_variables()
import_request_variables()
session_is_registered()
session_register()
session_unregister()
mysqli_bind_param()
mysqli_bind_result()
mysqli_client_encoding()
mysqli_fetch()
mysqli_param_count()
mysqli_get_metadata()
mysqli_send_long_data()
mysqli::client_encoding()
mysqli_stmt::stmt()

The register_globals and register_long_arrays php.ini directives have been removed. Safe mode also is no longer supported. Any applications that rely on safe mode for security reasons may need adjustment. This feature had already been deprecated as of PHP 5.3.0 and is now completely removed. This will now generate a fatal E_CORE_ERROR level error when enabled.

PHP 5.4 – Core changes is a post from: WhileIf Blog

The server will now be listening to your requests on port 8000.

php -S localhost:8000

Which will display the following:

PHP 5.4.0 Development Server started at Fri Apr 06 13:56:26 2012

Listening on localhost:8000

Document root is C:\php-5.4.0

Press Ctrl-C to quit.

Of course don’t expect something along the lines of Apache or IIS. This is a small built-in service that lets you quickly check your pages. Absolutely not recommended to use on a production basis.

PHP 5.4 – Built-in Web Server is a post from: WhileIf Blog

$data  = "piece1 piece2 piece3 piece4";
$pieces = explode(" ", $data);
echo $pieces[0]; // piece1
echo $pieces[1]; // piece2

We could instead shorten this to:

$data  = "piece1 piece2 piece3 piece4";
echo explode(" ", $data)[0];

Another example using the ‘getdate()’ function.

# Without Function Array dereferencing

date_default_timezone_set('Asia/Kolkata');

$temp = getdate();

echo $temp['year'];
echo $temp['mon'];

# With Function Array dereferencing

date_default_timezone_set('Asia/Kolkata');

echo getdate()['mon'];
You can use the above in a conditional as shown below:
date_default_timezone_set('Asia/Kolkata');

if(getdate()['mon'] == 4) {
    echo "Month of April";
}

Another example using a custom function.

function getColors ()
{
  return [
          'red' => '#FF0000',
          'green' => '#00FF00',
          'blue' => '#0000FF'
         ];
}

echo getColors()['green']; // returns #00FF00

PHP 5.4 – Function Array Dereferencing is a post from: WhileIf Blog

    class SimpleXML
    {
        use \Prototype;
    }

    $SimpleXML = new SimpleXML();
    $SimpleXML->load = function( $path )
    {
        if( file_exists( $path ))
            return simplexml_load_file( $path );

        return null;
    };

    $SimpleXML->load = function( $data )
    {
        return simplexml_load_string( $data );
    };

The previous code uses SimpleXML and contains a class declaration by that name with a single trait that is shown later. The class is then instantiated and 2 anonymous functions are added to the prototype. With the above code and the Prototype trait, the following statements are both possible.

    $doc = $SimpleXML->load( 'test.xml' );
    $doc = $SimpleXML->load( 'test' );

The first method triggers the Closure that uses simplexml_load_file and the second method triggers simplexml_load_string respectively. You may notice that both functions are assigned to the same property. Using the prototype trait, it is possible to define 2 functions with the same name and number of arguments. This is a lot like traditional method overloading which was previously not possible with PHP. Overloading in this way is primitive and requires that overloaded methods meet certain criteria, namely that a given method return null if the input is not valid.

trait Prototype
{
    private
            $_props = array(),
            $_methods = array();

    function &__get( $name )
    {
        if( array_key_exists( $name, $this->_props ))
        {
            return $this->_props[$name];
        }
        elseif( array_key_exists( $name, $this->_methods ))
        {
            return $this->_methods[$name];
        }

        return null;
    }

    function __set( $name, $value )
    {
        if( is_object( $value ) && is_callable( $value ))
        {
            if( !array_key_exists( $name, $this->_methods ))
            {
                $this->_methods[ $name ] = array();
            }

            if( $value instanceof \Closure )
            {
                $value = $value->bindTo( $this );
            }

            $this->_methods[ $name ][] = $value;
        }
        else
        {
            $this->_props[ $name ] = $value;
        }
    }

    function __call( $name, $args = array() )
    {
        if( array_key_exists( $name, $this->_methods ))
        {
            $methods = $this->_methods[ $name ];

            if( is_array( $methods ))
            {
                foreach( $methods as $method )
                {
                    if( !is_null( $result = call_user_func_array( $method, $args ) ) )
                    {
                        return $result;
                    }
                }
            }
        }

        return null;
    }
}

The __get method This one is fairly self-explanatory as it simply returns a property value or a Closure stored in _props and _methods respectively. The __set method This method first checks to see if the value is in-fact callable. An example of a callable value would be an anonymous function or a class that implements the __invoke method. If the value is a Closure, the BindTo method is called. BindTo simply allows the use of the $this keyword in the closure as you would use it in a normal method. Finally, if the value is not callable, the prototype assumes it is a property and assigns it to the _props array. The __call method This method iterates through all of the matching methods until one returns something other than null. Now the prototype above is well, a prototype. As per the original definition of prototype-based programming, it must also be possible to easily extend your prototype by cloning all of it’s methods and properties.

PHP 5.4 – Traits, Closures, and Prototype-based Programming is a post from: WhileIf Blog

scp Command

The correct syntax is as follows to copy all files including hidden dot files:

$ scp -rp /path/to/source/. user@server2:/path/to/dest/

Where,

-r : Recursively copy entire directories. Note that scp follows symbolic links encountered in the tree trave
-p : Preserves modification times, access times, and modes from the original file.
/path/to/source/. : Appending a dot (.) symbol is very important when you specify /path/to/source as a source path. If you skip dot in path it will only copy normal files and scp will skip all hidden files.
rsync Command

I recommend that you use rsync command to copy files between Unix / Linux based servers and workstations.

$ rsync -avzP /path/to/source/ user@server2:/path/to/dest/

OR

$ rsync -avzP /path/to/source/ user@192.168.1.5:/path/to/dest/

Linux – scp copy all hidden dot files is a post from: WhileIf Blog

tmpfs is similar to ramfs and RAM disk but with a few additional features. tmpfs is able to grow or shrink its space to accommodate files,and it can use swap space to store unneeded data. ramfs and RAM disk doesn’t have this capability.

Use of tmpfs in Linux

Debian, Ubuntu, Fedora, openSUSE, and many other Linux distributions use tmpfs file system to store all their run time data.

For example, in Ubuntu, if I execute the following command, I find that /run is mounted on a tmpfs filesystem.

$ df -h | grep tmpfs
tmpfs 401M 880K 400M 1% /run

The /run directory and its sub-directories store run time data of Linux processes and any running applications that may want to store their data.

You can check the actual [RAM + Swap] use of a tmpfs using df and du commands
Since tmpfs lives completely in the page cache and on swap, all tmpfs pages currently in memory will show up as cached.

tmpfs in some form or other is currently implemented in Sun/Solaris, Linux, and BSDs.

Linux – What is tmpfs ? is a post from: WhileIf Blog

Uptime command gives a one line display that offers the following information -

The current time,
How long the system has been running,
How many users are currently logged on, and
The system load averages for the past 1, 5, and 15 minutes.

System load averages is the average number of processes that are either in a runnable or un-interruptable state.

When I ran the uptime command on my Ubuntu machine, I got the following output.

$ uptime
08:25:48 up 1:21, 2 users, load average: 1.00, 1.01, 1.03

From the output, we can infer that the current time is 8:25 AM, the machine has been running continuously without a reboot for 1 hr and 21 minutes, and there are 2 users currently logged in to the system.

The load average for the past 1, 5 and 15 minutes is 1.00, 1.01, and 1.03 respectively.

Uptime is a simple command that offers useful information to the system administrator.

Linux – Howto find uptime and system load is a post from: WhileIf Blog

To see current status, enter:

<br />$ cat /proc/sys/fs/file-nr</p><p>

OR

<br />$ /sbin/sysctl fs.file-nr</p><p>

Sample outputs:

fs.file-nr = 6272 0 70000
The above output contains three numbers as follows:

6272: The number of allocated file handles.
0: The number of free file handles.
70000: The maximum number of file handles.

The Linux kernel allocates file handles dynamically, but it doesn’t free them again. If the number of allocated files is close to the maximum, you should consider increasing the maximum open file by editing /etc/sysctl.conf file.

Linux- Find Out Open Files Command is a post from: WhileIf Blog

It will display information like:

Number of CPUs
Threads
Cores
Sockets
NUMA nodes
Information about CPU caches,
CPU family, model and stepping.

Alternatively, it can print out in parsable format including how different caches are shared by different CPUs, which can also be fed to other programs.

Open a terminal and type the following command:

$ less /proc/cpuinfo

OR

$ lscpu

Samp-le outputs:

Architecture: x86_64
CPU op-mode(s): 32-bit, 64-bit
CPU(s): 8
Thread(s) per core: 2
Core(s) per socket: 4
CPU socket(s): 1
NUMA node(s): 1
Vendor ID: GenuineIntel
CPU family: 6
Model: 30
Stepping: 5
CPU MHz: 1199.000
Virtualization: VT-x
L1d cache: 32K
L1i cache: 32K
L2 cache: 256K
L3 cache: 8192K

Linux – Find Out CPU Architecture Information is a post from: WhileIf Blog

The syntax for setting path under UNIX / Linux dependent on which shell you are using.

BASH / SH shell uses following syntax:

export PATH=$PATH:/path/to/dir1:/path/to/dir2

For tcsh or csh, shell enter:

set PATH = ($PATH /path/to/dir1 /path/to/dir2)

You can type above command at the terminal or add it to your .bashrc (for BASH/sh shell) or .cshrc (for chs / tcsh shell) so that PATH can be set each time you login into box.

For example add /usr/local/bin to your path under BASH, enter:
export PATH=$PATH:/usr/local/bin

Or add as follows to your .bashrc file:

echo 'export PATH=$PATH:/usr/local/bin' >> ~/.bashrc

If you are using CSH / TCSH, enter:

echo 'set PATH = ($PATH /usr/local/bin /scripts/admin)' >> ~/.cshrc

To display path settings, enter:

$ echo $PATH

Linux – Set your PATH Variable using set or export command is a post from: WhileIf Blog

Here is an example:

$url = "http://whileifblog.com";
if (filter_var($url, FILTER_VALIDATE_URL)) {
      echo "URL is valid";
} else {
      echo "URL is invalid";
}

The only problem with this approach is that it has a few caveats. The PHP filter_var function has only been available since PHP 5.2. If you are running a PHP version older than 5.2 you are out of luck.

There is also a bug in PHP 5.2.13 and PHP 5.3.2 that will not allow URLs with dashes in them to validate. If you are unsure of your PHP version you can run php -v from the command line if you have command line PHP installed, or create a PHP file with the following contents and navigate to it using your web browser:

phpinfo();

Because of the limitations of filter_var(), you may have to fall back to using a regular expression. Here is an example of one regular expression that allows dashes in the URL:

$url = "http://whileifblog.com";
if (preg_match("/\b(?:(?:https?|ftp):\/\/|www\.)[-a-z0-9+&@#\/%?=~_|!:,.;]*[-a-z0-9+&@#\/%=~_|]/i", $url)) {
    echo "URL is valid";
} else {
    echo "URL is invalid";
}

There is a lot of debate about whether using a regular expression is a good idea when doing URL validation. If you are uncertain and looking for a guide then this may help:

If you are using a version of PHP that is older than PHP 5.2:
- Use the regular expression approach
If you are using PHP 5.2.13 or PHP 5.3.2 and need URLs with dashes to validate:
- Use the regular expression approach
If you don’t fall into one of the above categories:
- Use the filter_var() approach
Some have complained that using the PHP filter_var() function is too permissive and allows URLs that should not validate. One solution is to use filter_var for your initial validation and then perform additional validation checks if the original filter_var validation passes.

PHP – Validating a URL is a post from: WhileIf Blog