The first part of this series will focus solely on downloading the starter kit, how to pull it down from the SVN, and how to make sure your apache is configured to handle it. The rest of the series will focus on using this starter kit to make some awesome apps.

To start with, this series will assume that you have a basic knowledge of the following:

• Configuring your own local apache test environment or using a live apache server.
• Basic understanding of PHP syntax, functions and usage.
• Some knowledge of OOP, understanding of classes and methods.

Basically I will be giving you a “Starter Kit”, which will require you to have a functional PHP/Apache setup in order to run. From here on out, instead of referring to the package as the “Zend Framework Starter Kit”, I will simply be calling it ZF-Starter. You are free to use this code however you see fit, without attribution! Read on to check out all the steps in getting the code and getting started!

Exporting your copy of ZF-Starter

For ease of updating on my part, and since most developers already use some form of Version Control, I’ve added a public SVN Repository to greymass.com that contains a “Zend Framework Starter Kit”. If you are unfamiliar with using a SVN, I would like to direct you to a Round-Up post on Smashing Magazine with SVN resources. It’s a little older, but the resources within are still valid and good for learning about source control with SVN.

So, before you download the code itself, we should probably talk about how Apache or your Web Server needs to be configured in order to run this sample code. I will list off some of the basics that you need to have setup/enabled:

• Enable apache’s mod_rewrite (or your web server’s equivalent extension)
• PHP 5.3+ (5.2.x for earlier tutorials, but we will get into some things that require 5.3, so upgrading is recommended)
• Enable PHP’s short_open_tag in your php.ini or .htaccess
• The DocumentRoot for running this example will be the /public_html folder within the repository, not the root.
• You will need your web server setup to use the .htaccess included within the /public_html folder.

If anyone has any specific questions or setup problems with setting up their instance of a web server, I’d like to direct you to ServerFault.com. I really want to focus on the actual implementation of Zend Framework and less on the millions of configurations web servers can have. Onto the repository!

ZF-Starter Repository URL: http://greymass.com/code/zf-starter

Once you have some form of SVN installed on the operating system of your choice, there are 2 methods that you can download the ZF-Starter Kit. Both methods I will recommend use the “Export” feature of SVN, which will download the code and remove the “Version Control” from the code. You could also simply do a “Check Out” of this code, however if you started making changes, you’d be unable to commit them back to my public repository, so really checking out isn’t needed.

• SVN Export (Command Line) - If you are running from a command line, you can download the code from this command:

• svn export http://greymass.com/code/zf-starter c:/path/to/your/web/folder

• SVN Export (GUI)
• Windows/TortoiseSVN: Right click in the folder you wish to download the code. On the menu that pop’s up, hover over “Tortoise SVN” and on the sub-menu, click “Export”. The first box, “URL of the Repository” on the export screen should be the repository URL located above.

After the export is complete, browse to the folder that you downloaded, it should look something like this:

What are all these folders?

The starter kit is all about organization and establishing the base hierarchy of what you will be building. There are a few different ways you can use and implement the Zend Framework, this method is using the MVC pattern. The 2nd section of the Zend Framework – Quick Start gives a nice short overview of what these pieces do. Here’s a quick breakdown in my own words:

• Controllers – Controllers are objects that parse user input, call upon the models the user may need, redirect the user to a view and control the flow of traffic.
• Models – The model is the “data” object, the source of your information. MySQL tables can be used in models to fetch and store data, along with many other DB/NoDB solutions (which we will get into later in the series)
• Views – In one word: Templates. These are the files that hold your HTML, fill in the actual pages, and know how to display the data that the user has requested.

As you can see in the ZF-Starter, these are all folders with the /application folder. The other two folders not mentioned in the MVC structure that are included in the /applications folder are the layouts and configs folders. The layouts folder is a view technically, as it is used to create generic templates used site-wide, which will be used later in this series. The configs folder is probably a little more simple, it’s basically a location to store your server-based configuration options for your application (ie your DB connection string, analytics code, etc).

Also included as a folder you will find the /library and /scripts folders. The /library folder contains the Zend Framework as well as any other libraries you may require and/or create. The /scripts folder is a utility folder, which I use to store shell scripts/batch files to automate some routine tasks. For now, we will leave these folders alone, and come back to them later.

The last folder included is the /public_html folder, which is exactly what it sounds like, the root of your website. Images, Stylesheets, Javascript and all other files that aren’t part of your code can be placed in here just like any other website. The index.php and .htaccess files are already configured in those folders to run the site, and should need very little modifications for basic usage.

So what needs to be done?

The only thing that needs to be done after Apache is configured and the code is placed in the proper location is one step: rename the configuration file. In the folder /application/configs/ you will find a file named application.ini.template. This file just needs to be renamed to application.ini. Take a look in the file if you want to see some common configuration options, we will be changing this file in the future to add more flexibility to the application.

After you rename/copy your application.ini, try loading up the site and you should see the following (with a different time obviously):

That’s pretty much it… throughout this small tutorial you should have completed the following steps.

• 1) Have a functional Apache/IIS configuration with a mod_rewrite compatible extension.
• 2) Check-Out / Export the ZF-Starter Kit onto your local machine/web server.
• 3) Configure Apache/IIS site to point the DocumentRoot to the /public_html folder.
• 4) Rename/Copy the application.ini.template file to application.ini.
• 5) Check your site via a browser and see a page with some examples and the current time.

I plan (time permitting) on creating an entire series of “How-To’s” based on this ZF-Starter kit explaining how to integrate Databases, Frameworks and other libraries into the mix, if you have any requests, or end up creating anything cool with the kit, feel free to drop a comment and let me know!

Enjoy!

From: Wikipedia on the Active Record Pattern
Active record is an approach to access data in a database. A database table or view is wrapped into a class, thus an object instance is tied to a single row in the table. After creation of an object, a new row is added to the table upon save. Any object loaded gets its information from the database; when an object is updated, the corresponding row in the table is also updated. The wrapper class implements accessor methods or properties for each column in the table or view.

Essentially what we are doing is building a class for our tables in our database, then using the objects created to control what is coming in and out of the database. Also, for this post, I am going to be referencing the same contact table that was created and covered in our first ADOdb post, Getting started with ADOdb for PHP. Now, not to worry if you do not have the database already created, because in this article we also are going to cover dynamically generating table schema with XML using the ADOdb Data Dictionary.

To get started, lets first write the class that will control our contacts table.

An ADOdb_Active_Record Class

Each one of our tables that we want to access via the Active Records Method needs a class wrapped around it. The class we are going to create is going to be called contact and will extend the ADOdb_Active_Record class. The extending of the ADOdb class will give us all the basic functionality we will need in our class. You also will need to include one more file into your header, as well as change the way your database adapter is called.

require_once("adodb/adodb.inc.php");
require_once('adodb/adodb-active-record.inc.php');
$db = NewADOConnection($config['dbtype']);
$db->debug = true;
$db->Connect($config['server'], $config['username'], $config['password'], $config['database']);
ADOdb_Active_Record::SetDatabaseAdapter($db); // This line of code establishes DB connection to work with ActiveRecords.

Now lets make an extremely simple table wrapper class.

class contact extends ADOdb_Active_Record{
	var $_table = 'contacts'; // We need to specify what the name of the table is for this class.
}

It’s pretty simple, nothing here is required of the class, except for the $_table variable, and that is only required if your table name differs from the name of the class. Since the name of our class is contact and the table is named contacts, we must specify what the table is named.

Organizing how you wish to place your classes and files is up to you, but if you are looking for ideas, here is the generic directory structure that I use to setup my project.

   project/
      db/
         wrappers/
            contact.php
         schemas/
            contact.xml
      index.php

The wrappers folder contains all of the classes for the tables, while the schemas folder contains all of the XML files used to build/maintain the databases. However, for this example, I am just going to leave them all in the same file or same folder.

Building a method to Maintain our Schema

This is a small method I normally include in all of my wrappers to build the databases. You could easily build a class of your own that the wrappers extend, then have your new class extend the ADOdb class, to prevent yourself from repeating code. However, in this example, we are going for simplicity and keeping everything in one place and making it work. First off you are going to need to include the proper files from ADOdb, including adodb/adodb-xmlschema.inc.php. This file is the file that will do the parsing and execution of the XML files you will create.

So, now lets make an XML Schema file that will control the format of our table.

<?xml version="1.0"?>
<schema version="0.2">
  <table name="contacts">
    <field name="id" type="I">
      	<descr>A unique ID assigned to each contact.</descr>
      	<KEY/>
      	<AUTOINCREMENT/>
    </field>
    <field name="FirstName" type="C" size="50">
				<NOTNULL/>
		</field>
    <field name="LastName" type="C" size="50">
    		<NOTNULL/>
    </field>
    <field name="Phone" type="C" size="15">
    		<NOTNULL/>
    </field>
    <field name="Email" type="C" size="100">
    		<NOTNULL/>
    </field>
  </table>
</schema>

The layout of the XML is pretty easy to understand if you just glance over it. Essentially it is the schema of our database written out in a simple to use XML format. Each table and each field receives its own nodes and parts of the XML. More documentation on exactly what you can include into this XML can be found in the Data Dictionary Documentation, about 1/2 way down the page. You are going to need to save this file in the same area that you are working in, I saved it as contacts.xml.

Building an Initialization Method for the Schema

Now that we have our XML written for the table, now we need to parse it and include it into our table. For this, I normally would make a method called “init” on my wrapper that calls the proper XML file, parses it and executes any updates needed to the table all while maintaining the data within the table. Here is what our table wrapper would look like with this class embedded in it.

class contact extends ADOdb_Active_Record{
	var $_table = 'contacts'; // We need to specify what the name of the table is for this class.

	// This is a function I created, to work with the XML DB schema
	function init() {
		global $db; // We need to bring in the $db adapter
		$schemaFile = "contacts.xml"; // This is the file of the schema
		$schema = new adoSchema($db); // Establish a new Schema Object, and pass in the DB parameters
		$schema->ParseSchema($schemaFile); // Parse through the schema and read it into the object
		$schema->ExecuteSchema(); // Execute the Schema, and update the table if needed
	}
}

The code above is pretty well commented, essentially we are telling the object which file it should be using as its schema, creating a new schema object, parsing the schema then executing any actions required to update the table. If the script you were running had to build tables on the fly, this might be an excellent way to accomplish it. The main reason I use these XML schema is for rapid deployment across multiple servers. No more porting data from one database server to another, instead have an init call that will build your tables for you.

Alright, now that the wrapper object is created, we can move into the actual application portion of the code. So far, if you are using the code from the last example, your code should look something like this.

require_once("adodb/adodb.inc.php");
require_once('adodb/adodb-active-record.inc.php');
require_once("adodb/adodb-xmlschema.inc.php");

$config['server'] = "localhost";
$config['dbtype'] = "mysql";
$config['username'] = "root";
$config['password'] = "";
$config['database'] = "adodb_test";  

$db = NewADOConnection($config['dbtype']);
$db->debug = true;
$db->Connect($config['server'], $config['username'], $config['password'], $config['database']);

// This line of code establishes DB connection to work with ActiveRecords.
ADOdb_Active_Record::SetDatabaseAdapter($db);

// This is a special class for your table, extending the ADOdb_Active_Record class.
class contact extends ADOdb_Active_Record{
	var $_table = 'contacts'; // We need to specify what the name of the table is for this class.

	// This is a function I created, to work with the XML DB schema
	function init() {
		global $db; // We need to bring in the $db adapter
		$schemaFile = "contacts.xml"; // This is the file of the schema
		$schema = new adoSchema($db); // Establish a new Schema Object, and pass in the DB parameters
		$schema->ParseSchema($schemaFile); // Parse through the schema and read it into the object
		$schema->ExecuteSchema(); // Execute the Schema, and update the table if needed
	}
}

This is all of the code you should need to get started working with the contacts table, besides the contacts.xml file which we covered in the last section. Now, anytime you need to recreate the table or update the schema of the contacts table, you need to call 2 lines of code.

// First off, we create a new instance of the contacts table wrapper object
$contact = new Contact();
// Then, if needed, we run the init() command to create/update the table as the schema sees fit.
$contact->init();

If you have debugging on, you will see the SQL commands the Active Records method is going to generate automatically for you. You could add or remove columns, modify data types, or even rename columns from the XML, and once these lines of code execute, it will correct your table to match the schema. This is incredibly useful when you are developing an application across multiple servers and need to ensure that the database schemas across all development platforms are the same structure.

Inserting a new record into the Contacts Table

Well, running the above code should give you the table at least, you may want to insert some dummy records into the table, so lets show you how to create a new record in the table.

// Lets insert a new record from scratch
$newPerson = new Contact();
// Set all of their values for the database
$newPerson->firstname = "Aaron";
$newPerson->lastname = "Cox";
$newPerson->phone = "555-012-3456";
$newPerson->email = "aaroncox@emailaddress.com";
// And finally save the person in a new record
$newPerson->save();
// Wondering what their Database ID was? Well it autopopulates it into the field upon saving.
echo $newPerson->id;
// Echoing the $newPerson->id will display their new ID on the page.

All we have to do to create a new table record is create a new instance of the Active Record class, and start populating the properties of the object. Once complete, call the ->save() method on the object and poof, your record is properly saved into the database. The object is also updated with the proper ID that was auto generated by the table, you can see this on the last 2 lines of the example above, as I am echoing the content out to the screen.

When I started with Active Records, using this method helped me a tremendous amount when trying to figure out what variables I was setting to what values. Reading code like this is so extremely simple and effective.

Populating an Active Record by ID

Another incredibly useful method you can use with Active Records is to load records, then update them. To load a record, you simply use 1 line of code.

$contact->load("id = 1");
$contact->firstname = "ChangedName";
$contact->save();

The first line will run the SQL query and load ID = 1 into the object, making it look something like this:

contact Object
(
    [_table] => contacts
    [_dbat] => 0
    [_tableat] => contacts
    [_where] => id = 1
    [_saved] => 1
    [_lasterr] =>
    [_original] => Array
        (
            [0] => 1
            [1] => Joe
            [2] => User
            [3] => 545-454-5454
            [4] => joe@joeuser.com
        )

    [id] => 1
    [firstname] => Joe
    [lastname] => User
    [phone] => 545-454-5454
    [email] => joe@joeuser.com
)

You can do this via any search method you can use in SQL as well, here are a few examples. Keep in mind however that the “LOAD” method will only return one record. After the record was loaded, I am changing the firstname value to “ChangedName” and then proceeding to save the record. Once again, with debugging on, you will see the library writing the SQL for you to update that record to the value you chose to set it to.

Here are a few more examples of ways you can load data using the load method.

$contact->load("firstname = 'John'"); // Finds all with firstname IS John
$contact->load("firstname like 'John%'"); // Finds all with firstname LIKE John%
$contact->load("firstname like 'John%'"); // Finds all with firstname LIKE John%

Returning an Array of Objects using FIND

If you want to return multiple results into an array of objects, you can use the find method to do so. Find functions the same way as load, except it returns the values back into the array specified. We are going to use the same examples above, except as arrays with multiple objects inside them.

$contacts = $contact->find("firstname = 'John'"); // Finds all with firstname IS John
print_r($contacts); // Dump out the results on screen

$contacts = $contact->find("firstname like 'John%'"); // Finds all with firstname LIKE John%
print_r($contacts); // Dump out the results on screen

$contacts = $contact->find("firstname like 'John%'"); // Finds all with firstname LIKE John%
print_r($contacts); // Dump out the results on screen

Now once you have these record sets, you can easily loop through them and treat them individually like their own objects, and even update them. In my opinion, is much easier than writing a query, executing it, loading the results into a recordset and then accessing them.

foreach($contacts as $singlecontact) {
	echo $singlecontact->firstname." ".$singlecontact->lastname."
";
	$singlecontact->email = "email@address.com";
	$singlecontact->save();
}

These are all of the basic principals of the Active Record Implementation and the XML Data Dictionary Schema for ADOdb. There are a lot more things you can do with the Active Records, which I will hopefully dive into at a later date. The documentation on the ADOdb Website provides a LOT of examples that are practical to use, and they are what I used to learn the library myself and implement them in my day to day work.

Further Reading

For further reading, I would recommend the following links:

ADOdb @ SourceForge
An introduction to the ADOdb class library for PHP
ADOdb Implementation of Active Record

Throughout this small guide, the focus will be on getting the most out of the ADOdb library for accessing MySQL databases. One of the best parts of ADOdb in my opinion is the ability to switch between different databases without having to change your code. The last application I created with the ADOdb library was written locally on my development machine using a traditional LAMP setup, but upon completion was deployed to a Windows 2008 server running Microsoft’s SQL Server. I encountered very few issues in the transition, as swapping between database types was really not an issue, as long as it was coded it properly.

Here’s a quick list of what exactly will be covered in this “getting started” post.

Contents

• The Installation, Connection String and Config
• Performing a SELECT, looping through results
• Using the CACHE Mechanism to Speed up queries
• The EXECUTE Syntax for performing Updates/Inserts

The Installation, Connection String and Config

First things first, you are going to need to include the ADOdb library in your website’s server someplace. The easiest way to do this, is simply to create a folder in your project, call it ADODB, and download the library into that folder.

You will find the Download for ADOdb here: http://sourceforge.net/project/showfiles.php?group_id=42718

There are 3 different versions, each suited to which version/language you will be using. Personally, I am using the PHP5 version of the library. Simply download the archive and extract it into your project in a folder of your choosing. For this example, lets put it into your document root into the ADODB folder. If you are feeling savvy, feel free to also create a location on your web server for the library, and simply modify your include paths to search that location.

Next you are going to need a database to play around with… I went ahead and created a database on my development machine called adodb_test, and created a table called contacts with the following SQL commands. This will also insert 2 example contacts into the table with dummy information.

CREATE DATABASE `adodb_test`;

CREATE TABLE `adodb_test`.`contact` (
`id` INT NOT NULL AUTO_INCREMENT PRIMARY KEY ,
`FirstName` VARCHAR( 50 ) NOT NULL ,
`LastName` VARCHAR( 50 ) NOT NULL ,
`Phone` VARCHAR( 15 ) NOT NULL ,
`Email` VARCHAR( 100 ) NOT NULL
) ENGINE = MYISAM ;

INSERT INTO `adodb_test`.`contacts` (
`id` ,
`FirstName` ,
`LastName` ,
`Phone` ,
`Email`
)
VALUES (
NULL , 'Joe', 'User', '555-555-5555', 'joe@joeuser.com'
), (
NULL , 'John', 'Doe', '555-555-5555', 'john.doe@nobody.com');

Now that you have the files downloaded and an example database setup, including it into your project is as simple as below.

$config['server'] = "localhost"; // The URL/IP for your database server
$config['dbtype'] = "mysql"; // The type of database we are using (mysql in this example)
$config['username'] = "username"; // Username to connect to the database
$config['password'] = "password"; // Password to connect to the database
$config['database'] = "adodb_test"; // The Name of the Database which to use

require_once("ADODB/adodb.inc.php");;
$db = NewADOConnection($config['dbtype']);
$db->debug = true;
$db->Connect($config['server'], $config['username'], $config['password'], $config['database']);

// Do your SQL work here

$db->close();

Now generally I have a config.php file stored someplace out of my SVN repository, making it unique to each deployment of the application I create. The $config variables are usually set within this file, but for this example, I am trying to keep it all in a single script for ease of understanding.

The above code will establish a connection to your MySQL database or provide an error if it cannot. At the end, the $db->close() will terminate the database connection. The line of code “$db->debug = true” tells the library you are going to be in debug/development mode, and will output every single query that ADOdb executes, as well as provide errors on anything that might occur. It’s extremely useful for debugging your applications and seeing exactly what your code is trying to accomplish.

Performing a SELECT, looping through results

Well, now that we are connected, we might as well write a query for new table. Let’s say we want to write a command that will retrieve all of the contacts in our database. Well, there’s a nice little command that makes it easy to perform this action.

$res = $db->GetAll("select * from contacts");
foreach($res as $row) {
echo $row['FirstName']." ".$row['LastName']."
";
}

This code will loop through every row returned from the database, echo’ing the first and last name of each person on its own line. You can also append a WHERE clause into this statement to refine your results. There are a few other nice commands that are useful when selecting records as well.

// Returns a single row, and single column based on WHERE criteria (or first available)
$res = $db->GetOne("select LastName from contacts WHERE FirstName = 'John'");
echo $res; // Returns "Doe"
// Returns an Array containing a single Row based on WHERE criteria (or first available)
$res = $db->GetRow("select * from contacts");
var_dump($res); // Returns the row for "John Doe"

Pretty simple eh? This is one of the reasons I moved over to ADOdb a few years ago, was simply because I could write code more efficently that if I was just using straight PHP commands. Now that PHP has its PDO Layer its a lot easier to use with straight PHP, but I still prefer the ADOdb library, and hopefully through this article you will find out why.

Using the CACHE Mechanism to Speed up queries

A lot of applications repeat a lot of queries, over and over and over, and will return the same results during a period of time. Let’s say this example database of contacts is used for a user base of 10,000 users. Every time one of the users loads a page looking up an index of contacts, they will probably be getting the same results. In a normal application repeating and hammering our database server with all of these duplicate requests is counter productive, so what to do?

ADOdb provides a solution to your problem, it has built in record set caching, and its incredibly easy to use and build into your application. All of the above code does not use the cache system, but if you wanted it to, its as simple as changing the method you are calling from ADOdb.

$res = $db->CacheGetAll(60,"select * from contacts");
foreach($res as $row) {
echo $row['FirstName']." ".$row['LastName']."
";
}

// Returns a single row, and single column based on WHERE criteria (or first available)
$res = $db->CacheGetOne(60,"select LastName from contacts WHERE FirstName = 'John'");
echo $res; // Returns "Doe"
// Returns an Array containing a single Row based on WHERE criteria (or first available)
$res = $db->CacheGetRow(60,"select * from contacts");
var_dump($res); // Returns the row for "John Doe"

Notice the change, all of the methods called from the ADOdb Object are now prefixed with the word Cache. Also notice, before the query, we now have a number being passed into the call. The number I chose for this example was 60, meaning that the query will be cached on the server’s disk for 60 seconds. If one user hits this page, and loads that query, it will record the results to a temp file on the server, and feed the results back for anyone else from the temp file for 60 seconds.

So what exactly does this do? Well, now lets say you do a query for all users with the last name starting with the letter “S”, and there are 5,000 results. That query is probably pretty intense if your database is that large. So now imagine if 3,000 people use that same query in a hour, it would be extremely intensive on your database, and might cause some problems with the server. So by using the ADOdb caching mechanism, you could set it up so that the first person that loads the page, actually hits the database, and then every user after that wouldn’t be using the database, but a flat file in your temp folder. The performance boost for applications like this would be incredible.

Now the caveat to this is, by using cached results you won’t be able to see immediate results, unless you design your update process to flush the cache whenever a record is updated. It’s the same theory that the WP Super Cache plug-in for WordPress uses. Less Database Calls, more Flat Files, but the same functionality as a dynamic application.

The EXECUTE Syntax for performing Updates/Inserts

Updating and Inserting is pretty much just as easy as running queries against the database, very straight forward in how you can use the execute statement.

$db->Execute("INSERT INTO contacts VALUES (null,'Firstname','Lastname','phone','emailaddress')");

// or
$sql = "INSERT INTO contacts VALUES (null,'Firstname','Lastname','phone','emailaddress')";
$db->Execute($sql);

Essentially all the execute command is doing is running whatever SQL you are putting into the EXECUTE command, and will return either true or false based on whether it succeeds or not. You can use the EXECUTE command to fire stored procedures or any SQL command that you would like just to pass straight to the database.

More about ADOdb to Come!

In the next post about ADOdb I am going to cover using the ADOdb Active Records implementation as well as using XML to generate and update your table schema. There are some downfalls to using ADOdb’s Active Record implementation, but let me tell you, they are incredibly organized and a great tool for developing complex applications.

Making sure cURL is enabled and setup
First things first, you need to make sure cURL is enabled on your web host. The easiest way to accomplish this is to check your phpinfo on your server. Simply deploy a PHP file with the following information onto your server, and name it whatever you want.

<?
phpinfo();
?>

After the file is uploaded/saved onto your web server, look through the file to ensure that there is a section that looks as follows.

If your PHP file doesn’t have this section of code, or nothing similar to it, then your hosting service may not support cURL, or it may not be enabled. If you are on a hosting service, you can ask your host to enable it for you, or if you are on your own server, you can modify your php.ini file to enable the extension.

You can modify your php.ini file as follows:
(if you can’t find it, look at the top of the script we wrote above, it will give you the ini path)

// Find this line in your php.ini
;extension=php_curl.dll

// Remove the semi-colon in front, to make the line look like this:
extension=php_curl.dll

After modifying and saving your php.ini file, you are going to have to restart your web service.

- If you are running on Apache, you should be able to enable it with a simple “apachectl restart” command.

- If you are running an IIS web server, you are going to have to restart IIS or just restart the Worker Pool that is running your PHP. This can be done through the MMC IIS Snap-In.

- If you are running WAMP on your local machine, simply right-click on the WAMP icon in your system tray, find the Apache menu, and click “Restart”.

Just make sure you go back into your file running phpinfo() to ensure that cURL is showing up in the file now. If not, you may want to seek addition support from your IT, Co-workers or Web hosting provider for more information as to why cURL will not function on your server.

Assuming everything is running now, and cURL is enabled, we will continue onwards.

A simple cURL Request

cURL isn’t incredibly hard to use to pull the data in, as illustrated below.

<?php
// Init $curl as a cURL object
$curl = curl_init();

// Tell cURL what URL we are going after
curl_setopt($curl, CURLOPT_URL, 'http://www.google.com');

// Tell cURL we would like headers as well
curl_setopt($curl, CURLOPT_HEADER, 1);

// Tell cURL we would like the results as a string instead of just dumping it on the screen
curl_setopt($curl, CURLOPT_RETURNTRANSFER, 1);

// Execute the cURL request
$data = curl_exec($curl);

// Close the cURL request
curl_close($curl);

// Display the data from the variable to ensure its there.
var_dump($data);

The above set of code will go out to http://www.google.com and will set the variable $data to contain the HTML contents of the website. The var_dump($data) at the end of the file merely spits it back out onto your screen so you can see the data you have to work with.

Now, what you end up doing with this data is up to you! You could run it through some regex statements to pull relevant information, you could parse it line by line and store certain portions of code somewhere, or if you are pulling an XML file, you could begin to parse the XML. Since this article is just about cURL, we won’t get into that.

Using a cURL Request Object

A bit more on the advanced side, but if you want to create a function to handle all your requests for you, I’ve pulled one out of my code library that you may find useful.

(Thanks to antych for the tip at dzone.com)

<?php
function curlURL($url) {
    $curl = curl_init();
    curl_setopt($curl, CURLOPT_URL, $url);
    curl_setopt($curl, CURLOPT_RETURNTRANSFER, true);
    curl_setopt($curl, CURLOPT_USERAGENT, 'Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.2) Gecko/20070219 Firefox/2.0.0.2');
    $output = curl_exec($curl);
		return $output;
}

$curlResults = curlURL("http://www.google.com");

// Display what we've found
var_dump($curlResults);

Well, gathering data this way is pretty simple when you know what you are passing in. Notice above in my firefox, that I am passing a Firefox browser string into the cURL request. Why is this? Well some websites try to block cURL or automated requests (such as the World of Warcraft Armory, which is what I was scraping), so by mimicking a browser, we can get past these obstacles.

Now what you do with all of this new found data, well that is up to you. Eventually I will create a post more about parsing this data you find, but that is for another day.

The Semicolon

The basic syntax of PHP, which is the first thing every PHP developer needs to know, is the semicolon. Most lines of code end with a semicolon, which essentially means, to execute the code that has been loaded before this semicolon and after the last one.

$foo = "bar";
$fooArray = "Bar",
            "This",
            "Something";

You can break your code into multiple lines in some cases, but technically the code above is still only two lines of code. The first line of code assigns the variable of $foo, and the second line sets an array called $fooArray. Even though the array is broken into three separate lines, it still executes as one line of code.

Notice how still, each line of code ends with a semicolon. You cannot split every line up like this, but when assigning arrays, building long strings, or even working with objects, you can drop down and create a new line. The reasoning behind this will be covered more in the “Making your code Pretty” article.

The period as a “String Connector”

Some languages use the plus symbol (+), some languages use variations of quotes, and PHP uses the period (.) as a string connector.

// --- Long Method
echo "Your IP address is: ";
echo $_SERVER['REMOTE_ADDR'];
echo " <br/>";
echo "The current date/time is: ";
echo date("Y-m-d H:i:s");
echo " <br/>";

// --- Short Method
echo "Your IP address is: ".$_SERVER['REMOTE_ADDR']." <br/>";
echo "The current date/time is: ".date("Y-m-d H:i:s")." <br/>";

The two above examples will yield the exact same results, example #1 not using any string connectors, example #2 joining strings using the period. You can use this syntax to set variables, within functions, or nested inside of loops. Essentially what you are doing is appending to the current string with what is after the period. By joining multiple strings together with the “something”.$something.”something” method, you can easily assemble long strings without having to write an incredible amount of code.

(Encapsulating with Parenthesis)

This is just like algebra folks… things within parenthesis will be evaluated before the rest of the equation.

 	echo 1 + 6 * (( 8 - 5 ) / 2 );

	// Order of Operations:
	// 8 - 5 = 3
	// 3 / 2 = 1.5
	// 6 * 1.5 = 9
	// 1 + 9 = 10
	// echo 10

The comment above shows the order of operations, which is identical to that of an algebra equation. Evaluate the values inside the parenthesis first, work your way outwards, then use the standard order.

Order of Operations
Source: http://www.math.com/school/subject2/lessons/S2U1L2GL.html

1. First do all operations that lie inside parentheses.
2. Next, do any work with exponents or radicals.
3. Working from left to right, do all multiplication and division.
4. Finally, working from left to right, do all addition and subtraction.

Brackets and Uses

Brackets, as in [], are primarily used for assigning or calling values from an array.

	// Example #1
	$array = array("red","green","blue");
	echo $array[0]; // Will display "red"
	echo $array[1]; // Will display "green"
	echo $array[2]; // Will display "blue"

	// Example #2
	$array = array("color1"=>"red");
	echo $array['color1'];

By default an array will populate its keys with numbers, in the above example, it does just that. When passing values into an array, each value is assigned an auto-incremented number, starting at zero. To reference these values in an array in the most simple fashion, you simply put the key you wish to call on within brackets.

These keys do not have to be numbers, they can be strings as well, and the values of the array can be pretty much any type of variable or object. The second example shows that you can pass in a string within the brackets to pull out the value for that specified key.

For more information on arrays, please see: PHP Basics – The Array.

What are those “Curly Brackets” used for?

The { and }? They are actually called “Braces” and are used to define the starting and ending of a structure of code. The most common use of them while starting is to start a loop or if-statement. The “Open Brace” or {, signifies we are starting an structure of code that will continue until the “Close Brace”, or }. This is easily seen in an if-statement as seem below.

if($foo == "bar") { // This brace starts the structure
	// Do something!
} // This brace ends it

The code encased in the braces will only execute if the condition of the if-statement evaluates to TRUE. There are also other methods of starting and stopping an if-statement or loop, but we will wait to get into those later, as to not confuse people.

Braces are also used to define function, class and namespace contents. These are a little further along, but still solid examples.

	function doWork($foo) {
		// Perform Actions on $foo
		return $bar;
	}

	class foo extends bar {
		private $var = "test";

		public function doWork($var) {
			// Do Work!
			$this->var = $mod;
		}
	}

Notice in the second example, there are nested braces within. Each brace has a start and a stop, telling the system which pieces belong in which places. When your code starts getting extremely messy or complex, its always a good idea to keep the braces lined up with the same spacing for ease of reading. Yet another topic for another day.

The Key=>Value Syntax

The last syntax covered in this post is the $key=>$value assignment syntax, which can be a little confusing at first. This is primarily used in arrays and is meant to set specific keys to specific values.

  $key = "key";
  $value = "value";

	$array = array($key=>$value);
	$array = array("key"=>"value");

	echo $

The two above examples will both assign the $array variable to contain the same array; a single key named “key” will be assigned the value of “value”. The => syntax states that you are using a key=>value combo to pull this off. This can also be used in a foreach() loop to iterate through an array of values, as seen below.

$array = array("color1"=>"red", "color2"=>"blue");

foreach($array as $key=>$value) {
	echo $key." = ".$value."<br/>";
}

// Outputs:
// color1 = red
// color2 = blue

The loop will go through every item in the $array variable, and display every key=>value combo within it.

Well, that’s it for the basics of syntax. Stick around for more info at another time!

Starting off, we will look at the greater than and less than operators, which are going to be extremely simple and to the point.

$a = 1;
$b = 2;

$result = $a > $b;
echo "a > b = ";
echo $result;
echo "
";
$result = $a < $b;
echo "a < b = ";
echo $result;

The above lines of code will output that "a > b = false" (false doesn't echo), and "a < b = true". What does this mean? It means that the values returned by greater than and less than statements are either true or false. The above would be an extremely strange way of finding your results, so I am going to use a more common example next.

 if($a > $b) {
   echo "a is greater than b";
 } else {
   echo "a is less than b";
 }

Essentially what you are saying, is IF A is greater than B, then display the echo, else move on down to the bottom portion. Pretty simple, so moving on, here are two new operators.

 if($a >= $b) { }
 if($a <= $b) { }

It's just what it looks like, greater than OR equal to. Now your mixing and matching operators, stating maybe that you want something above/equal to, or less than/equal to. It's extremely simple logic/algebra here, just to check the values of these variables.

Onto a little something more complicated, the not operator.

 $a = 1;
 $b = 2;
 if($a != $b) { echo "not equal"; }

The exclamation point in front of the equals means we are making sure they are not the same value. This is extremely useful when you are building something that cannot have identical values. The "!=" statement checks the two variables to make sure they are not equal to each other, but does not care whether or not they are the same data type. Get where this is going from the "triple equals" from the first article?

 $a = 1;
 $b = "1";
 if($a !== $b) { echo "not equal or not the same type"; }

By using the single exclamation and the double equals, it is now also checking the variable types to make sure they are not the same. Even though technically both of the variables are equal to 1, $b is a string, and $a is an integer, so this statement will return and tell you they are "not equal or not the same type".

Well, these are all the basic operators. The next set of operators won't come up until the more advanced articles, where we will talk about Ternary Operators.

You can pretty much think of an array as a mini-storage unit for variables, someplace to order them, keep them in one space, and reference them by name dynamically. There are more advanced ways to do some of this as well but arrays are a good starting point.

Just as a starter, here is a basic array, the first code snippet is the PHP to write the array, and the second is a visual representation of the variable.

 $variable = array("red","green","blue");

$variable = Array
(
    [0] => red
    [1] => green
    [2] => blue
)

Now, a brief overview at exactly what you are looking at here, in case you have never worked in an array before. The variable named $variable is an array, and it contains 3 values, “Red”, “Green” and “Blue”. Each of these values now has dynamically been assigned a number on the left hand column. These are the keys to access the data in the array.

If you were to make an analogy to understand it better, we could say an array is a book, and each variable in the array is a page. Each page has a page number, and those page numbers would be the keys in the array. Let’s run with that example, and create a bit more complex of an array, so and pretend our array is indeed a book.

 $book = array(
     "The quick brown dog...",
     "Jumped over the big red fence...",
     "To get to his food..."
  );

Don’t let the change of how I typed the code throw you off, this is the exact same sample as above, instead we have a “page” of the “book” stored within each “page number”. Notice how the variable looks now:

Array
(
    [0] => The quick brown dog...
    [1] => Jumped over the big red fence...
    [2] => To get to his food...
)

The variable is still pretty much the same, just with different values stored within its keys. So now, if we were going to print out the first value of the array to the screen, we would echo it out, with slightly different syntax than just a standard echo.

 echo $book[0];

You would echo it just like a standard variable, except directly after, you would use brackets to specify which key you want to retrieve from the array. The above code would output “The quick brown dog…” onto the screen. You can simply change the number at the end of the variable to specify which portion of the array you are looking for.

The above syntax you can also set values in an array with as well!

 $book[4] = "This is another page!";
 $book[1000] = "This is WAY out there...";

These two lines of code will write their values into the key of 4 and key of 1000. There’s nothing telling you that you have to use numbers in order, or even numbers for that example!

 $book['index'] = "This is the index of the book";

You can store keys with words as well, if that helps you organize how your data is stored. PHP uses a lot of arrays for sessions, server variables and many other things. Here’s an example of pulling the IP address of your client, from a $_SERVER variable that is automagically set whenever a script on your server is called.

 echo $_SERVER['REMOTE_ADDR']; // Will print the IP address accessing the script

Arrays can be an amazing storage tool to keep your variables in check, instead of assigning every single variable its own name. It also is nice if you want to pass multiple variables into a function or an object’s method at once. That’s a little bit more advanced, and a subject for another time, but just understanding the basics of how an array looks, visually and in concept, will take you a long ways.

The Equals (=) Operator

The primary role of the equals operator I would consider is setting variables. The single equals role is to set the variable on the left, to the value on the right.

$foo = "bar";

This will set the variable named $foo to contain a string value of “bar”. Simple eh?

Well, now what happens if you double up your equals?

$foo == "bar";

It no longer will set the variable $foo equal to “bar”, instead what it is doing is comparing the variable on the left to the value on the right. So really, the above line of code is totally impractical, because really it isn’t doing anything. Lets write something that makes a little bit more sense.

if($foo == "bar") {
  echo $foo;
}

So the “IF Statement” above now is a better idea of exactly what is going on here. The statement is saying:

“IF $foo is set to ‘bar’, lets display the value of $foo on the page.”

The Double Equals expression doesn’t care what type of variable $foo is, as its moving through, which leads to the next point. The Triple Equals operator. This ones a little bit trickier and is very, very specific. In the following example, we are no longer going to use a string for the value of $foo, but instead use a number as a string and as an integer.

Example 1:
$foo = 1;

if($foo === 1) {
  echo $foo;
}

Example 2:
$foo = "1";

if($foo === 1) {
  echo $foo;
}

Example #1 will display the value of $foo, while Example #2 will not.

The two above samples are almost identical, except for the fact that the value of $foo in Example #2 is encased in quotes, telling it that the variable is a string instead of an integer. The Triple Equals Operator not only compares the values of the variable, but it also compares the type of variable being passed in. This is extremely useful when you have code that will only function against a specific type of variable.

One last thing, and this is veering off topic a little bit, but you can cast the variables in the above statement if your really want to use quotes.

$foo = (int) "1";

if($foo === 1) {
  echo $foo;
}

By placing the (int) in front of the value you are setting, you are casting that variable as a specific type. It’s useful when you want to specifically set a variable as well, but you might have some problems between variable type conversions if you’re always casting every variable.

But that’s a topic for another day, another post. Perhaps the next operator post, we will do some “not” functionality.