Some major new features in 5.3:

1. Namespaces! They didn’t end up exactly as I thought they would but they are a major feature PHP was missing for a long time, and I’m very curious to see how it works out in big projects.
2. Closures and anonymous functions! PHP now has first-class functions, and you can do all kinds of crazy stuff with it. Or just make your code easier to read and maintain
3. Garbage collection. PHP engine, being refcount-based, always has had a slight problem with reference loops. Even though usually it was not a big issue since at the end of the request everything is cleaned up, for long-running PHP applications not based on short request pattern it became a problem. Not anymore – now the engine knows to clean up such loops.
4. Late static binding – it’s somewhat exotic thing for people that never encountered it, but was very burning issue for people that did need it. Basically, when class Foo extends class Bar, and the method func() defined in Foo is called as Bar::func(), there was no way to distinguish it from Foo::func(). Now there is. This allows to implement all kinds of cool patterns like ActiveRecord.
5. Intl extension in core – lots of functions to allow you to internationalize your application.
6. Phar in core – now you can pack all the application in one neat file and still be able to run it!

Also in 5.3:

1. Nowdocs – same as heredocs, but doesn’t parse variables. Excellent feature for somebody that wants to include bing chunk of text into the script which can happen to have $’s etc. in it.
2. ?: shortcut. That’s simple – $a?:$b is $a if $a is true, otherwise it’s $b.
3. goto. Yes, I know. But now we have it too. Deal with it.
4. mysqlnd – native PHP-specific mysql driver.

Last but definitely not least – tons of performance improvements, bug fixes, etc. Download it today!

All information in this article can be found in the man pages for du and df. In case you get bored reading the man pages, and you want your work quickly, then this article is for you.

‘du’ – find the size of a directory

$ du

Enter the above at the command prompt, you can view a list of directories in the current directory with their sizes. The last line of output gives you the size of the current directory including subdirectories. The size given the size of the files and directories in the current directory and all its subdirectories. Note that by default are the size in kilobytes.

$ du / home / david

The above command would be the directory, size of the directory / home / david

$du  -h

This command gives you a better outcome than standard. The option “-h” stands for the human-readable format. So that the size of the files and directories are this time with a suffix ‘K’ if its kilobytes and “M” if its Megabytes and ‘G’, if its gigabytes.

$du -ah

This command would be in his performance, not just the directories, but also all the files in the current directory. Note that “you” always counts all files and directories, with the final size in the last line. But the “-a” shows the file name along with the directory name in the output. ‘-h’ is re-readable form.

$du -c

This gives you a large sum in the last line of output. So, if your directory is 30MB the last 2 lines of output would be

30M.
30M total

In the first line will be the default last line of the “du” output, indicating the size of the list and a further display of the same size, followed by the string “Total”. This is useful if you run this command with the command grep only the final size of a directory, as shown below.

$ du -ch | grep total

This would have only one line in the output shows the size of the current directory including all subdirectories.

Note: If you are not familiar with the lines (around the above command possible) refer to Article No. 24 Grep is one of the most important commands in Unix. See Rule No. 25 to learn more about grep.

$du -s

This shows a summary of the directory size. It is the easiest way to know the size of the current directory.

$du -S

This would increase the size of the current directory without the size of the subdirectories in that directory. So it basically shows the total size of all files in the current directory.

$du --exculde = mp3

The above command would be the size of the current directory with all subdirectories, but it would make all files with the given pattern in their filenames. Thus in the above case, if it happens, all MP3 files in the current directory or its subdirectories, their size is not taken into account when calculating the total list size.

‘df’ – finding the disk free space / disk usage

$df

Enter the above is a table consisting of 6 columns. All columns are very easy to understand. Remember that the “size”, “Used” and “free” columns use kilobytes as a unit. The “Use% column shows the use as a percentage, which is also very useful.

$df -h

Shows the same performance as the previous one, but the command “-h” shows human-readable format. Therefore, instead of kilobytes as the unit of output would have been “M” for megabytes and “G” for gigabytes.

The majority of users are not on the other parameters, which are to “df”. So I will not discuss.

I will again show you an example that I am on my computer. I have actually saved this as a script called “use” because I think it often.

Example:

I have my Linux installation on / dev/hda1 is mounted and I have my Windows partitions as well (by default every time Linux boots). So ‘df’ default shows me the disk usage of my Linux and Windows partitions. And I’m only in the hard disk using the Linux partitions. That is what I use:

$df-h | grep / dev/hda1 | cut-c 41-43

This command displays the following on my computer

45%

Basically, this command “df” which uses all the disk partitions and then extracts the lines with / dev/hda1, because I am only in this. Then cut the characters from the 41st to 43 Column, since the columns, the use in%, that is what I want.

$array = get_defined_vars();
 
print_r($array);

if you want to find out only SERVER vars you can try this;

print_r($array["_SERVER"]);

if you want to see vars in regular

echo "<pre>";
print_r($array);
echo "</pre>";

So here we go;

To dump all databases to a file:

$ mysqldump -u dbuser -pdbpass --all-databases > all-databases.sql

To dump a single database to a file:

$ mysqldump -u dbuser -pdbpass somedb > somedb.sql

Dump InnoDB in a single transaction:

$ mysqldump -u dbuser -pdbpass --single-transaction somedb > somedb.sql

To restore:

$ mysql -u dbuser -pdbpass somedb < somedb.sql

Unfortunately, although the people in the rule that an IP address is just an unsigned 32-bit integer, and is easy to determine, usually with $ _SERVER [ "REMOTE_ADDR"], where the real challenge – is in defining the range within which it must decide whether the IP address. IP ranges are usually divided into three categories (in increasing complexity):

1. Wild Card: 192.168.10 .*
2. Start-end: 10.1.0.0-10.1.255.255
3. * CIDR: 172.16.1.0/24

* Classless Inter-Domain Routing

The wild card method, or ‘class’, lets you in the class A (10 .*.*.*), Class B (172.16 .*.*) or Class C (192.168.10 .*) levels granularity of the things we like in the old days (before the web decided to make the popular internet). But still, this is just not granular enough for practice.

Thus was born CIDR (yes, I’m talking about skipping the end of last start now). CIDR was on the concept that we really do not need to create networks to 8, 16, 24-bit boundaries, and we could be more granular by using an arbitrary number (from 2-30) to a series of networks. Details about why you can not use “31″ beyond the scope of this article.

CIDR renaming of the former Class A, B and C networks / 8, / 16 and / 24, and reflects the left-most significant bits of the 32-bit IP address. Thus was born the possibility of very specific IP ranges in the form abcd / xx. However, part of the problem with this is that, although it succinctly describes the network beginning and end, the most normal mortal people could not decipher. CIDR addressing may also be in the form of a longer netmask, eg abcd/255.255.255.224

The simplified form of start-IP – IP in the end was just the place for mortals and is typically used by persons without networking background. There is also strong in the consumer broadband router, and especially in Microsoft Windows DHCP server.

To have declared, as a number, and hence that a network mask is, how can we use this knowledge to help us in determining whether an IP is in an area?

What this article will attempt to do if the design of algorithms for the verification of IP addresses easier.

Logically, Method 1 (the wildcard), the method can be easily 2 (start-end) through the use of setting start and end of the wildcard string and replaces the character “*” and 0 for the start and 255 for the end, for example, “192.168.10 .*” will “192.168.10.0-192.168.10.255″ which (I hope) will be for everyone apparently.

We can then assess whether Method1 and Method2 in the same way. In this, we simply use the PHP function in ip2long () for all 3 values and a mathematical test start <= IP <= end.

list ($ low, $ II) = explode ('-', $, 2);
        $ Lower_dec = ip2long ($ lower);
        $ Upper_dec = ip2long ($ top);
        $ Ip_dec = ip2long ($ ip);
        return (($ ip_dec> = $ lower_dec) & & ($ ip_dec <= $ upper_dec));

We have, however, a complicating factor here – PHP does not do unsigned integer (32 bit) – which would be necessary for this math to work. We can do this by switching to negate floating point datatypes. PHP stores floating species as 64-bit and thus will have no problem with the IPv4 address space (Note – This is obviously not enough for granular 128bit IPv6 addressing). It is the easiest way to solve the start <= IP <= end of problem with IP-and floating numers is the following piece of code:

$ Lower_dec = (float) sprintf ( "% u", ip2long ($ lower));
        $ Upper_dec = (float) sprintf ( "% u", ip2long ($ top));
        $ Ip_dec = (float) sprintf ( "% u", ip2long ($ ip));
        return (($ ip_dec> = $ lower_dec) & & ($ ip_dec <= $ upper_dec));

Next we have the challenge of handing the CIDR netmasks. What we can do is to create a format CIDR IP address / netmask, and calculate the start and end IP addresses of this block and proceed as before – but that would not take a joke – and would mean that I do not really taught by this article.

The method we use here is how the whole world of Internet routers, if a destination IP is in a given CIDR address space. And we receive and dirty with bitmask and bitwise logical operators.

This is a real world example, my web server IP 80.76.201.37 and the netblock in which it resides, is 80.76.201.32/27, how does this all mean?

Well, the / 27 indicates that the first 27 bits of the IP address are the same network and IP address in this network (area) have the same only 27 bits are identical. Bits 28-32 are variable and may be 5 bits of the variation. If you know your binary, so this means, 32 IP addresses. (However, with routing, you can not use the top and bottom of a range of IP addresses, because this special and the network and broadcast addresses. [This is also the reason why a / 31 is not much (except for PPP connections) you can not use the 2-addresses, which gives you room]).

So thinking logically, bitwise, if my IP address and CIDR specification, then all I have to do is verify that the first 27 bits are all involved, and I’m good. Right. How would we do this in PHP? Sounds simple, can only use PHP’s bitwise logical AND operator: &
Also correct.

To achieve this, we need to convert 27 in 27, which really means – a 32-bit number of 27 ones and zeros in binary-5 (which is what really looks like 255,255,255,224).

In pseudo-code that you then do if (IP & bitmask) == (RANGE & bitmask), then everything is good and you know that the IP is in the area.

Visualization of this with our IP address (using the Unix tool very handy ipcalc):

Address: 80.76.201.37 01010000.01001100.11001001.00100101
Netmask: 255,255,255,224 11111111.11111111.11111111.11100000
Wildcard: 0.0.0.31 00000000.00000000.00000000.00011111

Network: 80.76.201.32/27 01010000.01001100.11001001.00100000
HostMin: 80.76.201.33 01010000.01001100.11001001.00100001
HostMax: 80.76.201.62 01010000.01001100.11001001.00111110
Broadcast: 80.76.201.63 01010000.01001100.11001001.00111111
Hosts / Net: 30

You can do this in the wild card line-0.0.0.31, and the network-ored with wildcard results in the broadcast address: 80.76.201.63.

Knowing this, then the IP address ANDed with the network address is the same value as the margin ANDed with the network address and thus can be used as a comparison for an IP Broadcast resident in this area.

How can we network address in PHP, we have two strategies, one is in such a simple substr () and take the left bits of the number pad and then just to the right with 0s. Or we can do some math with “NOT from 2 to the power of the (32-area) – 1″. In order for our value / 27 This gives us the decimal value 31, NOTED results (65536-31) (representation in bit-form – PHP, it is considered a negative whole number, but we do not need to worry about that).

I am sure that from now on, you scream for some code (and if you are stuck in this long, you really deserve it).

Code to manipulate a number / netmask in a broadcast address, with mathematics, provided:

      $ Ip = "80.76.201.37";
      $ Row = "80.76.201.32";
      $ Netmask = 27;

We can change the IP addresses too long integers with ip2long (with variable_dec – December is the abbreviation for decimal):

      $ Range_dec = ip2long ($ range);
      $ Ip_dec = ip2long ($ ip);

This gives us the basis of our mathematics, we need now only to the broadcast address.

Strategy 1 with str_pad to a string by padding with 0s and 1s.

      $ Netmask_dec = bindec (str_pad ('', $ netmask,'1 ')
       . str_pad ('', 32 - $ netmask,'0 '));

We can achieve the same result if the mathematics of NOTtin wildcard value. That is our strategy 2:

      $ Wildcard_dec = pow (2, (32 - $ netmask)) - 1;
      $ Netmask_dec = ~ $ wildcard_dec;

Once we know that the netmask address (decimal), as we have here, we know that if Anding this with the original IP results to check against the margin ANDed with the netmask, the IP is in the area, defined by the range / mask.

This can be done simply with:

      return (($ ip_dec & $ netmask_dec) == ($ range_dec & $ netmask_dec));

I moved all this logic in an easy to make the file to a single function ip_in_range ($ ip, $ range) in which $ ip is the IP address you want to validate and $ field is a one of the above formats , Wild Card, start-end solution or CIDR. The function is a simple TRUE or FALSE, if the IP is in this area.