Consider an array `foo` with multiple values, and consider the problem of deleting an element from the array, given just the value. Let the variable `$delValue` hold the value to be  found and deleted.

Using `array_search` and `unset`

$key = array_search($delValue, $foo);
if($key !== false)
unset($foo[$key]);

The strict operator `!==` is required because the `array_search` function returns the key of the value in the array, if present. Since the key can be 0 and 0 evaluates to false in PHP, a strict comparison is required.
The method doesn’t work for multiple entries of the value, but with a slight modification, it can be made to :

while($key = array_search($delValue, $foo) !== false){
    unset($foo[$key])
}

Using `array_diff`

This method only works for arrays whose members can be converted to strings.

$foo = array_diff($foo, [$delValue]);

`delValue` is cast into an array, and `array_diff` returns only the values of `foo` that will not be found in `[$delValue]`. Thus, all instances of `delValue` are deleted. This is a concise, powerful way that successfully deletes multiple entries of `delValue`.

Using `array_keys`

This is similar to the first method, but multiple entries can be successfully deleted.

foreach(array_keys($foo, $delValue, true) as $key){
unset($foo[$key]);
}

The argument `$delValue` tells the function `array_keys` to return keys only for the values *equal to* `delValue`, and the third argument `true` signifies that strict comparison (`===`) be used for checking the values.

Using Anonymous Functions with `array_filter`

A neat method that only works for versions of PHP >= 5.3.0.

$foo = array_filter($foo, function($value) use ($delValue) {
    return ($value !== $delValue);
});

The anonymous function returns a boolean value, which determines whether an element should pass through the filter or not. All values of the array `foo` *strictly not equal to* `delValue` pass through and become a part of the new array. Worth noting that multiple instances of `delValue` are deleted.

Using `array_flip`

The function flips keys and values of the array passed as an argument. In the case of multiple values, only the latest key is used; the rest are discarded. Also, it’s necessary that the values be either integers or strings or be convertible as such.

$flippedFoo = array_flip($foo);
unset($foo[$delValue]);

$foo = array_flip($flippedFoo);

Multiple values are deleted as a side-effect of the `array_flip` call, although some data loss can possibly occur.

Using comparisons and loops

foreach($foo as $key => $value){
    if($value == $delValue){ // === for strict comparison may be used
    unset($foo[$key]);
    }
}

Since each element is looped over, multiple values if present are all deleted.

Using `array_splice`

The function array_splice can also be used to delete values from an array.

$key = array_search($delValue, $foo);
array_splice($foo, $key, 1);

The method only deletes one instance of the value from the array. In the case of associative arrays or arrays in which keys have gaps, the method fails.

References

1. array_search
2. unset
3. array_diff
4. array_keys
5. array_flip
6. array_filter
7. Anonymous Functions
8. array_splice

Let’s assume a PHP variable `$foo` on `page1.php`. There is a form on this page which posts on `page2.php`. Since HTTP is stateless, webpages are disconnected and this implies that `page2.php` won’t be aware of the existence of `page1.php` or any data thereof. However, `page2.php` can still access the variables from the `page1.php` script using the methods discussed here.

Sessions

Sessions store data on the server for access between php scripts on different web-pages.

// Page 1
session_start();
$_SESSION['foo'] = $foo;

// Page 2
session_start();
$foo = $_SESSION['foo'];

It’s important to note that the `session_start` line must be used prior to using the `$_SESSION` superglobal.

Cookies

Cookies differ from sessions in that they store the data on the client, instead of the server, and therfore are relatively un-safe.

// Page 1
setcookie('foo', $foo);

// Page 2
$foo = $_COOKIE['foo'];

Cookies maybe preferred over sessions in situations where data needs to persist. However, it’s possible to avoid cookies by storing the data in a database and retrieving it using an id or username.

GET and POST

The variable can either be added as a *GET* parameter in the link to Page 2 :

<a href=”page2.php?foo=<?php echo urlencode($foo);?>”>Go to Page 2</a>

Or, a hidden field can be created in a form that posts to Page 2 :

<form method="post" action="page2.php">
<input type="hidden" name="foo" value=<?php echo $foo;?>>
<input type="submit"
</form>

Then, on Page 2 the variables can be retrieved as :

// GET method
$foo = $_GET['foo'];

// POST method
$foo = $_POST['foo'];

// GET, POST or COOKIE
$foo = $_REQUEST['foo'];

Both methods, GET and POST, are insecure because it’s possible to tamper with this data before sending it to the server.

References

1. session_start
2. .$_SESSION
3. setcookie
4. $_COOKIE
5. $_GET
6. HTML Forms

It’s hard to ignore the importance of a good IDE when it comes to programming. A good choice can greatly enhance the productivity of any programmer. Remember the choice of an IDE is quite subjective and that there’s no such thing as the perfect choice. Also every one of these tools has a learning curve.

Here, we take a look at the various development options for PHP. There’s a lot for the community out there beyond gedit and Notepad.

jEdit

While not an IDE, jEdit ‘the mature programmer’s editor’ can be a great choice, given the range of features it provides. It’s open-source, and surprisingly light-weight compared to mainstream editors like Eclipse or Netbeans.
A number of plugins are available to enhance jEdit’s functionality. It provides syntax highlighting for more than 200 languages, according to it’s website. One can interact with the shell from inside the editor itself.

JetBrains PhpStorm

PhpStorm is a popular choice among PHP programmers. The tool features smart code completion and analysis, which has won great reviews. It also packs in a handy HTML/CSS/JavaScript editor, and integrates well with the popular revision control systems. A major turn-off is that it doesn’t come for free.

NetBeans

A traditional favourite among programmers, NetBeans provides robust support for PHP as well. It supports the popular web frameworks Zend and Symfony, integrates with SVN, CVS, git and the PHP editor is dynamically integrated with it’s friends HTML/CSS/JavaScript. It also offers a neat debugger for PHP, Xdebug.

phpDesigner

An IDE that some would swear by, phpDesigner offers built-in support for SQL, Perl, Python and more. Code completion, hinting, beautification, single-click comments, statement templates, php heredoc support, support for php 4 are some of its enticing features. Debugging becomes a whole lot easier with Xdebug. It’s only available for Windows though and is not free, although it offers a trial version.

Eclipse PDT

Eclipse fans can transition to PHP by using PDT, downloadable from inside Eclipse itself. Apart from all the cool generic features of Eclipse, it offers Xdebug and Zend Debugger support for debugging.

ActiveState Komodo

Komodo is a mature proprietary product aimed at the PHP audience. It impresses with it’s HTTP inspector, JavaScript debugger and Regular Expression Toolkit. It’s possible to view not just PHP, but running JavaScript and HTTP traffic as well through Komodo. Komodo also comes in free (Komodo Edit) and open (OpenKomodo) flavors.

Aptana

Once past the learning phase, Aptana aptly rewards programmers with it’s pace. It integrates very well with Subversion, plugin installation is smooth and file search is amazingly quick.

Geany

Geany is a small, lightweight and cute editor with many IDE-ish features. It supports standard features like code folding, syntax highlighting, code navigation, closing of html tags and the like.

Zend Studio

Zend competes with the other IDEs in that it too offers syntax highlighting, code

completion and the like. Where it wins is in offering debug support live on a web server while browsing, in addition to, with a standalone PHP interpreter.

Delphi for PHP

Delphi for PHP (now RadPHP 3.0) has won praise from the community for its smooth interfacing. It offers a designer, support for frameworks such as Zend, drag and drop utility and a neat GUI editor.