Wednesday, 7 August 2013

17 useful functions for manipulating arrays in PHP

This document outlines some of the more useful functions in the PHP array toolkit, and features detailed explanations and usage examples.
Like arrays in other languages, PHP arrays allow you to store multiple values in a single variable and operate on them as a set. PHP offers an extensive array manipulation toolkit—over 60 functions—that lets you process arrays in almost any way imaginable including reversing them, extracting subsets, comparing and sorting, recursively processing, and searching them for specific values.
This document outlines some of the more useful functions in the PHP array toolkit, with explanations and usage examples:
This table is also available as free downloadable PDF.

Function
Explanation
Example
sizeof($arr)
 This function returns the number of elements in an array.
Use this function to find out how many elements an array contains; this information is most commonly used to initialize a loop counter when processing the array.
 Code:
$data = array("red", "green", "blue");

echo "Array has " . sizeof($data) . " elements";
?>

Output:
Array has 3 elements
array_values($arr)
 This function accepts a PHP array and returns a new array containing only its values (not its keys). Its counterpart is the array_keys() function.
Use this function to retrieve all the values from an associative array.
 Code:
$data = array("hero" => "Holmes", "villain" => "Moriarty");
print_r(array_values($data));
?>

Output:
Array
(
[0] => Holmes
[1] => Moriarty
)
array_keys($arr)
 This function accepts a PHP array and returns a new array containing only its keys (not its values). Its counterpart is the array_values() function.
Use this function to retrieve all the keys from an associative array.
 Code:
$data = array("hero" => "Holmes", "villain" => "Moriarty");
print_r(array_keys($data));
?>

Output:
Array
(
[0] => hero
[1] => villain
)
array_pop($arr)
 This function removes an element from the end of an array.
 Code:
$data = array("Donald", "Jim", "Tom");
array_pop($data);
print_r($data);
?>

Output:
Array
(
[0] => Donald
[1] => Jim
)
array_push($arr, $val)
 This function adds an element to the end of an array.
 Code:
$data = array("Donald", "Jim", "Tom");
array_push($data, "Harry");
print_r($data);
?>

Output:
Array
(
[0] => Donald
[1] => Jim
[2] => Tom
[3] => Harry
)
array_shift($arr)
 This function removes an element from the beginning of an array.
 Code:
$data = array("Donald", "Jim", "Tom");
array_shift($data);
print_r($data);
?>

Output:
Array
(
[0] => Jim
[1] => Tom
)
array_unshift($arr, $val)
 This function adds an element to the beginning of an array.
 Code:
$data = array("Donald", "Jim", "Tom");
array_unshift($data, "Sarah");
print_r($data);
?>

Output:
Array
(
[0] => Sarah
[1] => Donald
[2] => Jim
[3] => Tom
)
each($arr)
 This function is most often used to iteratively traverse an array. Each time each() is called, it returns the current key-value pair and moves the array cursor forward one element. This makes it most suitable for use in a loop.
 Code:
$data = array("hero" => "Holmes", "villain" => "Moriarty");
while (list($key, $value) = each($data)) {
echo "$key: $value \n";
}
?>

Output:
hero: Holmes
villain: Moriarty
sort($arr)
 This function sorts the elements of an array in ascending order. String values will be arranged in ascending alphabetical order.
Note: Other sorting functions include asort(), arsort(), ksort(), krsort() and rsort().
 Code:
$data = array("g", "t", "a", "s");
sort($data);
print_r($data);
?>

Output:
Array
(
[0] => a
[1] => g
[2] => s
[3] => t
)
array_flip($arr)
 The function exchanges the keys and values of a PHP associative array.
Use this function if you have a tabular (rows and columns) structure in an array, and you want to interchange the rows and columns.
 Code:
$data = array("a" => "apple", "b" => "ball");
print_r(array_flip($data));
?>

Output:
Array
(
[apple] => a
[ball] => b
)
array_reverse($arr)
 The function reverses the order of elements in an array.
Use this function to re-order a sorted list of values in reverse for easier processing—for example, when you're trying to begin with the minimum or maximum of a set of ordered values.
 Code:
$data = array(10, 20, 25, 60);
print_r(array_reverse($data));
?>

Output:
Array
(
[0] => 60
[1] => 25
[2] => 20
[3] => 10
)
array_merge($arr)
 This function merges two or more arrays to create a single composite array. Key collisions are resolved in favor of the latest entry.
Use this function when you need to combine data from two or more arrays into a single structure—for example, records from two different SQL queries.
 Code:
$data1 = array("cat", "goat");
$data2 = array("dog", "cow");
print_r(array_merge($data1, $data2));
?>

Output:
Array
(
[0] => cat
[1] => goat
[2] => dog
[3] => cow
)
array_rand($arr)
 This function selects one or more random elements from an array.
Use this function when you need to randomly select from a collection of discrete values—for example, picking a random color from a list.
 Code:
$data = array("white", "black", "red");
echo "Today's color is " . $data[array_rand($data)];
?>

Output:
Today's color is red
array_search($search, $arr)
 This function searches the values in an array for a match to the search term, and returns the corresponding key if found. If more than one match exists, the key of the first matching value is returned.
Use this function to scan a set of index-value pairs for matches, and return the matching index.
 Code:
$data = array("blue" => "#0000cc", "black" => "#000000", "green" => "#00ff00");
echo "Found " . array_search("#0000cc", $data);
?>

Output:
Found blue
array_slice($arr, $offset, $length)
 This function is useful to extract a subset of the elements of an array, as another array. Extracting begins from array offset $offset and continues until the array slice is $length elements long.
Use this function to break a larger array into smaller ones—for example, when segmenting an array by size ("chunking") or type of data.
 Code:
$data = array("vanilla", "strawberry", "mango", "peaches");
print_r(array_slice($data, 1, 2));
?>

Output:
Array
(
[0] => strawberry
[1] => mango
)
array_unique($data)
 This function strips an array of duplicate values.
Use this function when you need to remove non-unique elements from an array—for example, when creating an array to hold values for a table's primary key.
 Code:
$data = array(1,1,4,6,7,4);
print_r(array_unique($data));
?>

Output:
Array
(
[0] => 1
[3] => 6
[4] => 7
[5] => 4
)
array_walk($arr, $func)
 This function "walks" through an array, applying a user-defined function to every element. It returns the changed array.
Use this function if you need to perform custom processing on every element of an array—for example, reducing a number series by 10%.
 Code:
function reduceBy10(&$val, $key) {
$val -= $val * 0.1;
}

$data = array(10,20,30,40);
array_walk($data, 'reduceBy10');
print_r($data);
?>

Output:
Array
(
[0] => 9
[1] => 18
[2] => 27
[3] => 36
)
Posted by at No comments:

9 Useful PHP Functions and Features You Need to Know

Even after using PHP for years, we stumble upon functions and features that we did not know about. Some of these can be quite useful, yet underused. With that in mind, I’ve compiled a list of nine incredibly useful PHP functions and features that you should be familiar with.

1. Functions with Arbitrary Number of Arguments

You may already know that PHP allows you to define functions with optional arguments. But there is also a method for allowing completely arbitrary number of function arguments.
First, here is an example with just optional arguments:
view plaincopy to clipboardprint?
  1. // function with 2 optional arguments  
  2. function foo($arg1 = '', $arg2 = '') {  
  3.   
  4.     echo "arg1: $arg1\n";  
  5.     echo "arg2: $arg2\n";  
  6.   
  7. }  
  8. foo('hello','world');  
  9. /* prints: 
  10. arg1: hello 
  11. arg2: world 
  12. */  
  13.   
  14. foo();  
  15. /* prints: 
  16. arg1: 
  17. arg2: 
  18. */  
Now, let’s see how we can build a function that accepts any number of arguments. This time we are going to utilize func_get_args():
view plaincopy to clipboardprint?
  1. // yes, the argument list can be empty  
  2. function foo() {  
  3.   
  4.     // returns an array of all passed arguments  
  5.     $args = func_get_args();  
  6.   
  7.     foreach ($args as $k => $v) {  
  8.         echo "arg".($k+1).": $v\n";  
  9.     }  
  10.   
  11. }  
  12.   
  13. foo();  
  14. /* prints nothing */  
  15.   
  16. foo('hello');  
  17. /* prints 
  18. arg1: hello 
  19. */  
  20.   
  21. foo('hello', 'world', 'again');  
  22. /* prints 
  23. arg1: hello 
  24. arg2: world 
  25. arg3: again 
  26. */  

2. Using Glob() to Find Files

Many PHP functions have long and descriptive names. However it may be hard to tell what a function named glob() does unless you are already familiar with that term from elsewhere.
Think of it like a more capable version of the scandir() function. It can let you search for files by using patterns.
view plaincopy to clipboardprint?
  1. // get all php files  
  2. $files = glob('*.php');  
  3.   
  4. print_r($files);  
  5. /* output looks like: 
  6. Array 
  7. ( 
  8.     [0] => phptest.php 
  9.     [1] => pi.php 
  10.     [2] => post_output.php 
  11.     [3] => test.php 
  12. ) 
  13. */  
You can fetch multiple file types like this:
view plaincopy to clipboardprint?
  1. // get all php files AND txt files  
  2. $files = glob('*.{php,txt}', GLOB_BRACE);  
  3.   
  4. print_r($files);  
  5. /* output looks like: 
  6. Array 
  7. ( 
  8.     [0] => phptest.php 
  9.     [1] => pi.php 
  10.     [2] => post_output.php 
  11.     [3] => test.php 
  12.     [4] => log.txt 
  13.     [5] => test.txt 
  14. ) 
  15. */  
Note that the files can actually be returned with a path, depending on your query:
view plaincopy to clipboardprint?
  1. $files = glob('../images/a*.jpg');  
  2.   
  3. print_r($files);  
  4. /* output looks like: 
  5. Array 
  6. ( 
  7.     [0] => ../images/apple.jpg 
  8.     [1] => ../images/art.jpg 
  9. ) 
  10. */  
If you want to get the full path to each file, you can just call the realpath() function on the returned values:
view plaincopy to clipboardprint?
  1. $files = glob('../images/a*.jpg');  
  2.   
  3. // applies the function to each array element  
  4. $files = array_map('realpath',$files);  
  5.   
  6. print_r($files);  
  7. /* output looks like: 
  8. Array 
  9. ( 
  10.     [0] => C:\wamp\www\images\apple.jpg 
  11.     [1] => C:\wamp\www\images\art.jpg 
  12. ) 
  13. */  

3. Memory Usage Information

By observing the memory usage of your scripts, you may be able optimize your code better.
PHP has a garbage collector and a pretty complex memory manager. The amount of memory being used by your script. can go up and down during the execution of a script. To get the current memory usage, we can use the memory_get_usage() function, and to get the highest amount of memory used at any point, we can use the memory_get_peak_usage() function.
view plaincopy to clipboardprint?
  1. echo "Initial: ".memory_get_usage()." bytes \n";  
  2. /* prints 
  3. Initial: 361400 bytes 
  4. */  
  5.   
  6. // let's use up some memory  
  7. for ($i = 0; $i < 100000; $i++) {  
  8.     $array []= md5($i);  
  9. }  
  10.   
  11. // let's remove half of the array  
  12. for ($i = 0; $i < 100000; $i++) {  
  13.     unset($array[$i]);  
  14. }  
  15.   
  16. echo "Final: ".memory_get_usage()." bytes \n";  
  17. /* prints 
  18. Final: 885912 bytes 
  19. */  
  20.   
  21. echo "Peak: ".memory_get_peak_usage()." bytes \n";  
  22. /* prints 
  23. Peak: 13687072 bytes 
  24. */  

4. CPU Usage Information

For this, we are going to utilize the getrusage() function. Keep in mind that this is not available on Windows platforms.
view plaincopy to clipboardprint?
  1. print_r(getrusage());  
  2. /* prints 
  3. Array 
  4. ( 
  5.     [ru_oublock] => 0 
  6.     [ru_inblock] => 0 
  7.     [ru_msgsnd] => 2 
  8.     [ru_msgrcv] => 3 
  9.     [ru_maxrss] => 12692 
  10.     [ru_ixrss] => 764 
  11.     [ru_idrss] => 3864 
  12.     [ru_minflt] => 94 
  13.     [ru_majflt] => 0 
  14.     [ru_nsignals] => 1 
  15.     [ru_nvcsw] => 67 
  16.     [ru_nivcsw] => 4 
  17.     [ru_nswap] => 0 
  18.     [ru_utime.tv_usec] => 0 
  19.     [ru_utime.tv_sec] => 0 
  20.     [ru_stime.tv_usec] => 6269 
  21.     [ru_stime.tv_sec] => 0 
  22. ) 
  23.  
  24. */  
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:
view plaincopy to clipboardprint?
  1. // sleep for 3 seconds (non-busy)  
  2. sleep(3);  
  3.   
  4. $data = getrusage();  
  5. echo "User time: ".  
  6.     ($data['ru_utime.tv_sec'] +  
  7.     $data['ru_utime.tv_usec'] / 1000000);  
  8. echo "System time: ".  
  9.     ($data['ru_stime.tv_sec'] +  
  10.     $data['ru_stime.tv_usec'] / 1000000);  
  11.   
  12. /* prints 
  13. User time: 0.011552 
  14. System time: 0 
  15. */  
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:
view plaincopy to clipboardprint?
  1. // loop 10 million times (busy)  
  2. for($i=0;$i<10000000;$i++) {  
  3.   
  4. }  
  5.   
  6. $data = getrusage();  
  7. echo "User time: ".  
  8.     ($data['ru_utime.tv_sec'] +  
  9.     $data['ru_utime.tv_usec'] / 1000000);  
  10. echo "System time: ".  
  11.     ($data['ru_stime.tv_sec'] +  
  12.     $data['ru_stime.tv_usec'] / 1000000);  
  13.   
  14. /* prints 
  15. User time: 1.424592 
  16. System time: 0.004204 
  17. */  
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:
view plaincopy to clipboardprint?
  1. $start = microtime(true);  
  2. // keep calling microtime for about 3 seconds  
  3. while(microtime(true) - $start < 3) {  
  4.   
  5. }  
  6.   
  7. $data = getrusage();  
  8. echo "User time: ".  
  9.     ($data['ru_utime.tv_sec'] +  
  10.     $data['ru_utime.tv_usec'] / 1000000);  
  11. echo "System time: ".  
  12.     ($data['ru_stime.tv_sec'] +  
  13.     $data['ru_stime.tv_usec'] / 1000000);  
  14.   
  15. /* prints 
  16. User time: 1.088171 
  17. System time: 1.675315 
  18. */  
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.

5. Magic Constants

PHP provides useful magic constants for fetching the current line number (__LINE__), file path (__FILE__), directory path (__DIR__), function name (__FUNCTION__), class name (__CLASS__), method name (__METHOD__) and namespace (__NAMESPACE__).
We are not going to cover each one of these in this article, but I will show you a few use cases.
When including other scripts, it is a good idea to utilize the __FILE__ constant (or also __DIR__ , as of PHP 5.3):
view plaincopy to clipboardprint?
  1. // this is relative to the loaded script's path  
  2. // it may cause problems when running scripts from different directories  
  3. require_once('config/database.php'); 
  4.  
  5. // this is always relative to this file's path  
  6. // no matter where it was included from  
  7. require_once(dirname(__FILE__) . '/config/database.php');  
Using __LINE__ makes debugging easier. You can track down the line numbers:
view plaincopy to clipboardprint?
  1. // some code  
  2. // ...  
  3. my_debug("some debug message", __LINE__);  
  4. /* prints 
  5. Line 4: some debug message 
  6. */  
  7.   
  8. // some more code  
  9. // ...  
  10. my_debug("another debug message", __LINE__);  
  11. /* prints 
  12. Line 11: another debug message 
  13. */  
  14.   
  15. function my_debug($msg, $line) {  
  16.     echo "Line $line: $msg\n";  
  17. }  

6. Generating Unique ID's

There may be situations where you need to generate a unique string. I have seen many people use the md5() function for this, even though it's not exactly meant for this purpose:
view plaincopy to clipboardprint?
  1. // generate unique string  
  2. echo md5(time() . mt_rand(1,1000000));  
There is actually a PHP function named uniqid() that is meant to be used for this.
view plaincopy to clipboardprint?
  1. // generate unique string  
  2. echo uniqid();  
  3. /* prints 
  4. 4bd67c947233e 
  5. */  
  6.   
  7. // generate another unique string  
  8. echo uniqid();  
  9. /* prints 
  10. 4bd67c9472340 
  11. */  
You may notice that even though the strings are unique, they seem similar for the first several characters. This is because the generated string is related to the server time. This actually has a nice side effect, as every new generated id comes later in alphabetical order, so they can be sorted.
To reduce the chances of getting a duplicate, you can pass a prefix, or the second parameter to increase entropy:
view plaincopy to clipboardprint?
  1. // with prefix  
  2. echo uniqid('foo_');  
  3. /* prints 
  4. foo_4bd67d6cd8b8f 
  5. */  
  6.   
  7. // with more entropy  
  8. echo uniqid('',true);  
  9. /* prints 
  10. 4bd67d6cd8b926.12135106 
  11. */  
  12.   
  13. // both  
  14. echo uniqid('bar_',true);  
  15. /* prints 
  16. bar_4bd67da367b650.43684647 
  17. */  
This function will generate shorter strings than md5(), which will also save you some space.

7. Serialization

Have you ever needed to store a complex variable in a database or a text file? You do not have to come up with a fancy solution to convert your arrays or objects into formatted strings, as PHP already has functions for this purpose.
There are two popular methods of serializing variables. Here is an example that uses the serialize() and unserialize():
view plaincopy to clipboardprint?
  1. // a complex array  
  2. $myvar = array(  
  3.     'hello',  
  4.     42,  
  5.     array(1,'two'),  
  6.     'apple'  
  7. );  
  8.   
  9. // convert to a string  
  10. $string = serialize($myvar);  
  11.   
  12. echo $string;  
  13. /* prints 
  14. a:4:{i:0;s:5:"hello";i:1;i:42;i:2;a:2:{i:0;i:1;i:1;s:3:"two";}i:3;s:5:"apple";} 
  15. */  
  16.   
  17. // you can reproduce the original variable  
  18. $newvar = unserialize($string);  
  19.   
  20. print_r($newvar);  
  21. /* prints 
  22. Array 
  23. ( 
  24.     [0] => hello 
  25.     [1] => 42 
  26.     [2] => Array 
  27.         ( 
  28.             [0] => 1 
  29.             [1] => two 
  30.         ) 
  31.  
  32.     [3] => apple 
  33. ) 
  34. */  
This was the native PHP serialization method. However, since JSON has become so popular in recent years, they decided to add support for it in PHP 5.2. Now you can use the json_encode() and json_decode() functions as well:
view plaincopy to clipboardprint?
  1. // a complex array  
  2. $myvar = array(  
  3.     'hello',  
  4.     42,  
  5.     array(1,'two'),  
  6.     'apple'  
  7. );  
  8.   
  9. // convert to a string  
  10. $string = json_encode($myvar);  
  11.   
  12. echo $string;  
  13. /* prints 
  14. ["hello",42,[1,"two"],"apple"] 
  15. */  
  16.   
  17. // you can reproduce the original variable  
  18. $newvar = json_decode($string);  
  19.   
  20. print_r($newvar);  
  21. /* prints 
  22. Array 
  23. ( 
  24.     [0] => hello 
  25.     [1] => 42 
  26.     [2] => Array 
  27.         ( 
  28.             [0] => 1 
  29.             [1] => two 
  30.         ) 
  31.  
  32.     [3] => apple 
  33. ) 
  34. */  
It is more compact, and best of all, compatible with javascript and many other languages. However, for complex objects, some information may be lost.

8. Compressing Strings

When talking about compression, we usually think about files, such as ZIP archives. It is possible to compress long strings in PHP, without involving any archive files.
In the following example we are going to utilize the gzcompress() and gzuncompress() functions:
view plaincopy to clipboardprint?
  1. $string =  
  2. "Lorem ipsum dolor sit amet, consectetur 
  3. adipiscing elit. Nunc ut elit id mi ultricies 
  4. adipiscing. Nulla facilisi. Praesent pulvinar, 
  5. sapien vel feugiat vestibulum, nulla dui pretium orci, 
  6. non ultricies elit lacus quis ante. Lorem ipsum dolor 
  7. sit amet, consectetur adipiscing elit. Aliquam 
  8. pretium ullamcorper urna quis iaculis. Etiam ac massa 
  9. sed turpis tempor luctus. Curabitur sed nibh eu elit 
  10. mollis congue. Praesent ipsum diam, consectetur vitae 
  11. ornare a, aliquam a nunc. In id magna pellentesque 
  12. tellus posuere adipiscing. Sed non mi metus, at lacinia 
  13. augue. Sed magna nisi, ornare in mollis in, mollis 
  14. sed nunc. Etiam at justo in leo congue mollis. 
  15. Nullam in neque eget metus hendrerit scelerisque 
  16. eu non enim. Ut malesuada lacus eu nulla bibendum 
  17. id euismod urna sodales. ";  
  18.   
  19. $compressed = gzcompress($string);  
  20.   
  21. echo "Original size: ". strlen($string)."\n";  
  22. /* prints 
  23. Original size: 800 
  24. */  
  25. echo "Compressed size: ". strlen($compressed)."\n";  
  26. /* prints 
  27. Compressed size: 418 
  28. */  
  29.   
  30. // getting it back  
  31. $original = gzuncompress($compressed);  
We were able to achive almost 50% size reduction. Also the functions gzencode() and gzdecode() achive similar results, by using a different compression algorithm.

9. Register Shutdown Function

There is a function called register_shutdown_function(), which will let you execute some code right before the script finishes running.
Imagine that you want to capture some benchmark statistics at the end of your script execution, such as how long it took to run:
view plaincopy to clipboardprint?
  1. // capture the start time  
  2. $start_time = microtime(true);  
  3.   
  4. // do some stuff  
  5. // ...  
  6.   
  7. // display how long the script took  
  8. echo "execution took: ".  
  9.         (microtime(true) - $start_time).  
  10.         " seconds.";  
At first this may seem trivial. You just add the code to the very bottom of the script and it runs before it finishes. However, if you ever call the exit() function, that code will never run. Also, if there is a fatal error, or if the script is terminated by the user (by pressing the Stop button in the browser), again it may not run.
When you use register_shutdown_function(), your code will execute no matter why the script has stopped running:
view plaincopy to clipboardprint?
  1. $start_time = microtime(true);  
  2.   
  3. register_shutdown_function('my_shutdown');  
  4.   
  5. // do some stuff  
  6. // ...  
  7. function my_shutdown() {  
  8.     global $start_time;  
  9.   
  10.     echo "execution took: ".  
  11.             (microtime(true) - $start_time).  
  12.             " seconds.";  
  13. }  

Conclusion

Are you aware of any other PHP features that are not widely known but can be quite useful? Please share with us in the comments. And thank you for reading!
Posted by at 1 comment:

20 Handy PHP String Functions

PHP is the widely used open source language especially for developing web applications. Strings in PHP play very important role. In this tutorial, You will find about 20 handy and most used PHP functions.

1. addcslashes()

This string function returns a string also with backslashes before characters and characters are listed as parameter.
Syntax:
1

<?php addcslashes($str, characters); ?>
Example:
1
2
3
4

<?php
$mystr = "How are you.";
echo addcslashes($mystr, 'r');
?>
Output:
1

How a\re you.

2. convert_uudecode()

This string function decodes a string that is uuencoded (in simple words it decodes a string which is encrypted by some security methods).
Syntax:
1
2
3

<?php
convert_uudecode($encrypted_string);
?>
Example:
1
2
3
4
5

<?php
$encrypted_string = "+2&]W($%R92!9;W4` `";

echo convert_uudecode($encrypted_string);
?>
Output:
1

How Are You

3. convert_uuencode()

This string function encodes a string.
Syntax:
1
2
3

<?php
convert_uuencode($encrypted_string);
?>
Example:
1
2
3
4
5

<?php
$encrypted_string = "How Are You";

echo convert_uuencode($encrypted_string);
?>
Output:
1

+2&]W($%R92!9;W4` `

4. count_chars()

This string function returns how many times a character (ASCII) appears in a string depending on the modes we specified.
By default, mode is 0 that returns an array with Key (ASCII Value) and Value (Number of Occurrences.
Mode 1 returns an array with same functionality as Mode 2, but it only lists appearance of characters which are greater than zero.
Mode 2 returns occurrence which are equal to zero.
Mode 3 returns string with difference characters used.
Mode 4 generates string of all unused characters.
Syntax:
1

count_chars($str, mode);
Example:
1
2
3
4
5
6
7
8
9
10
11

<?php
$mystr = "Hello Dear, How are you";

print_r(count_chars($mystr, 0));
print_r(count_chars($mystr, 1));
print_r(count_chars($mystr, 2));

echo count_chars($mystr, 3);
echo count_chars($mystr, 4);

?>

5. echo()

This function helps to output more than one strings. Parameters in this function are optional.
Syntax:
1

echo(string)

6. explode()

explode() explodes or break a string into an array. We can easily understand the functionality of this function by the name “explode”. explode() has three parameters, first 2 are required and third is optional.
Syntax:
1

explode(string_separator, $str, limit);
Example:
1
2
3
4
5
6
7

<?php

$mystr = "Hello Dear, How are you";

print_r(explode(" ", $mystr));

?>
Output:
1

Array ( [0] => Hello [1] => Dear, [2] => How [3] => are [4] => you )

7. implode()

implode() is a reverse of explode(), means it joins an array into a sring. It has two parameters, first one is optional and second one is required.
Syntax:
1

imlode(string_separator, array);
Example:
1
2
3
4
5
6
7

<?php

$arr = array("Hello", "Dear", "How", "Are", "You");

echo implode(" ", $arr);

?>
Output:
1

Hello Dear How Are You

8. md5()

md5() function calculates Message-Digest Algorithm (md5) hash of a string. It has two parameters, first one is required and second one is optional which was included in PHP 5.0.
Syntax:
1

md5($str, raw);
Example:
1
2
3
4
5
6
7

<?php

$mystr = "How Are You";

echo md5($mystr);

?>
Output:
1

9e227bb366c119c7f27a7115f0136f42

9. str_replace()

If you want to replace some specified characters with other characters in PHP, str_replace() is the best choice. It has many rules like:
  1. If we want to search a string in an array, it returns as an array.
  2. Find and Replace is performed with each array element as we want to search a string in an array.
  3. If we are finding an array and also replacing with it with an array, an empty string will be used as replace.
  4. In case, replace is a string and find is an array, then it uses replace sting as find value.
Syntax:
1

str_replace(find, replace, string, count);
Example:
1
2
3

<?php
echo str_replace("How", "Dear", "How Di");
?>
Output:
1

How Dear

10. str_split()

str_split() works like explode() in some manner, it is used for splitting a string into an array.
Syntax:
1

str_split($mystring, length);
Example:
1
2
3

<?php
print_r(str_split("What"));
?>
Output:
1
2
3
4
5
6
7

Array
(
[0] => W
[1] => h
[2] => a
[3] => T
)

11. str_word_count()

This function is used for counting the words in a string.
Syntax:
1

str_word_count(string, return, char);
Example:
1
2
3

<?php
echo str_word_count("What are you doing");
?>
Output:
1

4

12. strcmp()

This case-sensitive string function is used for comparing two strings. It returns “0″ if both strings are equal, “<0″ if first string is less than second string and “>0″ if first string is greater than second string.
Syntax:
1

strcmp(first string, second string);
Example:
1
2
3

<?php
echo strcmp("What Are You Doing", "What I Should Do");
?>
Output:
1

-1

13. strlen()

strlen() calculates the length of string based on extra spaces and characters used in a string.
Syntax:
1

strlen($str);
Example:
1
2
3

<?php
echo strlen("Oh, No!");
?>
Output:
1

7

14. strrpos()

strrpos() is used to find the position of the last occurrence string inside another string.
Syntax:
1

strrpos(strong, find, start)
Example:
1
2
3
4
5
6
7
8

<?php
echo strrpos("Where are you going?", "go");
?>
[code]

<strong>Output:</strong>

[code type="php"]14

15. strstr()

strstr() finds the first occurrence of a string in a string, if found it returns at the matching point else it returns 0.
Syntax:
1

strstr();
Example:
1
2
3

<?php
echo strstr('Hi What', 'Hi');
?>
Output:
1

Hi What

16. strtolower()

This function converts a string to lowercase (It converts only letters from A-Z or a-z).
Syntax:
1

strtolower($str);
Example:
1
2
3

<?php
echo strtolower("Now WhaT are");
?>
Output:
1

now what are

17. strtoupper()

This function converts a string to uppercase letters.
Syntax:
1

strtoupper($str)
Example:
1
2
3

<?php
echo strtoupper("Yes");
?>
Output:
1

YES

18. substr()

This function split up a part from a string according to given criteria specified in the parameters.
Syntax:
1

substr($str, start, length)
Example:
1
2
3

<?php
echo substr("Where I Can Find You", 7);
?>
Output:
1

Can Find You

19. trim()

This function erases predefined characters and whitespaces from every side of a string. Predefined characters are like: \0, \t, \n, \xob, \r etc.
Syntax:
1

trim($str, chars)
Example:
1
2
3
4

<?php
$mystr = "Hey dude, I'm going with you";
echo trim($mystr);
?>

20. wordwrap()

If you want to cut a string after it reaches to a specific length, wordwrap() is the best choice for achieving this.
Syntax:
1

wordwrap($str, width, break, cut)
Example:
1
2
3
4
5
6

<?php

$str = "Check the example: Supercalifragulistic";

echo wordwrap($str,9);
?>
Output:
Browser will display out like this
1

Check the example: Supercalifragulistic
But after checking the page source, output will be something like below:
1
2
3

Check the
example:
Supercalifragulistic
Posted by at No comments:
Subscribe to: Posts (Atom)