CodeIgniter 1.7 Professional Development

The first step to getting started with CodeIgniter is to download the files from the website. The website is located at www.codeigniter.com. This website includes a backlog of all of the previous versions of CodeIgniter, as well as a Subversion Repository (SVN) for the latest version. In our case, we can simply download the latest version straight from the home page—currently 1.7.2— by clicking on the Download CodeIgniter button, as seen in the next screenshot.

When you have downloaded the ZIP file, unzip it using your favourite file archiving program. You will now have a folder named CodeIgniter_1.7.2. The folder should contain two files and two directories, as seen in the next screenshot.

The system directory holds the core CodeIgniter files, libraries, and other CI specific stuff, such as the logs and cache directories. It also houses the application folder—this is the only folder you truly need to worry about, as this is the only place where you need to put your files. As you can guess, this is the folder where all your application-specific code goes, and includes the configuration files that you may need to edit.

Simply open this folder in your code editor of choice and we'll go ahead and install CodeIgniter in our final step. We need to edit the base URL—the URL at which you will you access your application—and to do this we need to open the file /system/application/config/config.php. The value that we need to change is the array item $config['base_url'] which is currently set to http://example.com/—simply change this to your URL.

When that is done, navigate to your base URL and you should see the CodeIgniter welcome screen, as seen in the next screenshot.

CodeIgniter has the ability to set a Controller as the default controller. This is the controller that is to be called when no other controller is passed to index.php. A default CodeIgniter install will set the default controller to welcome_message.php– this is the default CI welcome page, as shown earlier.

To set a different default controller, open the file system/application/config/routes.php and change welcome to the name of any other controller in your application.

$route['default_controller'] = "welcome";

You can remap function calls by using a function in your controller called _remap() —this will be called every time that the controller is called, even if a different function is used. This is useful for developers who wish to easily remap their function calls in order to provide a different Uniform Resource Identifier (URI) structure, or to remap functions instead of extending CodeIgniter's routing class.

The function string will be passed to the function. You would usually have a function that looks like this:

Function _remap($method)
{
  if($method == "method_name")
  {
    $this->$method();
  }
  else
  {
    $this->default_method();
  }
}

A model is loaded from Controller functions. Loading a model takes just one line of code.

$this->load->model('model_name');

In this instance, you should replace model_name with the name of your model. If your model is located in a sub-folder, you would load the model as follows:

$this->load->model('sub_folder/model_name');

Once loaded, you access your model functions by using the global object with the same name as your model name.

$this->model_name->function_name();

You can assign a new name for your Model object by passing it to the second parameter of the loading function.

$this->load->model('model_name', 'different_name');

Now you would call your model functions as follows:

$this->different_name->function_name();

Here's an example of a controller calling a model and serving a view.

<?php
class Shop extends Controller
{
  function Shop()
  {
    parent::Controller();
  }

  function index()
  {
    $this->load->model('products');
    $products = $this->products->build_list();
    $this->load->view('shop', $products);
  }
}
?>

When a model is loaded, it does not connect to the database automatically unless you autoload the database class for your application. You can tell the model to connect to the database automatically by passing boolean TRUE as the third parameter.

$this->load->model('model_name', '', TRUE);

The model will now connect to the database using the setting defined in your database.php configuration file, which is located in system/application/config/.

You can pass an array of configuration details to the third parameter if you wish to use a database other than the one that's set up in your database configuration file.

$config['hostname'] = "localhost";
$config['username'] = "myusername";
$config['password'] = "mypassword";
$config['database'] = "mydatabase";
$config['dbdriver'] = "mysql";
$config['dbprefix'] = "";
$config['pconnect'] = FALSE;
$config['db_debug'] = TRUE;

$this->load->model('model_name', '', $config);

Loading a view is done in the same way as loading a model; it takes just one line of code.

$this->load->view('view_name');

Here, view_name would be the name of the view file that you wish to load. You can also pass an array of data to a view file by passing an array as the second parameter of the load->view function.

$data['title'] = "My Web Page";
$this->load->view('view_name', $data);

You would then be able to use the variable $title in your view file to echo out the page title.

You load multiple views in the same way as you load just one view. CodeIgniter intelligently handles multiple calls to $this->load->view, and will append these calls together. Here is an example:

function index()
{
  $data['title'] = "My Web Page";
  $this->load->view('header', $data);
  $this->load->view('navigation');
  $this->load->view('content');
  $this->load->view('footer');
}

Adding data to a view file is a very simple process, which we have touched upon already. You pass data to a view file by using the second parameter of the load->view function. All view data must be passed as an array or an object. This is because CI runs this array or object through PHP's extract function, which simply takes an object or array key and creates a variable for it with the same name. Let's look at an example:

$data = array(
      'title' => "My Web Page",
      'heading' => "Welcome to my web page",
      'content' => "This is my first web page using Codeigniter!"
      );
$this->load->view('main', $data);

You will then be able to use this data in your view, as illustrated below:

<html>
<head>
  <title><?php echo $title; ?></title>
</head>
<body>
<h1><?php echo $heading; ?></h1>
<?php echo $content; ?>
</body>
</html>

Creating loops in view files has been a stumbling block for a few developers. By passing a multidimensional array to a view file, you can easily establish a loop in any of your view files. Let's take a look at an example.

<?php
  class Todo extends Controller
  {
    function index()
    {
      $data['todo_list'] = array("buy food", "clean up", "mow lawn");
      $this->load->view('todo', $data);
    }
  }
?>

This is a very simple Controller. Your view file for this would be as follows:

<html>
<head>
  <title><?php echo $title; ?></title>
</head>
<body>
<h1><?php echo $heading; ?></h1>
<?php echo $content;?>
<h2>My Todo List</h2>
<?php
foreach($todo_list as $item)
{
  echo $item;
}
?>
</body>
</html>

You are also able to return view files as data; this can be useful if you wish to process this data in some way. Simply set the third parameter to boolean TRUE—and it will return the view data.

$this->load->view('welcome', NULL, TRUE);

CodeIgniter uses an output buffer to take all calls to the load view function, and processes them all at once, sending the whole page to the browser at the same time. So when you return views as data, you will be able to save the contents of the view inside a variable for whatever use you need.

The PHP closing tag ?> is optional to the PHP parser. If used, any whitespace after the PHP closing tag can result in PHP errors, warnings, or even blank pages. For this reason, all PHP files should omit the closing PHP tag, and instead use a comment block to display relevant details for the file location. This allows you to signify that a file is complete.

<?php
  class Helloworld extends Controller
  {
    function index()
    {
      echo("Hello, World!");
    }
  }
?>

<?php
  class Helloworld extends Controller
  {
    function index()
    {
      echo("Hello, World!");
    }
  }

/* End of file helloworld.php */
/* Location: system/application/controllers/ */

As we have touched upon before, class names should always have their first letter in uppercase and the rest of the name in lowercase. Multiple words should be separated with an underscore and not use the CamelCase convention.

class myClass
class MYClass

class My_class

class My_class
{
  function My_class()
  {

  }
}

function fileproperties() // not descriptive and needs underscore separator
function fileProperties() // not descriptive and uses CamelCase
function getfileproperties() // Better! But still missing underscore separator
function getFileProperties() // uses CamelCase
function get_the_file_properties_from_the_file() // wordy

function get_file_properties() // descriptive, underscore separator, and all lowercase letters

The guidelines for variable names are very similar to those for class and method names. Variable names should only contain lowercase letters, should use underscore separators to separate words and not use CamelCasing, and should be named to indicate their contents.

$f = 'foo'; // single letter variable name, does not explicitly show what it contains
$Text // contains uppercase letters
$someTextHere // uses camelCase and does not show it's contents
$userid // multiple words, needs an underscore to separate them

for ($i = 0; $i <= 10; $i++)
$text
$user_id

CodeIgniter recommends that you comment your code as much as possible. This is for two reasons: it helps inexperienced programmers who may be working on the same project as you, or if you release your code; and it will help you months down the line to understand the code more quickly than if there were no comments. There isn't a particular required commenting style, but CodeIgniter recommends that you use DocBlock styling. This is recommended as it will be picked up by many Integrated Development Environments (IDE).

/**
* Class Name
*
* @package Package name
* @subpackage Subpackage Name
* @category category name
* @author Author Name
* @linkhttp://example.com
*/

When commenting your code, you should use singe line comments and leave a line between a large comment block and the code. I would personally recommend that comments mean something.

// a foreach loop

foreach($posts as $post)
{
  echo $post;
}

// loop through the blog posts and echo each out

foreach($posts as $post)
{
  echo $post;
}

When using the keywords TRUE, FALSE, and NULL in your applications, you should always write them in uppercase letters.

if($active == true)
$zero = null;
function test($test = false)

if($active == TRUE)
$zero = NULL;
function test($test = FALSE)

You should always use full PHP opening tags and not short tags, just in case a server does not have short_open_tag enabled. CodeIgniter can rewrite short tags, although the PHP Style Guide states that full opening tags should be used.

<? echo $foo; ?>
<?=$foo?>

<?php echo $foo; ?>

You should always have one statement per line in CodeIgniter applications. This improves code readability, and will also makes things easier to find.

$foo = 'bar'; $bar = 'foo'; $baz = 'zip';

$foo = 'bar';
$bar = 'foo';
$baz = 'zip';

You can remove the index.php part of the URL by adding a .htaccess file to the root of your CodeIgniter install. Here is an example file:

RewriteEngine on
RewriteCond $1 !^(index\.php|images|robots\.txt)
RewriteRule ^(.*)$ /index.php/$1 [L]

This will redirect anything to the index.php file except for index.php, the images folder, and robots.txt. You can add any other items to the list as you so wish, such as a folder for .css files or even JavaScript files.

You can specify in your system/application/config/config.php file to add a suffix to your URLs. Take this example:

http://mywebxite.ext/products/books/

You can add a suffix so that the URL becomes:

http://mywebsite.ext/products/books.html

You don't have to use .html, I just used it as an example.

Helper files are a collection of functions in a particular group. For example, CodeIgniter has a URL helper, which lets you easily print your website URL or the current URL, build links, and a few other functions too. Helpers can be used within Models, Controllers, and View files.

Helpers are not written in an object oriented format in the way that Controllers and Models are, they are simply a collection of procedural functions.

$this->load->helper('form');

$this->load->helper( array('form', 'url', 'cookie') );

<?php echo base_url(); ?>

Plugins work in almost exactly the same way as Helpers. The main difference is that a plugin should be used to add a single function, instead of a collection of functions. Helpers are also considered to be part of the core framework, whereas plugins are intended to be created and shared by the community. Plugins are stored inside the system/application/plugins/ folder.

$this->load->plugin('name');

$this->load->plugin( array('name1', 'name2', 'name3') );

Libraries provide extra functionality that can be used across multiple projects. Libraries usually abstract functions for many different tasks. For example, the Database Library provides a way to create SQL functions in very simple, readable ways. It is advisable to keep Library calls out of your View files, and a helper should be used to perform the operation instead.

$CI =& get_instance();

$this->load->library('name');

<?php
  class MY_Session extends CI_Session
{
    function MY_Session()
    {
      parent::CI_Session();
    }
}
?>

$this->load->library('session');

<?php
  class CI_Session
  {
    
  }
?>

$this->load->library('session');