# Computer Algorithms: Quicksort

## Introduction

When it comes to sorting items by comparing them merge sort is one very natural approach. It is natural, because simply divides the list into two equal sub-lists then sort these two partitions applying the same rule. That is a typical divide and conquer algorithm and it just follows the intuitive approach of speeding up the sorting process by reducing the number of comparisons. However there are other “divide and conquer” sorting algorithms that do not follow the merge sort scheme, while they have practically the same success. Such an algorithm is quicksort.

## Overview

Back in 1960 C. A. R. Hoare comes with a brilliant sorting algorithm. In general quicksort consists of some very simple steps. First we’ve to choose an element from the list (called a pivot) then we must put all the elements with value less than the pivot on the left side of the pivot and all the items with value greater than the pivot on its right side. After that we must repeat these steps for the left and the right sub-lists. That is quicksort! Simple and elegant!

# PHP: Fetch \$_GET as String with http_build_query()

PHP is really full of functions for everything! Most of the time when you try to do something with strings, there’s a function that can do it better and faster.

## The Route from \$_GET to String

The global arrays in PHP contain request parameters. Either GET or POST. As you know if the page address is something like:

`http://www.example.com/index.php?a=b&key=value`

This means that you pass to the index.php file two parameters – “a” and “key” with their values: “b” and “value”. Now in this case you can dump the \$_GET global array somewhere in index.php and you’ll receive something like this.

```array( "a" => "b", "key" => "value", );```

This is however pseudocode, but in fact \$_GET will be very similar to this sample array. Continue reading PHP: Fetch \$_GET as String with http_build_query()

# PHP Strings: How to Get the Extension of a File

## EXE or GIF or DLL or …

Most of the code chunks I’ve seen about getting a file extension from a string are based on some sort of string manipulation.

```\$filename = '/my/path/image.jpeg'; echo substr(\$filename, strrpos(\$filename, '.') + 1);```

Howerver there is a more elegant solution.

```\$filename = '/my/path/image.jpeg'; echo strtolower(pathinfo(\$filename, PATHINFO_EXTENSION));```

Thus you rely on PHP built in functions and it’s harder to overlook the exact string manipulation approach.

# Returning JSON in a Zend Controller’s Action – Part 2

In a reply from my latest post after following the comments, there is a much elegant solution to this use case. Simply by changing the output with a JSON helper. This also changes the content-type of the returned response.

```\$data = array(...); \$this->_helper->json(\$data);```

# Zend Examples: GET Parameters Default Value

## PHP Style

As you may know in PHP you can access everything in the request uri by accessing the global \$_GET array. If there is something like that in the browser’s address field: www.example.com/index.php?controller=index&action=test, you can simply get the values by that:

```echo \$_GET['controller']; // this will print "index" echo \$_GET['action']; // this will print "test"```

## Zend Framework, Uri & Request Params

If you code with Zend Framework, you should know already, and that’s perhaps the first thing you’ve learned about Zend, that \$_GET params can be accessed by calling the requrest’s getParam() method. But first of all the request uri will be different. The Zend’s convetion is to place after the domain name first the module name (which is omited when there’s only one module), than the controller’s name followed by the action and the key value pairs of all parameters. In that scheme the request uri above will look like that:

`http://www.example.com/index/test`

Here the keywords “controller” and “action” are omitted. This is cool – it’s more user friendly and it definitely helps the SEO.

## Get the \$_GET

Once the uri is setup like so – /index/test you can access it via the Zend way:

`echo \$this->getRequest()->getParam('controller'); // this will print "index"`

The cool thing is that in the first case you don’t have any prevention of a missing value, while in the second case there is a second parameter or the getParam() method that does this job. What if the uri is www.example.com/index.php?controller=&action=test than by printing the \$_GET[‘controller’] you’ll get nothing. In other hand even this:

`echo \$this->getRequest()->getParam('action');`

won’t return “test” if the uri is http://www.example.com/index/

Note: actually here the default “index” action will be referenced!

That’s where the power of the framework comes. In the first case the solution is:

`echo (empty(\$_GET['controller']) ? 'default': \$_GET['controller']);`

while in Zend there’s more elegant solution:

`echo \$this->getRequest()->getParam('action', 'test');`

Thus when the action param is missing the “test” value is considered as default! Very useful!