Regular expressions are a powerful tool for finding, examining and/or modifying text. Regular expressions themselves are, with a general pattern notation almost like a mini programming language, allowing you to define and parse text. They enable you to search for patterns within a string, extracting matches flexible and precise. However, you should note that because regular expressions are more powerful, they also suffer from added overhead and are slower than the more basic string functions. You should make careful consideration and only use regular expressions if you have a particular need.

PHP supports two different types of regular expressions: POSIX-extended and Perl-Compatible Regular Expressions (PCRE). The PCRE functions are more commonly used, are more powerful than the POSIX ones and faster as well

In a regular expression, most characters match only themselves. For instance, if you search for the regular expression “foo” in the string “only a fool does not use regular expressions” you get a match because “foo” occurs in that string. Some characters have a special meaning. For instance, the dollar sign ($) is used to match strings that end with the given pattern. Similarly, a caret (^) character at the beginning of a regular expression indicates that it must match the beginning of the string. Characters that match themselves are called literals while characters that have special meanings are called metacharacters.

The dot (.) metacharacter matches any single character except newline (\). Hence, the pattern h.t matches hat, hothit, hut and h7t. The vertical pipe (|) metacharacter is used for alternatives in a regular expression. It behaves much like a logical OR operator and you should use it if you want to construct a pattern that matches more than one set of characters. For instance, the pattern Monday|Tuesday|Wednesday matches strings that contain “Monday” or “Tuesday” or “Wednesday”. Parentheses are used to group sequences. For example, (fri|satur)day matches “friday” or “saturday”. Using parentheses to group characters for alternation is called grouping.

If we want to match a literal metacharacter in a pattern, we have to escape it with a backslash.

To specify a set of acceptable characters in a pattern, we can either build a character class ourself, or use a predefined one. A character class lets us represent a bunch of characters as a single item. We can build our own character class by enclosing the acceptable characters in square brackets. A character class matches any one of the characters in the class. For example a character class [abc] matches a, b or c. To define a range of characters, we just add the first and last characters separated by hyphen. For example, to match all alphanumeric characters: [a-zA-Z0-9]. We can also create a negated character class, which matches any character that is not in the class. To create a negated character class, we start the character class with ^: [^0-9].

Metacharacters +, *, ?, and {} affect the number of times a pattern should be matched. + means “Match one or more of the preceding expression”, * means “Match zero or more of the preceding expression”, and ? means “Match zero or one of the preceding expression”. Curly braces {} are be used differently. With a single integer, {n} means “match exactly n occurrences of the preceding expression”, with one integer and a comma, {n,} means “match n or more occurrences of the preceding expression”, and with two comma-separated integers {n,m} means “match the previous character if it occurs at least n times, but no more than m times”.

I recently installed the memcached daemon on my MacBook Pro, incuding the necessary PHP client for development purposes. I just prefer to work locally instead of using a VM running Linux. And the process is actually quite simple and straight forward. Please note, I have included both clients, the old standard one and the newer PECL extension, because I deal with different applications and also lots of people seems to get confused when they install one version and their memcache classes cannot get instantiated and throw errors. So, if in doubt, just install both.

These are the five (four if you know which extension you want) components needed:

- libevent (requred library for memcached)

- memcached daemon

- libmemcached (required library for the php client)

- php extension (standard)

- php extension (PECL)

Now open your terminal and off we go:

Note: if you don’t want to install wget, you can alternatively use “curl -O”)

Installing libevent:

$ cd /tmp
$ wget http://www.monkey.org/~provos/libevent-1.4.13-stable.tar.gz (if you’re brave, you can try the 2.0 beta)
$ tar zxvf libevent-1.4.13-stable.tar.gz
$ ./configure
$ make
$ sudo make install

Installing memcached:

$ wget http://memcached.googlecode.com/files/memcached-1.4.1.tar.gz
$ tar xzvf memcached-1.4.1.tar.gz
$ cd memcached-1.4.1
$ ./configure
$ make
$ make test
$ sudo make install
$ memcached -d -P pidfile -l 127.0.0.1 (this will start the memcached daemon)
$ ps aux | grep ‘memcached’ (this should confirm that memcached is running and how much memory is assigned to it)

Installing libmemcached:

$ wget http://launchpad.net/libmemcached/1.0/0.34/+download/libmemcached-0.34.tar.gz
$ tar -zxvf libmemcached-0.34.tar.gz
$ cd libmemcached-0.34
$ ./configure
$ make
$ sudo make install

Installing PECL memcache extension:

$ cd /tmp
$ pecl download memcached
$ tar xzvf memcached-1.0.0.tgz
$ cd memcached-1.0.0
$ phpize
$ ./configure
$ make
$ sudo make install

Installing PHP memcache extension:

$ cd /tmp
$ wget http://pecl.php.net/get/memcache-2.2.4.tgz
$ tar -zxvf memcache-2.2.4.tgz
$ cd memcache-2.2.4
$ phpize &&
$ ./configure
$ make
$ sudo make install

Once all the steps are completed successfully, ensure that the extension directory is specified as the same as the output of the terminal after the extensions installed. Otherwise correct in php.ini.

Also add the line(s) to load the extension(s) in the php.ini file, in the extension section:

extension=memcached.so
extension=memcache.so

And finally restart apache:
$ sudo apachectl restart

And verify in phpinfo that memcache(d) is loaded and working.

These instructions assume that you have a working Apache 2.2 / PHP 5.3 in place and want to add the php mcrypt module. It will work as a fresh install, but keep in mind that additional configuration steps after these instructions are necessary to get your webserver working properly. Those additional steps are omitted here, as there are countless resources available on the Internet.

1. If you don’t already have the mcrypt module (in /usr/lib), download the libmcrypt source code from sourceforge here. Then extract the downloaded file in a Terminal and move inside the created directory. (cd libmcrypt-2.5.8 in my case)

2. Execute the following lines in one command in your Terminal, if you have a 64bit version of Apache/PHP:

CFLAGS=”-arch x86_64″ \
CXXFLAGS=”-arch x86_64″ \
./configure –disable-posix-threads

(for 32 bit versions: ./configure –disable-posix-threads)

2. In your Terminal, run:

make

3. If no errors, in your Terminal run:

sudo make install

4. Download the PHP source code from PHP’s website here. Extract in a Terminal and move into the extracted directory.

5. In your Terminal, run the following lines in one command:

export MACOSX_DEPLOYMENT_TARGET=10.6 \
CFLAGS=”-arch x86_64″ \
CXXFLAGS=”-arch x86_64″

./configure –prefix=/usr/local/php5
–mandir=/usr/share/man
–infodir=/usr/share/info
–sysconfdir=/etc \
–with-config-file-path=/etc \
–with-zlib \
–with-zlib-dir=/usr \
–with-openssl \
–with-iconv=/usr \
–enable-exif \
–enable-ftp \
–enable-mbstring \
–enable-mbregex \
–with-mcrypt \
–enable-sockets \
–with-mysql=/usr/local/mysql \
–with-pdo-mysql=/usr/local/mysql \
–with-mysqli=/usr/local/mysql/bin/mysql_config \
–with-apxs2=/usr/sbin/apxs

6. Correct a bug in Makefile.

As a result of a bug in PHP 5.2.9 and 5.3.0, we’ll need to correct the file Makefile generated by the configure phase. Let’s add ‘-lresolv‘ at the end of the line that begins with ‘EXTRA_LIBS‘. Leave a space and add it like ” …   -lz -licucore -lm -lresolv to whatever is there already. Do not alter the exiting text, simply add it.

7. In your Terminal, run:

make

8. If no errors, run:

sudo make install

At this point, restart apache and check your configuration with phpinfo(). Look for mcrypt as it should appear as an enabled module.

These instructions lead you thru the installation of the latest LAMP Stack on MacOS X Snow Leopard.

1 – Download the installation image from MySQL website here. Then double-click to mount and open the disk image.

2 – Install MySQL Server by double clicking the package “mysql-5.1.*****.pkg” and follow the menu, accepting the default values, unless you want to change something and know exactly what you’re doing.

3 – Install MySQL Startup Item by double-clicking the package “MySQLStartupitem.pkg” and follow the menu.

4 – Install MySQL Preference Pane by double-clicking the file “MySQL.prefPane” and follow the menu. This item will simplify the management of your SQL Server. You can now use the “System Preferences” panel to start and stop the database server.

5 – Enable the php module in your apache config file. You might know that Snow Leopard already ships with Apache 2.2 and PHP 5.3, but it needs a couple of tweaks to make it work smoothly. So, open /etc/apache2/httpd.conf and search for “php5_module”. Remove the comment (#) in front of the line, save and close the file, then restart apache (sudo apachectl restart)

6 – Testing Apache/PHP. Let’s create an info file so we know what we got. Navigate to /Library/WebServer/Documents and create a file called phpinfo.php. Put the following line into the file, save and close. “<?php phpinfo(); ?>”. Now open your favorite browser and hit it (http://localhost/phpinfo.php). You should see a page like the one below, which shows you configuration details, modules enabled and other useful information.

7 – There is no php.ini out of the box (as you may have discovered by looking at the phpinfo page), but there is a sample file called “php.ini.default” which we’re going to use. Copy this file and save it as php.ini.

8 – Set the default time zone. As PHP 5.3 requires the timezone to be set, let’s do this inside php.ini, so we don’t have to worry about it anymore. You can always override it in your application’s bootstrap, if needed. Open /etc/php.ini and search for “[Date]“. Uncomment the line “date.timezone = ” and add your timezone. Check the php manual for acceptable values. (example: date.timezone = ‘America/Los Angeles’)

And that’s it. You should now have a fully functional LAMP stack with Apache, PHP and MySQL server.

I had numerous requests for info and questions relating to JSON extension in CentOS. To enable these functions in RedHat and CentOs 5, the process is really simple and fast.

NOTE: As of PHP 5.2, json extension is now standard. If you’re running PHP 5.2 or later, or like to upgrade instead, you can skip this!

1. Ensure you have the necessary dependecies (php, php-pear, php-devel, gcc, make):
   • $ sudo yum install gcc make
   • $ sudo yum install php php-pear php-devel
2. Use PECL (PHP Extension Community Library) to download the json package:
   • $ sudo pecl download json
3. Use PEAR (PHP Extension and Application Repository) to extract and install the extension:
   • $ sudo pear install json-1.2.1.tgz
4. Create a file in /etc/php.d called “json.ini”, and add the following lines:
   • ; php-json extension
   • extension=json.so
5. Restart apache (gracefully if you’re running a live site:
   • $ sudo service httpd restart (apachectl graceful)
6. Check for availability by creating an info.php file in the web root with the following line:
   • <?php phpinfo(); ?>
7. Load info.php in your browser and check for JSON. You now should be all set, but if it doesn’t appear, verify all of the above steps very carefully.

Memcache is traditionally used as a module inside server side scripts, such as PHP, ASP, ColdFusion and others. And it’s doing a terrific job, as long as it’s implemented correctly.

But if we look under the hood of the actual Memcache application, and I’m not talking about the PHP or ASP extension, but rather the executable that’s running as a daemon under linux, for example, it is a rather simple database like application running in memory. Now there are two basic actions that need to be performed to use it, one is writing info into memcache, the other is reading it. In a typical scenario, there are many reads for one write, that’s the whole point, isn’t it. But what if we can isolate the reading from the server side scripts, and let a small high speed module do that for us.

That’s where Nginx and it’s Memcache Module comes in. We use PHP to fill up the cache and then let Nginx serve that content to the requesting client. According to lead architect Peter Gilg, this configuration is used at Mademan.com, a lifestyle site serving up to 1 million pageviews/day.

To be more specific, we’ll have nginx listen on port 80. If a request comes in, it checks memcache if the requested page is in memory and serves it directly to the client, or sends it to Apache (on port 88 for example) to produce the page. At the same time apache inserts the page into memcache, so it’s available to nginx for the next request. A sample configuration nginx script would look something like this:

server {
  location / {
    set $memcached_key $uri;
    memcached_pass     name:11211;
    default_type       text/html;
    error_page         404 = /fallback;
  }

  location = /fallback {
    proxy_pass backend;
  }
}

Additional Resources: Nginx Memcache Apache

With the release of Eclipse Ganymede, the IDE has become even better. I remember using Zend Studio for Eclipse 6.0.1 for about two weeks, after giving up and moving over to Netbeans 6.5. Too many issues with the debugging part, constant exceptions and a sizable slow down when working on web pages just got me too frustrated.

Now Ganymede is out for a while, but I just haven’t given it a change until now. And I’m positively surprised. While still fairly slow and lagging wile editing html/css content, gone are the countless exceptions, the cumbersome, seemingly endless installation procedure and also xDebug integrates quite nicely with the IDE. There are still a few caveats during the install, especially on a 64 bit environment.

So here are the installation steps I went through getting this IDE installed, PHP editing enabled and everything configured.

Getting the correct version of Java JRE setup. Eclipse doesn’t come with one, so we have to get the right version. I have read multiple blogs from frustrated users complaining that their IDE won’t start up or just start half way. That would be an indication of the wrong JRE. We need the matching JRE for your OS. I got it from here:    32 bit JRE and 64 bit JRE

1. Download Install the Java Runtime Environment. I will install the 64bit version it into /opt, for 32bit version you will need to substitute the file name.

2. Setting the JRE 6u13 as the default:

(you should be getting an output like this: Using ‘/opt/java/jre1.6.0_13/bin/java’ to provide ‘java’)

3. Download and install Eclipse. I will install the full version 3.4 64bit and PDT into /opt/eclipse. You’ll find other versions (32bit) here:

4. Running Eclipse and install PDT 2.0

This will start our IDE.

5. Now we’re going to add PDT 2.0 integration.

Click OK to close the Available Sites Manager. The rest is just as easy – two new sites should appear in the Available Software sites list. Expand the DLTK site (the small triangle to the left of the site name), then the Dynamic Languages Toolkit option, and check “Dynamic Languages Toolkit – Core Frameworks (Incubation)”, from the top of the list. Then repeat the process with the PDT Update site – expand PDT Update Site -> PDT SDK 2.0.0 and check “PDT Runtime Feature” from the list. If you like to add the latest Subversion client, select the entire “update_1.6.x” feature. That’s it. Click Install and follow the prompts.

Once installed, Eclipse recommends restarting the application. Accept, restart, and enjoy your new PHP IDE with PDT 2.