Let us do | php

Helper Functions in Object Oriented PHP

2013-07-29T23:37:00.000+05:30

A number of functions are available to help the developer manage and use class libraries. These functions (more about functions in PHP) are introduced in this section.

Creating a Class Alias

The class_alias() function creates a class alias, allowing the class (more about classes in PHP) to be referred to by more than one name. Its prototype follows:

boolean class_alias(string originalClassName, string aliasName)

This function was introduced in PHP 5.3.

Determining Whether a Class Exists

The class_exists() function returns TRUE if the class specified by class_name exists within the currently executing script context and returns FALSE otherwise. Its prototype follows:

boolean class_exists(string class_name)

Determining Object Context

The get_class() function returns the name of the class to which object (more about objects in PHP) belongs and returns FALSE if object is not an object. Its prototype follows:

string get_class(object object)

Learning about Class Methods

The get_class_methods() function returns an array containing all method names defined by the class class_name. Its prototype follows:

array get_class_methods(mixed class_name)

Learning about Class Properties

The get_class_vars() function returns an associative (array more about arrays in PHP) containing the names of all properties and their corresponding values defined within the class specified by class_name. Its prototype follows:

array get_class_vars(string class_name)

Learning about Declared Classes

The function get_declared_classes() returns an array containing the names of all classes defined within the currently executing script. The output of this function will vary according to how your PHP distribution is configured (more about configuring PHP). For instance, executing get_declared_classes() on a test server produces a list of 97 classes. Its prototype follows:

array get_declared_classes(void)

Learning about Object Properties

The function get_object_vars() returns an associative array containing the defined properties available to object and their corresponding values. Those properties that don’t possess a value will be assigned NULL within the associative array. Its prototype follows:

array get_object_vars(object object)

Determining an Object’s Parent Class

The get_parent_class() function returns the name of the parent of the class to which object belongs. If object’s class is a base class, that class name will be returned. Its prototype follows:

string get_parent_class(mixed object)

Determining Interface Existence

The interface_exists() function determines whether an interface exists, returning TRUE if it does and FALSE otherwise. Its prototype follows:

boolean interface_exists(string interface_name [, boolean autoload])

Determining Object Type

The is_a() function returns TRUE if object belongs to a class of type class_name or if it belongs to a class that is a child of class_name. If object bears no relation to the class_name type, FALSE is returned. Its prototype follows:

boolean is_a(object object, string class_name)

Oddly, this function was temporarily deprecated from PHP 5.0.0 to PHP 5.3.0, causing an E_STRICT warning to be displayed during this time.

Determining Object Subclass Type

The is_subclass_of() function returns TRUE if object (which can be passed in as type string or object) belongs to a class inherited from class_name and returns FALSE otherwise. Its prototype follows:

boolean is_subclass_of(mixed object, string class_name)

Determining Method Existence

The method_exists() function returns TRUE if a method named method_name is available to object and returns FALSE otherwise. Its prototype follows:

boolean method_exists(object object, string method_name)

Autoloading Objects

For organizational reasons, it’s common practice to place each class in a separate file. Returning to the library scenario, suppose the management application calls for classes representing books, employees, events, and patrons. Tasked with this project, you might create a directory named classes and place the following files in it: Books.class.php, mployees.class.php, Events.class.php, and Patrons.class.php. While this does indeed facilitate class management, it also requires that each separate file be made available to any script requiring it, typically through the require_once() statement. Therefore, a script requiring all four classes would require that the following statements be inserted at the beginning:

require_once("classes/Books.class.php");
require_once("classes/Employees.class.php");
require_once("classes/Events.class.php");
require_once("classes/Patrons.class.php");

Managing class inclusion in this manner can become rather tedious and adds an extra step to the already often complicated development process. To eliminate this additional task, the concept of auto loading objects was introduced in PHP 5. Autoloading allows you to define a special __autoload function that is automatically called whenever a class is referenced that hasn’t yet been defined in the script. You can eliminate the need to manually include each class file by defining the following function:

function __autoload($class) {
require_once("classes/$class.class.php");
}

Defining this function eliminates the need for the require_once() statements because when a class is invoked for the first time, __autoload() will be called, loading the class according to the commands defined in __autoload(). This function can be placed in a global application configuration file, meaning only that function will need to be made available to the script.

More components of Object Oriented PHP <-> Advanced Object Oriented PHP

More components of Object Oriented PHP

2013-07-28T23:16:00.000+05:30

Static Class Members

In the articles on properties and methods in classes in PHP namely:

Defining Class Properties in PHP
Defining Class Methods in PHP

You were made acquainted with the declarations and scope of properties and methods in classes in PHP (more about classes in PHP). But the Static scope of properties and methods was not introduced there to prevent confusion for the newbies. Confusion? Not really! It’s just for the sake of convenience. Now that you are comfortable with class’s components I can introduce Static Scope here.

One of the major benefits to using static properties is that they keep their stored values for the duration of the script.

Sometimes it’s useful to create properties and methods that are not invoked by any particular object but rather are pertinent to and are shared by all class instances.

It is similar to static variables discussed in article: Variables in PHP.

For example, suppose that you are writing a class that tracks the number of web page visitors. You wouldn’t want the visitor count to reset to zero every time the class is instantiated, so you would set the property to be of the static scope:

<?php
class Visitor
{
private static $visitors = 0;
function __construct()
{
self::$visitors++;
}
static function getVisitors()
{
return self::$visitors;
}
}
// Instantiate the Visitor class.
$visits = new Visitor();
echo Visitor::getVisitors()." ";
// Instantiate another Visitor class.
$visits2 = new Visitor();
echo Visitor::getVisitors()." ";
?>

The results are as follows:

1
2

Because the $visitors property was declared as static, any changes made to its value (in this case via the class constructor) are reflected across all instantiated objects. Also note that static properties and methods are referred to using the self keyword and class name, rather than via $this and arrow operators. This is because referring to static properties using the means allowed for their “regular” siblings is not possible and will result in a syntax error if attempted.

Note: You can’t use $this within a class to refer to a property declared as static.

The instanceof Keyword

The instanceof keyword was introduced with PHP 5. With it you can determine whether an object is an instance of a class, is a subclass of a class, or implements a particular interface, and do something accordingly. For example, suppose you want to learn whether $manager is derived from the class Employee:

$manager = new Employee();
...
if ($manager instanceof Employee) echo "Yes";

Note: The class name is not surrounded by any sort of delimiters (quotes). Including them will result in a syntax error.

The instanceof keyword is particularly useful when you’re working with a number of objects simultaneously. For example, you might be repeatedly calling a particular function but want to tweak that function’s behavior in accordance with a given type of object. You might use a case statement and the instanceof keyword to manage behavior in this fashion.

Using Constructors and Destructors in PHP <-> Helper Functions in OOP PHP

Using Constructors and Destructors in PHP

2013-07-27T23:34:00.000+05:30

Often, you’ll want to execute a number of tasks when creating and destroying objects. For example, you might want to immediately assign several properties of a newly instantiated object. However, if you have to do so manually, you’ll almost certainly forget to execute all of the required tasks. Object-oriented programming goes a long way toward removing the possibility for such errors by offering special methods, called constructors and destructors, that automate the object creation and destruction processes.

Constructors

You often want to initialize certain properties and even trigger the execution of methods (more about methods in PHP) found when an object (more about objects in PHP) is newly instantiated. There’s nothing wrong with doing so immediately after instantiation, but it would be easier if this were done for you automatically. Such a mechanism exists in OOP, known as a constructor. Quite simply, a constructor is defined as a block of code that automatically executes at the time of object instantiation. OOP constructors offer a number of advantages:

Constructors can accept parameters, which are assigned to specific object properties at creation time.
Constructors can call class methods or other functions.
Class constructors can call on other constructors, including those from the class parent.

This section reviews how all of these advantages work with PHP 5’s improved constructor functionality.

Note: PHP 4 also offered class constructors, but it used a different, more cumbersome syntax than the one used in version 5. Version 4 constructors were simply class methods of the same name as the class they represented. Such a convention made it tedious to rename a class. The new constructor-naming convention resolves these issues. For reasons of compatibility, however, if a class is found to not contain a constructor satisfying the new naming convention, that class will then be searched for a method bearing the same name as the class; if located, this method is considered the constructor.

PHP recognizes constructors by the name __construct (a double underscore precedes the constructor keyword). The general syntax for constructor declaration follows:

function __construct([argument1, argument2, ..., argumentN])
{
// Class initialization code
}

As an example, suppose you want to immediately populate certain book properties with information specific to a supplied ISBN. For example, you might want to know the title and author of a book, in addition to how many copies the library owns and how many are presently available for loan. The code might look like this:

<?php
class Book
{
private $title;
private $isbn;
private $copies;
function __construct($isbn)
{
$this->setIsbn($isbn);
$this->getTitle();
$this->getNumberCopies();
}
public function setIsbn($isbn)
{
$this->isbn = $isbn;
}
public function getTitle() {
$this->title = "Easy PHP Websites with the Zend Framework";
print "Title: {$this->title} ";
}
public function getNumberCopies() {
$this->copies = "5";
print "Number copies available: {$this->copies} ";
}
}
$book = new book("0615303889");
?>

This results in the following:

Title: Easy PHP Websites with the Zend Framework
Number copies available: 5

Of course, a real-life implementation would likely involve somewhat more intelligent get methods (e.g., methods that query a database), but the point is made. Instantiating the book object results in the automatic invocation of the constructor, which in turn calls the setIsbn(), getTitle(), and getNumberCopies() methods. If you know that such methods should be called whenever a new object is instantiated, you’re far better off automating the calls via the constructor than attempting to manually call them yourself.

Additionally, if you would like to make sure that these methods are called only via the constructor, you should set their scope to private, ensuring that they cannot be directly called by the object or by a subclass.

Invoking Parent Constructors

PHP does not automatically call the parent constructor; you must call it explicitly using the parent keyword. An example follows:

<?php
class Employee
{
protected $name;
protected $title;
function __construct()
{
echo "Employee constructor called!";
}
}
class Manager extends Employee
{
function __construct()
{
parent::__construct();
echo "Manager constructor called!";
}
}
$employee = new Manager();
?>

This results in the following:

Employee constructor called!
Manager constructor called!

Neglecting to include the call to parent::__construct() results in the invocation of only the Manager constructor, like this:

Manager constructor called!

Invoking Unrelated Constructors

You can invoke class constructors that don’t have any relation to the instantiated object simply by prefacing __construct with the class name, like so:

classname::__construct()

As an example, assume that the Manager and Employee classes used in the previous example bear no hierarchical relationship; instead, they are simply two classes located within the same library. The Employee constructor could still be invoked within Manager’s constructor, like this:

Employee::__construct();

Calling the Employee constructor in this manner results in the same outcome shown in the example.

Destructors

Just as you can use constructors to customize the object creation process, so can you use destructors to modify the object destruction process. Destructors are created like any other method but must be titled __destruct(). An example follows:

<?php
class Book
{
private $title;
private $isbn;
private $copies;
function __construct($isbn)
{
echo "Book class instance created.";
}
function __destruct()
{
echo "Book class instance destroyed.";
}
}
$book = new Book("0615303889");
?>

Here’s the result:

Book class instance created.
Book class instance destroyed.

When the script is complete, PHP will destroy any objects that reside in memory. Therefore, if the instantiated class and any information created as a result of the instantiation reside in memory, you’re not required to explicitly declare a destructor. However, if less volatile data is created (say, stored in a database) as a result of the instantiation and should be destroyed at the time of object destruction, you’ll need to create a custom destructor.

Defining Class Methods <-> More components of Object Oriented PHP

Defining Class Methods in PHP

2013-07-26T23:32:00.000+05:30

A method is quite similar to a function, except that it is intended to define the behavior of a particular class (more about classes in PHP). Like a function (more about functions in PHP), a method can accept arguments as input and can return a value to the caller. Methods are also invoked like functions, except that the method is prefaced with the name of the object (more about objects in PHP) invoking the method, like this:

$object->methodName();

In this article you’ll learn all about methods, including method declaration, method invocation, and scope.

Declaring Methods

Methods are created in exactly the same fashion as functions, using identical syntax. The only difference between methods and normal functions is that the method declaration is typically prefaced with a scope descriptor. The generalized syntax follows:

scope function functionName()
{
// Function body goes here
}

For example, a public method titled calculateSalary() might look like this:

public function calculateSalary()
{
return $this->wage * $this->hours;
}

In this example, the method is directly invoking two class properties, wage and hours, using the $this keyword. It calculates a salary by multiplying the two property values together and returns the result just like a function might. Note, however, that a method isn’t confined to working solely with class properties; it’s perfectly valid to pass in arguments in the same way you can with a function.

Tip: In the case of public methods, you can forgo explicitly declaring the scope and just declare the method like you would a function (without any scope).

Invoking Methods

Methods are invoked in almost exactly the same fashion as functions. Continuing with the previous example, the calculateSalary() method would be invoked like so:

$employee = new Employee("Janie");
$salary = $employee->calculateSalary();

Method Scopes

PHP supports six method scopes: public, private, protected, abstract, final, and static. The first five scopes are introduced in this article. The sixth, static, is introduced in the article “More components of Object Oriented PHP”.

Public

Public methods can be accessed from anywhere at any time. You declare a public method by prefacing it with the keyword public or by forgoing any prefacing whatsoever. The following example demonstrates both declaration practices, in addition to demonstrating how public methods can be called from outside the class:

<?php
class Visitors
{
public function greetVisitor()
{
echo "Hello ";
}
function sayGoodbye()
{
echo "Goodbye ";
}
}
Visitors::greetVisitor();
$visitor = new Visitors();
$visitor->sayGoodbye();
?>

The following is the result:

Hello
Goodbye

Private

Methods marked as private are available for use only within the originating class and cannot be called by the instantiated object, nor by any of the originating class’s child classes (more about child classes in OOP model of PHP). Methods solely intended to be helpers for other methods located within the class should be marked as private. For example, consider a method called validateCardNumber() that is used to determine the syntactical validity of a patron’s library card number. Although this method would certainly prove useful for satisfying a number of tasks, such as creating patrons and self-checkout, the function has no use when executed alone. Therefore, validateCardNumber() should be marked as private, like this:

private function validateCardNumber($number)
{
if (! ereg('^([0-9]{4})-([0-9]{3})-([0-9]{2})') ) return FALSE;
else return TRUE;
}

Attempts to call this method directly from an instantiated object result in a fatal error.

Protected

Class methods marked as protected are available only to the originating class and its child classes. Such methods might be used for helping the class or subclass perform internal computations. For example, before retrieving information about a particular staff member, you might want to verify the employee identification number (EIN) passed in as an argument to the class instantiator. You would then verify this EIN for syntactical correctness using the verifyEIN() method. Because this method is intended for use only by other methods within the class and could potentially be useful to classes derived from
Employee, it should be declared as protected:

<?php
class Employee
{
private $ein;
function __construct($ein)
{
if ($this->verifyEIN($ein)) {
echo "EIN verified. Finish";
}
}
protected function verifyEIN($ein)
{
return TRUE;
}
}
$employee = new Employee("123-45-6789");
?>

Attempts to call verifyEIN() from outside of the class or from any child classes will result in a fatal error because of its protected scope status.

Abstract

Abstract methods are special in that they are declared only within a parent class but are implemented in child classes. Only classes declared as abstract can contain abstract methods. You might declare an abstract method if you want to define an application programming interface (API) that can later be used as a model for implementation. A developer would know that his particular implementation of that method should work provided that it meets all requirements as defined by the abstract method. Abstract methods are declared like this:

abstract function methodName();

Suppose that you want to create an abstract Employee class, which would then serve as the base class for a variety of employee types (manager, clerk, cashier, etc.):

abstract class Employee
{
abstract function hire();
abstract function fire();
abstract function promote();
abstract demote();
}

This class could then be extended by the respective employee classes, such as Manager, Clerk, and Cashier.

Final

Marking a method as final prevents it from being overridden by a subclass. A finalized method is declared like this:

class Employee
{
final function getName() {
...
}
}

Attempts to later override a finalized method result in a fatal error.

Type Hinting

Type hinting is a feature introduced with the PHP 5 release. Type hinting ensures that the object being passed to the method is indeed a member of the expected class. For example, it makes sense that only objects of class Employee should be passed to the takeLunchbreak() method. Therefore, you can preface the method definition’s sole input parameter $employee with Employee, enforcing this rule. An example follows:

private function takeLunchbreak(Employee $employee)
{
...
}

Keep in mind that type hinting only works for objects and arrays. You can’t offer hints for types such as integers, floats, or strings.

Defining Class Properties <-> Using Constructors and destructors

Defining Class Properties in PHP :: continued

2013-07-25T23:30:00.000+05:30

Property Overloading

Property overloading continues to protect properties by forcing access and manipulation through public methods, yet allowing the data to be accessed as if it were a public property. These methods, known as accessors and mutators, or more informally as getters and setters, are automatically triggered whenever the property is accessed or manipulated, respectively.

Unfortunately, PHP does not offer property overloading features that you might be used to if you’re familiar with other OOP languages such as C++ and Java. Therefore, you’ll need to make do with using public methods to imitate such functionality. For example, you might create getter and setter methods for the property name by declaring two functions, getName() and setName(), respectively, and embedding the appropriate syntax within each.

PHP version 5 and newer does offer some semblance of support for property overloading, done by overloading the __set and __get methods. These methods are invoked if you attempt to reference a member variable that does not exist within the class definition. Properties can be used for a variety of purposes, such as to invoke an error message, or even to extend the class by actually creating new variables (more about variables in PHP) on the fly. Both __get and __set are introduced in this article.

Setting Properties with the __set() Method

The mutator, or setter method, is responsible for both hiding property assignment implementation and validating class data before assigning it to a class property. Its prototype follows:

boolean __set([string property_name],[mixed value_to_assign])

It takes as input a property name and a corresponding value, returning TRUE if the method is successfully executed and FALSE otherwise. An example follows:

class Employee
{
var $name;
function __set($propName, $propValue)
{
echo "Nonexistent variable: \$$propName!";
}
}
$employee = new Employee ();
$employee->name = "Mario";
$employee->title = "Executive Chef";

This results in the following output:

Nonexistent variable: $title!

You could use this method to actually extend the class with new properties, like this:

class Employee
{
public $name;
function __set($propName, $propValue)
{
$this->$propName = $propValue;
}
}
$employee = new Employee();
$employee->name = "Mario";
$employee->title = "Executive Chef";
echo "Name: ".$employee->name;
echo " ";
echo "Title: ".$employee->title;

This produces the following:

Name: Mario
Title: Executive Chef

Getting Properties with the __get() Method

The accessor, or mutator method, is responsible for encapsulating the code required for retrieving a class variable. Its prototype follows:

boolean __get([string property_name])

It takes as input one parameter, the name of the property whose value you’d like to retrieve. It should return the value TRUE on successful execution and FALSE otherwise. An example follows:

class Employee
{
public $name;
public $city;
protected $wage;
function __get($propName)
{
echo "__get called! ";
$vars = array("name","city");
if (in_array($propName, $vars))
{
return $this->$propName;
} else {
return "No such variable!";
}
}
}
$employee = new Employee();
$employee->name = "Mario";
echo $employee->name." ";
echo $employee->age;

This returns the following:

Mario
__get called!
No such variable!

Creating Custom Getters and Setters

Frankly, although there are some benefits to the __set() and __get() methods, they really aren’t sufficient for managing properties in a complex object-oriented application. Because PHP doesn’t offer support for the creation of properties in the fashion that Java or C# does, you need to implement your own solution. Consider creating two methods for each private property, like so:

<?php
class Employee
{
private $name;
// Getter
public function getName() {
return $this->name;
}
// Setter
public function setName($name) {
$this->name = $name;
}
}
?>

Although such a strategy doesn’t offer the same convenience as using properties, it does encapsulate management and retrieval tasks using a standardized naming convention. Of course, you should add additional validation functionality to the setter; however, this simple example should suffice to drive the point home.

Defining Class Properties <-> Defining Class Methods

Defining Class Properties in PHP

2013-07-24T00:58:00.000+05:30

Properties are attributes that are intended to describe some aspect of a class. They are quite similar to standard PHP variables (more about variables in PHP), except for a few minor differences, which you’ll learn about in this article. You’ll also learn how to declare and invoke properties and how to restrict access using property scopes.

Declaring Properties

The rules regarding property declaration are quite similar to those in place for variable declaration (more about variables declaration in PHP); essentially, there are none. Because PHP is a loosely typed language, properties don’t even necessarily need to be declared; they can simply be created and assigned simultaneously by a class object, although you’ll rarely want to do that.

For introduction to classes and objects in PHP refer to my previous post Key concepts of OOP in PHP

Instead, common practice is to declare properties at the beginning of the class. Optionally, you can assign them initial values at this time. An example follows:

class Employee
{
public $name = "John";
private $wage;
}

In this example, the two properties, name and wage, are prefaced with a scope descriptor (public or private), a common practice when declaring properties. Once declared, each property can be used under the terms accorded to it by the scope descriptor. If you don’t know what role scope plays in class properties, don’t worry, this topic is covered later in this article.

Invoking Properties

Properties are referred to using the -> operator and, unlike variables, are not prefaced with a dollar sign. Furthermore, because a property’s value typically is specific to a given object, it is correlated to that object like this:

$object->property

For example, the Employee class includes the properties name, title, and wage. If you create an object of type Employee, you would refer to its properties like this:

$employee->name
$employee->title
$employee->wage

When you refer to a property from within the class in which it is defined, it is still prefaced with the -> operator, although instead of correlating it to the class name, you use the $this keyword. $this implies that you’re referring to the property residing in the same class in which the property is being accessed or manipulated. Therefore, if you were to create a method for setting the name property in the Employee class, it might look like this:

function setName($name)
{
$this->name = $name;
}

Property Scopes

PHP supports five class property scopes: public, private, protected, final, and static. The first four are introduced in this article, and the static scope is introduced in the article “More about Object Oriented PHP”.

Public

You can declare properties in the public scope by prefacing the property with the keyword public. An example follows:

class Employee
{
public $name;
// Other property and method declarations follow...
}

Public properties can then be accessed and manipulated directly via the corresponding object, like so:

$employee = new Employee();
$employee->name = "Mary Swanson";
$name = $employee->name;
echo "New employee: $name";

Executing this code produces the following:

New employee: Mary Swanson

Although this might seem like a logical means for maintaining class properties, public properties are actually generally considered taboo to OOP, and for good reason. The reason for shunning such an implementation is that such direct access robs the class of a convenient means for enforcing any sort of data validation. For example, nothing would prevent the user from assigning name like so:

$employee->name = "12345";

This is certainly not the kind of input you are expecting. To prevent such occurrences, two solutions are available. One solution involves encapsulating the data within the object, making it available only via a series of interfaces, known as public methods. Data encapsulated in this way is said to be private in scope. The second recommended solution involves the use of properties and is actually quite similar to the first solution, although it is a tad more convenient in most cases.

Private

Private properties are only accessible from within the class in which they are defined. An example follows:

class Employee
{
private $name;
private $telephone;
}

Properties designated as private are not directly accessible by an instantiated object, nor are they available to child classes (more about child classes in OOP model of PHP). If you want to make these properties available to child classes, consider using the protected scope instead, introduced next. Note that private properties must be accessed via publicly exposed interfaces, which satisfies one of OOP’s main tenets: encapsulation. Consider the following example, in which a private property is manipulated by a public method:

class Employee
{
private $name;
public function setName($name) {
$this->name = $name;
}
}
$employee = new Employee;
$employee->setName("Mary");

Encapsulating the management of such properties within a method enables the developer to maintain tight control over how that property is set. For example, you could add to the setName() method’s capabilities to validate that the name is set to solely alphabetical characters and to ensure that it isn’t blank. This strategy is much more reliable than leaving it to the end user to provide valid information.

Protected

Just like functions often require variables intended for use only within the function, classes can include properties used for solely internal purposes. Such properties are deemed protected and are prefaced accordingly. An example follows:

class Employee
{
protected $wage;
}

Protected properties are also made available to inherited classes for access and manipulation, a trait not shared by private properties. Any attempt by an object to access a protected property will result in a fatal error. Therefore, if you plan on extending the class, you should use protected properties in lieu of private properties.

Final

Marking a property as final prevents it from being overridden by a subclass. A finalized property is declared like so:

class Employee
{
final $ssn;
}

Key Concepts of Object Oriented PHP <-> Defining Class Properties :: continued

Key concepts of OOP in PHP

2013-07-23T23:29:00.000+05:30

In the previous post on Benefits of Object-Oriented Programming I focused three of OOP’s foundational concepts: encapsulation, inheritance, and polymorphism. Now it is time to tell you what it really means in the world of PHP.

Classes

Our everyday environment consists of countless entities: plants, people, vehicles, food...I could go on for hours just listing them. Each entity is defined by a particular set of characteristics and behaviors that ultimately serves to define the entity for what it is. For example, a vehicle might be defined as having characteristics such as color, number of tires, make, model, and capacity, and having behaviors such as stop, go, turn, and honk horn.

In the vocabulary of OOP, such an embodiment of an entity’s defining attributes and behaviors is known as a Class. The set of characteristics and behaviors are better known in OOP as properties and methods, respectively

Classes are intended to represent those real-life items that you’d like to manipulate within an application. For example, if you want to create an application for managing a public library, you’d probably want to include classes representing books, magazines, employees, special events, patrons, and anything else that would require oversight. Each of these entities embodies a certain set of characteristics and behaviors, better known in OOP as properties and methods, respectively, that define the entity as what it is. PHP’s generalized class creation syntax follows:

class ClassName
{
// Property declarations defined here
// Method declarations defined here
}

Listing 6-1. Class Creation - a class representing employees

class Employee
{
private $name;
private $title;
protected $wage;
protected function clockIn() {
echo "Member $this->name clocked in at ".date("h:i:s");
}
protected function clockOut() {
echo "Member $this->name clocked out at ".date("h:i:s");
}
}

Titled Employee, this class defines three properties: name, title, and wage, in addition to two methods, clockIn and clockOut. Don’t worry if you’re not familiar with some of the syntax; it will become clear later in the articles that follows.

Note: While no official PHP code conventions exist, consider following the PHP Extension and Application Repository (PEAR) guidelines when creating your classes. You can learn more about these conventions at pear website.

Objects

A class provides a basis from which you can create specific instances of the entity the class models, better known as objects. For example, an employee management application may include an Employee class. You can then call upon this class to create and maintain specific instances, Sally and Jim, for example.

Note: The practice of creating objects based on predefined classes is often referred to as class instantiation.

Objects are created using the new keyword, like this:

$object_name = new class_name()

For Example:

$employee = new Employee();

Once the object is created, all of the characteristics and behaviors defined within the class are made available to the newly instantiated object. Exactly how this is accomplished is revealed in the given articles:-

Classes form the structure of data and actions and use that information to build objects.

Constants

You can define constants, or values that are not intended to change, within a class. These values will remain unchanged throughout the lifetime of any object instantiated from that class. Class constants are created like so:

const NAME = 'VALUE';

For example, suppose you create a math-related class that contains a number of methods defining mathematical functions, in addition to numerous constants:

class mathFunctions
{
const PI = '3.14159265';
const E = '2.7182818284';
const EULER = '0.5772156649';
// Define other constants and methods here...
}

Class constants can then be called like this:

echo mathFunctions::PI;

Benefits of OOP <-> Definining Class Properties

Benefits of Object-Oriented Programming

2013-07-22T23:25:00.000+05:30

Although PHP did not start out as an object-oriented language, over the years a great deal of effort has been put into adding many of the object-oriented features found in other languages. This article and the following aim to introduce these features. Before doing so, let’s consider the advantages of the OOP development model.

Just a thought: If you got any OOP history before PHP this post is going to be a tom’s task for you- very easy. But if you are new to OOP concept and you got confused at any point, don’t get disheartened because as you will proceed to your journey with OOP features of PHP you will realize what I want to say here. Because things can very easily be understood in the field rather than the theory.

The Benefits of OOP

The birth of object-oriented programming represented a major paradigm shift in development strategy, refocusing attention on an application’s data rather than its logic. To put it another way, OOP shifts the focus from a program’s procedural events toward the real-life entities it is intended to model. The result is an application that closely resembles the world around us.

This section examines three of OOP’s foundational concepts: encapsulation, inheritance, and polymorphism. Together, these three ideals form the basis for the most powerful programming model yet devised.

Encapsulation

Programmers enjoy taking things apart and learning how all of the little pieces work together. Although gratifying, attaining such in-depth knowledge of an item’s inner workings isn’t a requirement. For example, millions of people use a computer every day, yet few know how it actually works. The same idea applies to automobiles, microwaves, and any number of other items. We can get away with such ignorance through the use of interfaces. For example, you know that turning the radio dial allows you to change radio stations; never mind the fact that what you’re actually doing is telling the radio to listen to the signal transmitted at a particular frequency, a feat accomplished using a demodulator. Failing to understand this process does not prevent you from using the radio because the interface gracefully hides such details. The practice of separating the user from the true inner workings of an application through well-known interfaces is known as encapsulation.

Object-oriented programming promotes the same notion of hiding the inner workings of the application by publishing well-defined interfaces from which each application component can be accessed. Rather than get bogged down in the gory details, OOP-minded developers design each application component so that it is independent from the others, which not only encourages reuse but also enables the developer to assemble components like a puzzle rather than tightly lash, or couple, them together. These components are known as OBJECTS, and objects are created from a template known as a CLASS, which specifies what sorts of data the object might contain and the behavior one would expect. This strategy offers several advantages:

The developer can change the application implementation without affecting the object user because the user’s only interaction with the object is via its interface.
The potential for user error is reduced because of the control exercised over the user’s interaction with the application.

Inheritance

The many objects constituting our environment can be modeled using a fairly well-defined set of rules. For instance, all employees share a common set of characteristics: name, employee ID, and wage. However, there are many different types of employees: clerks, supervisors, cashiers, and chief executive officers, among others, each of which likely possesses some superset of those characteristics defined by the generic employee definition. In object-oriented terms, these various employee types inherit the general employee definition, including all of the characteristics and behaviors that contribute to this definition. In turn, each of these specific employee types could be inherited by yet another more specific type. For example, the Clerk type might be inherited by a day clerk and a night clerk, each of which inherits all traits specified by both the employee definition and the clerk definition. Building on this idea, you could then later create a Human class, and then make the Employee class a subclass of Human.

The effect would be that the Employee class and all of its derived classes (Clerk, Cashier, Executive, etc.) would immediately inherit all characteristics and behaviors defined by Human.

The object-oriented development methodology places great stock in the concept of inheritance. This strategy promotes code reusability because it assumes that one will be able to use well-designed classes (i.e., classes that are sufficiently abstract to allow for reuse) within numerous applications.

Polymorphism

Polymorphism, a term originating from the Greek language that means “having multiple forms”, defines OOP’s ability to redefine, or morph, a class’s characteristic or behavior depending upon the context in which it is used. Returning to the example, suppose that a behavior titled clockIn was included within the employee definition. For employees of class Clerk, this behavior might involve actually using a time clock to timestamp a card. For other types of employees, Programmer for instance, clocking in might involve signing on to the corporate network. Although both classes derive this behavior from the Employee class, the actual implementation of each is dependent upon the context in which “clocking in” is implemented. This is the power of polymorphism.

These three key OOP concepts (encapsulation, inheritance, and polymorphism) are further introduced as they apply to PHP through the next articles.

Note: While it may be daunting at first, OOP actually provides an easier approach to dealing with data than the procedural programming.

Move on to Key concepts of OOP in PHP

Other Useful Array Functions

2013-07-18T14:46:00.000+05:30

This article introduces a number of array (what is an array) functions (more about functions in php) that perhaps don’t easily fall into one of the prior articles but are nonetheless quite useful.

Returning a Random Set of Keys

The array_rand() function will return a random number of keys found in an array. Its prototype follows:

mixed array_rand(array array [, int num_entries])

If you omit the optional num_entries parameter, only one random value will be returned. You can tweak the number of returned random values by setting num_entries accordingly. An example follows:

$states = array("Ohio" => "Columbus", "Iowa" => "Des Moines",
"Arizona" => "Phoenix");
$randomStates = array_rand($states, 2);
print_r($randomStates);

This returns the following (your output may vary):

Array ( [0] => Arizona [1] => Ohio )

Shuffling Array Elements

The shuffle() function randomly reorders an array. Its prototype follows:

void shuffle(array input_array)

Consider an array containing values representing playing cards:

$cards = array("jh", "js", "jd", "jc", "qh", "qs", "qd", "qc",
"kh", "ks", "kd", "kc", "ah", "as", "ad", "ac");
shuffle($cards);
print_r($positions);

This returns something along the lines of the following (your results will vary because of the shuffle):

Array ( [0] => js [1] => ks [2] => kh [3] => jd
[4] => ad [5] => qd [6] => qc [7] => ah
[8] => kc [9] => qh [10] => kd [11] => as
[12] => ac [13] => jc [14] => jh [15] => qs )

Adding Array Values

The array_sum() function adds all the values of input_array together, returning the final sum. Its prototype follows:

mixed array_sum(array array)

If other data types (a string, for example) are found in the array, they will be ignored. An example follows:

<?php
$grades = array(42, "hello", 42);
$total = array_sum($grades);
print $total;
?>

This returns the following:

Subdividing an Array

The array_chunk() function breaks input_array into a multidimensional array that includes several smaller arrays consisting of size elements. Its prototype follows:

array array_chunk(array array, int size [, boolean preserve_keys])

If the input_array can’t be evenly divided by size, the last array will consist of fewer than size elements. Enabling the optional parameter preserve_keys will preserve each value’s corresponding key. Omitting or disabling this parameter results in numerical indexing starting from zero for each array. An example follows:

$cards = array("jh", "js", "jd", "jc", "qh", "qs", "qd", "qc",
"kh", "ks", "kd", "kc", "ah", "as", "ad", "ac");
// shuffle the cards
shuffle($cards);
// Use array_chunk() to divide the cards into four equal "hands"
$hands = array_chunk($cards, 4);
print_r($hands);

This returns the following (your results will vary because of the shuffle):

Array ( [0] => Array ( [0] => jc [1] => ks [2] => js [3] => qd )
[1] => Array ( [0] => kh [1] => qh [2] => jd [3] => kd )
[2] => Array ( [0] => jh [1] => kc [2] => ac [3] => as )
[3] => Array ( [0] => ad [1] => ah [2] => qc [3] => qs ) )

Splicing and Dissectiong Arrays

Splicing and Dissecting Arrays

2013-07-17T14:12:00.000+05:30

Splicing an Array

The array_splice() function removes all elements of an array (what is an array) found within a specified range, returning those removed elements in the form of an array. Its prototype follows:

array array_splice(array array, int offset [, int length [, array replacement]])

A positive offset value will cause the splice to begin that many positions from the beginning of the array, while a negative offset will start the splice that many positions from the end of the array. If the optional length parameter is omitted, all elements from the offset position to the conclusion of the array will be removed. If length is provided and is positive, the splice will end at offset + length position from the beginning of the array. Conversely, if length is provided and is negative, the splice will end at count(input_array) – length position from the end of the array. An example follows:

$states = array("Alabama", "Alaska", "Arizona", "Arkansas",
"California", "Connecticut");
$subset = array_splice($states, 4);
print_r($states);
print_r($subset);

This produces the following (formatted for readability):

Array ( [0] => Alabama [1] => Alaska [2] => Arizona [3] => Arkansas )
Array ( [0] => California [1] => Connecticut )

You can use the optional parameter replacement to specify an array that will replace the target segment. An example follows:

$states = array("Alabama", "Alaska", "Arizona", "Arkansas",
"California", "Connecticut");
$subset = array_splice($states, 2, -1, array("New York", "Florida"));
print_r($states);

This returns the following:

Array ( [0] => Alabama [1] => Alaska [2] => New York
[3] => Florida [4] => Connecticut )

Calculating an Array Intersection

The array_intersect() function returns a key-preserved array consisting only of those values present in the first array that are also present in each of the other input arrays. Its prototype follows:

array array_intersect(array array1, array array2 [, arrayN])

The following example will return all states found in the $array1 that also appear in $array2 and $array3:

$array1 = array("OH", "CA", "NY", "HI", "CT");
$array2 = array("OH", "CA", "HI", "NY", "IA");
$array3 = array("TX", "MD", "NE", "OH", "HI");
$intersection = array_intersect($array1, $array2, $array3);
print_r($intersection);

This returns the following:

Array ( [0] => OH [3] => HI )

Note: array_intersect() considers two items to be equal only if they also share the same data type.

Note: Introduced in PHP 5.1.0, the array_intersect_key() function will return keys located in an array that are located in any of the other provided arrays. The function’s prototype is identical to array_intersect(). Likewise, the array_intersect_ukey() function allows you to compare the keys of multiple arrays with the comparison algorithm determined by a user-defined function. Consult the PHP manual for more information.

Calculating Associative Array Intersections

The function array_intersect_assoc() operates identically to array_intersect(), except that it also considers array keys in the comparison. Therefore, only key/value pairs located in the first array that are also found in all other input arrays will be returned in the resulting array. Its prototype follows:

array array_intersect_assoc(array array1, array array2 [, arrayN])

The following example returns an array consisting of all key/value pairs found in $array1 that also appear in $array2 and $array3:

$array1 = array("OH" => "Ohio", "CA" => "California", "HI" => "Hawaii");
$array2 = array("50" => "Hawaii", "CA" => "California", "OH" => "Ohio");
$array3 = array("TX" => "Texas", "MD" => "Maryland", "OH" => "Ohio");
$intersection = array_intersect_assoc($array1, $array2, $array3);
print_r($intersection);

This returns the following:

Array ( [OH] => Ohio )

Note: Hawaii was not returned because the corresponding key in $array2 is 50 rather than HI (as is the case in the other two arrays).

Calculating Array Differences

Essentially the opposite of array_intersect(), the function array_diff() returns those values located in the first array that are not located in any of the subsequent arrays:

array array_diff(array array1, array array2 [, arrayN])

An example follows:

$array1 = array("OH", "CA", "NY", "HI", "CT");
$array2 = array("OH", "CA", "HI", "NY", "IA");
$array3 = array("TX", "MD", "NE", "OH", "HI");
$diff = array_diff($array1, $array2, $array3);
print_r($intersection);

This returns the following:

Array ( [0] => CT )

If you’d like to compare array values using a user-defined function (more about functions in php) , check out the array_udiff() function, introduced in PHP 5.0.2.

Note: Introduced in PHP 5.1.0, the array_diff_key() function will return keys located in an array that are not located in any of the other provided arrays. The function’s prototype is identical to array_diff(). Likewise, the array_diff_ukey() function allows you to compare the keys of multiple arrays with the comparison algorithm determined by a user-defined function. Consult the PHP manual for more information.

Calculating Associative Array Differences

The function array_diff_assoc() operates identically to array_diff(), except that it also considers array keys in the comparison. Therefore, only key/value pairs located in the first array but not appearing in any of the other input arrays will be returned in the result array. Its prototype follows:

array array_diff_assoc(array array1, array array2 [, array arrayN])

The following example only returns "HI" => "Hawaii" because this particular key/value appears in $array1 but doesn’t appear in $array2 or $array3:

$array1 = array("OH" => "Ohio", "CA" => "California", "HI" => "Hawaii");
$array2 = array("50" => "Hawaii", "CA" => "California", "OH" => "Ohio");
$array3 = array("TX" => "Texas", "MD" => "Maryland", "KS" => "Kansas");
$diff = array_diff_assoc($array1, $array2, $array3);
print_r($diff);

This returns the following:

Array ( [HI] => Hawaii )

Note: Introduced in PHP 5.0, the array_udiff_assoc(), array_udiff_uassoc(), and array_diff_uassoc() functions are all capable of comparing the differences of arrays in a variety of manners using user-defined functions. Consult the PHP manual for more information.

Merging and Slicing Arrays <-> Other Array Functions

Usefull Links

2013-07-16T00:29:00.000+05:30

Here are some usefull links, you might need. Keep it handy.

Official Sites

Documentation

http://www.php.net/docs.php

PHP Portals and Communities

http://www.phpbuilder.com/
http://www.phpfreaks.com/
http://www.phpkitchen.com/
http://php.nilostep.com/ PHP Class Libraries and Application Frameworks
http://www.zend.com/
http://www.weberdev.com/
http://www.phpcomplete.com/
http://codewalkers.com/
http://www.phpwelt.de/ (german)
http://www.dynamic-webpages.de/ (german)
http://www.isernese.de/ (german)
http://www.php-homepage.de/ (german)
http://www.php-resource.de/ (german)
http://www.phpindex.com/ (french)
http://www.php-corner.com/

PHP News and Blogs

http://www.zend.com/zend/week/ PHP Weekly Summary
http://phplens.com/phpeverywhere/ PHP Everywhere by John Lim
http://www.blueshoes.org/en/blog/ PHP Blog by Fabian Kessler
http://www.sitepoint.com/blogs/category/php/ Sitepoint PHP Blog by various writers
http://www.procata.com/blog/ PHP Advocacy and Best Practices
http://shiflett.org/ PHP Blog by Chris Shiflett
http://blogs.phparch.com/mt/ Marco Tabini's Weblog
http://www.php.net/

Forums

http://forums.devnetwork.net/

PHP Tutorials and Articles

PHP Code Archives

Editors and IDE's

http://www.waterproof.fr/ PHPEdit
http://www.zend.com/store/products/zend-studio/index.php Zend Studio
http://www.maguma.com/
http://www.eclipse.org/

PHP Help and FAQs

PHP Magazines

PHP Setup Tools for Linux

PHP Setup Tools for Windows

PHP Accelerators (Code Cache)

PHP Encoder

PHP Debugger

http://apd.communityconnect.com/ APD (Advanced PHP Debugger)
http://pear.php.net/apd/ PEAR website of APD
http://www.php.net/apd PHP Documentation of APD
http://www.wiki.cc/php/Apd Wiki for APD
http://www.linuxjournal.com/article/7213 Article about PHP Performance Profiling
http://www.schlossnagle.org/~george/talks/Profiling-phpworks-2004.pdf Another article (PDF) by George Schlossnagle
http://dd.cron.ru/dbg/ dbg
http://www.xdebug.org/ Xdebug
http://pear.php.net/package/benchmark/redirected Benchmark (in PECL)

PHP Directories

PHP Mailing Lists

PHP User Groups

Misc

Resource: www.blueshoes.org

Merging And Slicing Arrays

2013-07-12T21:36:00.000+05:30

This section introduces a number of functions (more about functions in PHP) that are capable of performing somewhat more complex array-manipulation (what is an array) tasks, such as combining and merging multiple arrays, extracting a cross-section of array elements, and comparing arrays.

Merging Arrays

The array_merge() function merges arrays together, returning a single, unified array. The resulting array will begin with the first input array parameter, appending each subsequent array parameter in the order of appearance. Its prototype follows:

array array_merge(array array1, array array2 [, array arrayN])

If an input array contains a string (what is a string) key that already exists in the resulting array, that key/value pair will overwrite the previously existing entry. This behavior does not hold true for numerical keys, in which case the key/value pair will be appended to the array. An example follows:

$face = array("J", "Q", "K", "A");
$numbered = array("2", "3", "4", "5", "6", "7", "8", "9");
$cards = array_merge($face, $numbered);
shuffle($cards);
print_r($cards);

This returns something along the lines of the following (your results will vary because of the shuffle):

Array ( [0] => 8 [1] => 6 [2] => K [3] => Q [4] => 9 [5] => 5
[6] => 3 [7] => 2 [8] => 7 [9] => 4 [10] => A [11] => J )

Recursively Appending Arrays

The array_merge_recursive() function operates identically to array_merge(), joining two or more arrays together to form a single, unified array. The difference between the two functions lies in the way that this function behaves when a string key located in one of the input arrays already exists within the resulting array.

Note: array_merge() will simply overwrite the preexisting key/value pair, replacing it with the one found in the current input array, while array_merge_recursive() will instead merge the values together, forming a new array with the preexisting key as its name.

Its prototype follows:

array array_merge_recursive(array array1, array array2 [, array arrayN])

An example follows:

$class1 = array("John" => 100, "James" => 85);
$class2 = array("Micky" => 78, "John" => 45);
$classScores = array_merge_recursive($class1, $class2);
print_r($classScores);

This returns the following:

Array ( [John] => Array ( [0] => 100 [1] => 45 ) [James] => 85 [Micky] => 78 )

Note that the key John now points to a numerically indexed array consisting of two scores.

Combining Two Arrays

The array_combine() function produces a new array consisting of a submitted set of keys and corresponding values. Its prototype follows:

array array_combine(array keys, array values)

Both input arrays must be of equal size, and neither can be empty. An example follows:

$abbreviations = array("AL", "AK", "AZ", "AR");
$states = array("Alabama", "Alaska", "Arizona", "Arkansas");
$stateMap = array_combine($abbreviations,$states);
print_r($stateMap);

This returns the following:

Array ( [AL] => Alabama [AK] => Alaska [AZ] => Arizona [AR] => Arkansas )

Slicing an Array

The array_slice() function returns a section of an array based on a starting and ending offset value. Its prototype follows:

array array_slice(array array, int offset [, int length [, boolean preserve_keys]])

A positive offset value will cause the slice to begin offset positions from the beginning of the array, while a negative offset value will start the slice offset positions from the end of the array. If the optional length parameter is omitted, the slice will start at offset and end at the last element of the array. If length is provided and is positive, it will end at offset + length position from the beginning of the array. Conversely, if length is provided and is negative, it will end at count(input_array) – length position from the end of the array.

Consider an example:

$states = array("Alabama", "Alaska", "Arizona", "Arkansas",
"California", "Colorado", "Connecticut");
$subset = array_slice($states, 4);
print_r($subset);

This returns the following:

Array ( [0] => California [1] => Colorado [2] => Connecticut )

Consider a second example, this one involving a negative length:

$states = array("Alabama", "Alaska", "Arizona", "Arkansas",
"California", "Colorado", "Connecticut");
$subset = array_slice($states, 2, -2);
print_r($subset);

This returns the following:

Array ( [0] => Arizona [1] => Arkansas [2] => California )

Setting the optional preserve_keys parameter (introduced in PHP 5.0.2) to true will cause the array values’ keys to be preserved in the returned array.

Sorting Arrays <-> Splicing and Dissecting Arrays

Sorting Arrays :: continued

2013-07-11T21:32:00.000+05:30

Sorting an Array Naturally

The natsort() function is intended to offer a sorting mechanism comparable to the mechanisms that people normally use. Its prototype follows:

void natsort(array array)

The PHP manual offers an excellent example, shown here, of what it means to sort an array “naturally.” Consider the following items:

picture1.jpg, picture2.jpg, picture10.jpg, picture20.jpg.

Sorting these items using typical algorithms results in the following ordering:

picture1.jpg, picture10.jpg, picture2.jpg, picture20.jpg

Certainly not what you might have expected, right? The natsort() function resolves this dilemma, sorting the array in the order you would expect, like so:

picture1.jpg, picture2.jpg, picture10.jpg, picture20.jpg

Case-Insensitive Natural Sorting

The function natcasesort() is functionally identical to natsort(), except that it is case insensitive:

void natcasesort(array array)

Returning to the file-sorting dilemma raised in the natsort() section, suppose that the pictures are named like this:

Picture1.JPG, picture2.jpg, PICTURE10.jpg, picture20.jpg

The natsort() function would do its best, sorting these items like so:

PICTURE10.jpg, Picture1.JPG, picture2.jpg, picture20.jpg

The natcasesort() function resolves this idiosyncrasy, sorting as you might expect:

Picture1.jpg, PICTURE10.jpg, picture2.jpg, picture20.jpg

Sorting an Array by Key Values

The ksort() function sorts an array by its keys, returning TRUE on success and FALSE otherwise. Its prototype follows:

integer ksort(array array [, int sort_flags])

If the optional sort_flags parameter is included, the exact sorting behavior is determined by its value, as described in the sort() section. Keep in mind that the behavior will be applied to key sorting but not to value sorting.

Sorting Array Keys in Reverse Order

The krsort() function operates identically to ksort(), sorting by key, except that it sorts in reverse (descending) order. Its prototype follows:

integer krsort(array array [, int sort_flags])

Sorting According to User-Defined Criteria

The usort() function offers a means for sorting an array by using a user-defined comparison algorithm, embodied within a function. This is useful when you need to sort data in a fashion not offered by one of PHP’s built-in sorting functions. Its prototype follows:

void usort(array array, callback function_name)

The user-defined function must take as input two arguments and must return a negative integer, zero, or a positive integer, respectively, based on whether the first argument is less than, equal to, or greater than the second argument. Not surprisingly, this function must be made available to the same scope in which usort() is being called.
A particularly applicable example of where usort() comes in handy involves the ordering of American-format dates (month, day, year, as opposed to day, month, year used by most other countries). Suppose that you want to sort an array of dates in ascending order. While you might think the sort() or natsort() functions are suitable for the job, as it turns out, both produce undesirable results.

The only recourse is to create a custom function capable of sorting these dates in the correct ordering:

<?php
$dates = array('10-10-2011', '2-17-2010', '2-16-2011',
'1-01-2013', '10-10-2012');
sort($dates);
echo "Sorting the array using the sort() function:";
print_r($dates);
natsort($dates);
echo "Sorting the array using the natsort() function: ";
print_r($dates);
function DateSort($a, $b) {
// If the dates are equal, do nothing.
if($a == $b) return 0;
// Disassemble dates
list($amonth, $aday, $ayear) = explode('-',$a);
list($bmonth, $bday, $byear) = explode('-',$b);
// Pad the month with a leading zero if leading number not present
$amonth = str_pad($amonth, 2, "0", STR_PAD_LEFT);
$bmonth = str_pad($bmonth, 2, "0", STR_PAD_LEFT);
// Pad the day with a leading zero if leading number not present
$aday = str_pad($aday, 2, "0", STR_PAD_LEFT);
$bday = str_pad($bday, 2, "0", STR_PAD_LEFT);
// Reassemble dates
$a = $ayear . $amonth . $aday;
$b = $byear . $bmonth . $bday;
// Determine whether date $a > $date b
return ($a > $b) ? 1 : -1;
}
usort($dates, 'DateSort');
echo "Sorting the array using the user-defined DateSort() function: ";
print_r($dates);
?>

This returns the following (formatted for readability):

Sorting the array using the sort() function:
Array ( [0] => 1-01-2013 [1] => 10-10-2011 [2] => 10-10-2012
[3] => 2-16-2011 [4] => 2-17-2010 )

Sorting the array using the natsort() function:
Array ( [0] => 1-01-2013 [3] => 2-16-2011 [4] => 2-17-2010
[1] => 10-10-2011 [2] => 10-10-2012 )

Sorting the array using the user-defined DateSort() function:
Array ( [0] => 2-17-2010 [1] => 2-16-2011 [2] => 10-10-2011
[3] => 10-10-2012 [4] => 1-01-2013 )

Sorting Arrays <-> Merging and Slicing Arrays

Sorting Arrays

2013-07-10T21:26:00.000+05:30

To be sure, data sorting is a central topic of computer science. Anybody who’s taken an entry-level programming class is well aware of sorting algorithms such as bubble, heap, shell, and quick. This subject rears its head so often during daily programming tasks that the process of sorting data is as common as creating an if conditional or a while loop. PHP facilitates the process by offering a multitude of useful functions capable of sorting arrays (what is an array) in a variety of manners.

Note: By default, PHP’s sorting functions sort in accordance with the rules as specified by the English language. If you need to sort in another language, say French or German, you’ll need to modify this default behavior by setting your locale using the setlocale() function.

Reversing Array Element Order

The array_reverse() function reverses an array’s element order. Its prototype follows:

array array_reverse(array array [, boolean preserve_keys])

If the optional preserve_keys parameter is set to TRUE, the key mappings are maintained. Otherwise, each newly rearranged value will assume the key of the value previously presiding at that position:

$states = array("Delaware", "Pennsylvania", "New Jersey");
print_r(array_reverse($states));
// Array ( [0] => New Jersey [1] => Pennsylvania [2] => Delaware )

Contrast this behavior with that resulting from enabling preserve_keys:

$states = array("Delaware", "Pennsylvania", "New Jersey");
print_r(array_reverse($states,1));
// Array ( [2] => New Jersey [1] => Pennsylvania [0] => Delaware )

Arrays with associative keys are not affected by preserve_keys; key mappings are always preserved in this case.

Flipping Array Keys and Values

The array_flip() function reverses the roles of the keys and their corresponding values in an array. Its prototype follows:

array array_flip(array array)

An example follows:

$state = array("Delaware", "Pennsylvania", "New Jersey");
$state = array_flip($state);
print_r($state);

This example returns the following:

Array ( [Delaware] => 0 [Pennsylvania] => 1 [New Jersey] => 2 )

Sorting an Array

The sort() function sorts an array, ordering elements from lowest to highest value. Its prototype follows:

void sort(array array [, int sort_flags])

The sort() function doesn’t return the sorted array. Instead, it sorts the array “in place,” returning nothing, regardless of outcome. The optional sort_flags parameter modifies the function’s default behavior in accordance with its assigned value:

SORT_NUMERIC: Sorts items numerically. This is useful when sorting integers or floats.
SORT_REGULAR: Sorts items by their ASCII value. This means that B will come before a, for instance.
SORT_STRING: Sorts items in a fashion that better corresponds with how a human might perceive the correct order. See natsort() for more information about this matter, introduced later in this section.

Consider an example. Suppose you want to sort exam grades from lowest to highest:

$grades = array(42, 98, 100, 100, 43, 12);
sort($grades);
print_r($grades);

The outcome looks like this:

Array ( [0] => 12 [1] => 42 [2] => 43 [3] => 98 [4] => 100 [5] => 100 )

It’s important to note that key/value associations are not maintained. Consider the following example:

$states = array("OH" => "Ohio", "CA" => "California", "MD" => "Maryland");
sort($states);
print_r($states);

Here’s the output:

Array ( [0] => California [1] => Maryland [2] => Ohio )

To maintain these associations, use asort().

Sorting an Array While Maintaining Key/Value Pairs

The asort() function is identical to sort(), sorting an array in ascending order, except that the key/value correspondence is maintained. Its prototype follows:

void asort(array array [, integer sort_flags])

Consider an array that contains the states in the order in which they joined the Union:

$state[0] = "Delaware";
$state[1] = "Pennsylvania";
$state[2] = "New Jersey";

Sorting this array using sort() produces the following ordering (note that the associative correlation are lost, which is probably a bad idea):

Array ( [0] => Delaware [1] => New Jersey [2] => Pennsylvania )

However, sorting with asort() produces the following:

Array ( [0] => Delaware [2] => New Jersey [1] => Pennsylvania )

If you use the optional sort_flags parameter, the exact sorting behavior is determined by its value, as described in the sort() section.

Sorting an Array in Reverse Order

The rsort() function is identical to sort(), except that it sorts array items in reverse (descending) order. Its prototype follows:

void rsort(array array [, int sort_flags])

An example follows:

$states = array("Ohio", "Florida", "Massachusetts", "Montana");
rsort($states);
print_r($states);

It returns the following:

Array ( [0] => Ohio [1] => Montana [2] => Massachusetts [3] => Florida )

If the optional sort_flags parameter is included, the exact sorting behavior is determined by its value, as explained in the sort() section.

Sorting an Array in Reverse Order While Maintaining Key/Value Pairs

Like asort(), arsort() maintains key/value correlation. However, it sorts the array in reverse order. Its prototype follows:

void arsort(array array [, int sort_flags])

An example follows:

$states = array("Delaware", "Pennsylvania", "New Jersey");
arsort($states);
print_r($states);

It returns the following:

Array ( [1] => Pennsylvania [2] => New Jersey [0] => Delaware )

If the optional sort_flags parameter is included, the exact sorting behavior is determined by its value, as described in the sort() section.

Determining Array Size and Uniqueness <-> Sorting Arrays :: continued

Determining Array Size and Uniqueness

2013-07-09T21:14:00.000+05:30

A few functions (more about functions in PHP) are available in PHP for determining the number of total and unique array (what is an array) values. These functions are introduced in this section.

Determining the Size of an Array

The count() function returns the total number of values found in an array. Its prototype is as follows:

integer count(array array [, int mode])

If the optional mode parameter is enabled ( or you can say- set to 1), the array will be counted recursively, a feature useful when counting all the elements of a multidimensional array. The first example counts the total number of vegetables found in the $garden array:

$garden = array("cabbage", "peppers", "turnips", "carrots");
echo count($garden);

This returns the following:

The next example counts both the scalar values and array values found in $locations identifier:

$locations = array("Italy", "Amsterdam", array("Boston","Des Moines"), "Miami");
echo count($locations, 1);

This returns the following:

You may be scratching your head at this outcome because there appears to be only five elements in the array. It’s because the array entity holding Boston and Des Moines is counted as an item, just as its contents are.

Note: The sizeof() function is an alias of count(). It is functionally identical.

Counting Array Value Frequency

The array_count_values() function returns an array consisting of associative key/value pairs. Its prototype follows:

array array_count_values(array array)

Each key represents a value found in the input_array, and its corresponding value denotes the frequency of that key’s appearance (as a value) in the input_array. An example follows:

$states = array("Ohio", "Iowa", "Arizona", "Iowa", "Ohio");
$stateFrequency = array_count_values($states);
print_r($stateFrequency);

This returns the following:

Array ( [Ohio] => 2 [Iowa] => 2 [Arizona] => 1 )

Determining Unique Array Values

The array_unique() function removes all duplicate values found in an array, returning an array (more about arrays in PHP) consisting of solely unique values. Its prototype follows:

array array_unique(array array [, int sort_flags = SORT_STRING])

An example follows:

$states = array("Ohio", "Iowa", "Arizona", "Iowa", "Ohio");
$uniqueStates = array_unique($states);
print_r($uniqueStates);

This returns the following:

Array ( [0] => Ohio [1] => Iowa [2] => Arizona )

The optional sort_flags parameter (added in PHP 5.2.9) determines how the array values are sorted. By default, they will be sorted as strings (what is string data type); however, you also have the option of sorting them numerically (SORT_NUMERIC), using PHP’s default sorting methodology (SORT_REGULAR), or according to a locale (SORT_LOCALE_STRING).

Traversing Arrays <-> Sorting Arrays

Traversing Arrays

2013-07-08T21:01:00.000+05:30

The need to travel across an array (what is an array) and retrieve various keys, values, or both is common, so it’s not a surprise that PHP offers numerous functions suited to this need. Many of these functions do double duty: retrieving the key or value residing at the current pointer location, and moving the pointer to the next appropriate location. These functions are introduced here.

Retrieving the Current Array Key

The key() functions (more about functions in PHP) returns the key located at the current pointer position of the provided array. Its prototype follows:

mixed key(array array)

The following example will output the $capitals array keys by iterating over the array and moving the pointer:

$capitals = array("Ohio" => "Columbus", "Iowa" => "Des Moines");
echo "Can you name the capitals of these states?";
while($key = key($capitals)) {
printf("%s ", $key);
next($capitals);
}

This returns the following:

Can you name the capitals of these states?
Ohio
Iowa

Note: key() does not advance the pointer with each call. Rather, you use the next() function, whose sole purpose is to accomplish this task. This function is introduced later in this section.

Retrieving the Current Array Value

The current() function returns the array value residing at the current pointer position of the array. Its prototype follows:

mixed current(array array)

Let’s revise the previous example, this time retrieving the array values:

$capitals = array("Ohio" => "Columbus", "Iowa" => "Des Moines");
echo "Can you name the states belonging to these capitals?";
while($capital = current($capitals)) {
printf("%s ", $capital);
next($capitals);
}

The output follows:

Can you name the states belonging to these capitals?
Columbus
Des Moines

Retrieving the Current Array Key and Value

The each() function returns the current key/value pair from the array and advances the pointer one position. Its prototype follows:

array each(array array)

The returned array consists of four keys, with keys 0 and key containing the key name, and keys 1 and value containing the corresponding data. If the pointer is residing at the end of the array before executing each(), FALSE is returned.

Moving the Array Pointer

Several functions are available for moving the array pointer. These functions are introduced in this section.

Moving the Pointer to the Next Array Position

The next() function returns the array value residing at the position immediately following that of the current array pointer. Its prototype follows:

mixed next(array array)

An example follows:

$fruits = array("apple", "orange", "banana");
$fruit = next($fruits); // returns "orange"
$fruit = next($fruits); // returns "banana"

Moving the Pointer to the Previous Array Position

The prev() function returns the array value residing at the location preceding the current pointer location, or FALSE if the pointer resides at the first position in the array. Its prototype follows:

mixed prev(array array)

Because prev() works in exactly the same fashion as next(), no example is necessary.

Moving the Pointer to the First Array Position

The reset() function serves to set an array pointer back to the beginning of the array. Its prototype follows:

mixed reset(array array)

This function is commonly used when you need to review or manipulate an array multiple times within a script, or when sorting has completed.

Moving the Pointer to the Last Array Position

The end() function moves the pointer to the last position of an array, returning the last element. Its prototype follows:

mixed end(array array)

The following example demonstrates retrieving the first and last array values:

$fruits = array("apple", "orange", "banana");
$fruit = current($fruits); // returns "apple"
$fruit = end($fruits); // returns "banana"

Passing Array Values to a Function

The array_walk() function will pass each element of an array to the user-defined function. This is useful when you need to perform a particular action based on each array element. If you intend to actually modify the array key/value pairs, you’ll need to pass each key/value to the function as a reference. Its prototype follows:

boolean array_walk(array &array, callback function [, mixed userdata])

The user-defined function must take two parameters as input. The first represents the array’s current value, and the second represents the current key. If the optional userdata parameter is present in the call to array_walk(), its value will be passed as a third parameter to the user-defined function.
You are probably scratching your head, wondering how this function could possibly be of any use. Perhaps one of the most effective examples involves the sanity-checking of user-supplied form data. Suppose the user is asked to provide six keywords that he thinks best describe the state in which he lives. A sample form is provided in Listing 5-1.

Listing 5-1. Using an Array in a Form

<form action="submitdata.php" method="post">

Provide up to six keywords that you believe best describe the state in
which you live:

Keyword 1: 
<input type="text" name="keyword[]" size="20" maxlength="20" value="" />
Keyword 2: 
<input type="text" name="keyword[]" size="20" maxlength="20" value="" />
Keyword 3: 
<input type="text" name="keyword[]" size="20" maxlength="20" value="" />
Keyword 4: 
<input type="text" name="keyword[]" size="20" maxlength="20" value="" />
Keyword 5: 
<input type="text" name="keyword[]" size="20" maxlength="20" value="" />
Keyword 6: 
<input type="text" name="keyword[]" size="20" maxlength="20" value="" />
<input type="submit" value="Submit!">
</form>

This form information is then sent to some script, referred to as submitdata.php in the form. This script should sanitize user data and then insert it into a database for later review. Using array_walk(), you can easily filter the keywords using a predefined function:

<?php
function sanitize_data(&$value, $key) {
$value = strip_tags($value);
}
array_walk($_POST['keyword'],"sanitize_data");
?>

The result is that each value in the array is run through the strip_tags() function, which results in any HTML and PHP tags being deleted from the value. Of course, additional input checking would be necessary, but this should suffice to illustrate the utility of array_walk().

If you’re working with arrays of arrays, the array_walk_recursive() function (introduced in PHP 5.0) is capable to recursively apply a user-defined function to every element in an array.

Locating Array Elements <-> Determining Array Size and Uniqueness

Locating array elements

2013-07-06T00:41:00.000+05:30

The ability to efficiently sift through data is absolutely crucial in today’s information-driven society. This article introduces several functions that enable you to search arrays(what is an array?) in order to locate items of interest.

Searching an Array

The in_array() function searches an array for a specific value, returning TRUE if the value is found and FALSE otherwise. Its prototype follows:

boolean in_array(mixed needle, array haystack [, boolean strict])

Note:- If the needle is a string, then, comparison is case sensitive.

In the following example, a message is output if a specified state (Ohio) is found in an array consisting of states having statewide smoking bans:

$state = "Ohio";
$states = array("California", "Hawaii", "Ohio", "New York");
if(in_array($state, $states)) echo "Not to worry, $state is smoke-free!";

The optional third parameter, strict, forces in_array() to also consider type.

<?php
$a = array('1.10', 12.4, 1.13);
if (in_array('12.4', $a, true)) {
echo "'12.4' found with strict check\n";
}
if (in_array(1.13, $a, true)) {
echo "1.13 found with strict check\n";
}
?>

The above example will output:

1.13 found with strict check

Searching Associative Array Keys

The function array_key_exists() returns TRUE if a specified key is found in an array and FALSE otherwise. Its prototype follows:

boolean array_key_exists(mixed key, array array)

The following example will search an array’s keys for Ohio, and if found, will output information about its entrance into the Union:

$state["Delaware"] = "December 7, 1787";
$state["Pennsylvania"] = "December 12, 1787";
$state["Ohio"] = "March 1, 1803";
if (array_key_exists("Ohio", $state))
printf("Ohio joined the Union on %s", $state["Ohio"]);

The following is the result:

Ohio joined the Union on March 1, 1803

Searching Associative Array Values

The array_search() function searches an array for a specified value, returning its key if located and FALSE otherwise. Its prototype follows:

mixed array_search(mixed needle, array haystack [, boolean strict])

The following example searches $state for a particular date (December 7), returning information about the corresponding state if located:

$state["Ohio"] = "March 1";
$state["Delaware"] = "December 7";
$state["Pennsylvania"] = "December 12";
$founded = array_search("December 7", $state);
if ($founded) printf("%s was founded on %s.", $founded, $state[$founded]);

The output follows:

Delaware was founded on December 7.

Note:- If needle is found in haystack more than once, the first matching key is returned. To return the keys for all matching values, use array_keys() with the optional search_value parameter instead

Retrieving Array Keys

The array_keys() function returns an array consisting of all keys located in an array. Its prototype follows:

array array_keys(array array [, mixed search_value [, boolean preserve_keys]])

If the optional search_value parameter is included, only keys matching that value will be returned.

The following example outputs all of the key values found in the $state array:

$state["Delaware"] = "December 7, 1787";
$state["Pennsylvania"] = "December 12, 1787";
$state["New Jersey"] = "December 18, 1787";
$keys = array_keys($state);
print_r($keys);

The output follows:

Array ( [0] => Delaware [1] => Pennsylvania [2] => New Jersey )

Setting the optional preserve_keys parameter (introduced in PHP 5.0.2) to true will cause the array values’ keys to be preserved in the returned array.

Retrieving Array Values

The array_values() functions returns all values located in an array, automatically providing numeric indexes for the returned array. Its prototype follows:

array array_values(array array)

The following example will retrieve the population numbers for all of the states found in $population:

$population = array("Ohio" => "11,421,267", "Iowa" => "2,936,760");
print_r(array_values($population));

This example will output the following:

Array ( [0] => 11,421,267 [1] => 2,936,760 )

Now take another example:-

<?php
$array = array("size" => "XL", "color" => "gold","x" => " ","y" => "gold","z" => "");
print_r(array_values($array));
?>

Above example will produce the following result:

Array ( [0] => XL [1] => gold [2] => [3] => gold [4] => )

Adding and Removing array Elements <-> Traversing Arrays

Adding and Removing Array Elements

2013-07-05T00:40:00.000+05:30

PHP provides a number of functions for both growing and shrinking an array (what is an array?). Some of these functions are provided as a convenience to programmers who wish to mimic various queue implementations (FIFO, LIFO, etc.), as reflected by their names (push, pop, shift, and unshift). In this article we’ll be covering these topics and many more with examples.

Note:- A traditional queue is a data structure in which the elements are removed in the same order in which they were entered, known as first-in-first-out or FIFO. In contrast, a stack is a data structure in which the elements are removed in the order opposite to that in which they were entered, known as last-in-first-out or LIFO.

Adding a Value to the Front of an Array

The array_unshift() function adds elements to the front of the array. Returns the new number of elements in the array. All preexisting numerical keys are modified to reflect their new position in the array, but associative keys aren’t affected. Its prototype follows:

int array_unshift(array array, mixed variable [, mixed variable...])

The following example adds two states to the front of the $states array:

$states = array("Ohio", "New York");
array_unshift($states, "California", "Texas");
// $states = array("California", "Texas", "Ohio", "New York");

Adding a Value to the End of an Array

The array_push() function adds a value to the end of an array, returning the total count of elements in the array after the new value has been added. You can push multiple variables onto the array simultaneously by passing these variables into the function as input parameters. Its prototype follows:

int array_push(array array, mixed variable [, mixed variable...])

Note:- If you use array_push() to add one element to the array it's better to use $array[] = because in that way there is no overhead of calling a function.
Note:- array_push() will raise a warning if the first argument is not an array. This differs from the $var[] behaviour where a new array is created.

If you're going to use array_push() to insert a "$key" => "$value" pair into an array, it can be done using the following:

$data[$key] = $value;

It is not necessary to use array_push.

The following example adds two more states onto the $states array:

$states = array("Ohio", "New York");
array_push($states, "California", "Texas");
// $states = array("Ohio", "New York", "California", "Texas");

Removing a Value from the Front of an Array

The array_shift() function removes and returns the first item found in an array, or NULL if array is empty or is not an array. If numerical keys are used, all corresponding values will be shifted down, whereas arrays using associative keys will not be affected. Its prototype follows:

mixed array_shift(array array)

The following example removes the first state from the $states array:

$states = array("Ohio", "New York", "California", "Texas");
$state = array_shift($states);
// $states = array("New York", "California", "Texas")
// $state = "Ohio"

Note:- If you want a version of array_shift() that works non-destructively (i.e., an easy function to grab the first element of the array without modifying the array), try reset(), which returns the value of first element or False if array is empty.

Removing a Value from the End of an Array

The array_pop() function removes and returns the last element from an array. If array is empty (or is not an array), NULL will be returned. Its prototype follows:

mixed array_pop(array array)

The following example removes the last state from the $states array:

$states = array("Ohio", "New York", "California", "Texas");
$state = array_pop($states);
// $states = array("Ohio", "New York", "California"
// $state = "Texas"

Note:- If you want a version of array_pop() that works non-destructively (i.e., an easy function to grab the last element of the array without modifying the array), try end(), which returns the value of last element or False if array is empty.

You can see a single task can be accomplished by a number of ways. It depends on your comfort and demand of the situation- which method to choose.

Outputting arrays <-> Locating Array elements

Outputting Arrays

2013-07-03T00:39:00.000+05:30

Now that you know what is an array? and how to create an array?, it is the time to learn how to output arrays. The most common way to output an array’s contents is by iterating over each key and echoing the corresponding value. For instance, a foreach statement does the trick nicely:

$states = array("Ohio", "Florida", "Texas");
foreach ($states AS $state) {
echo "{$state} ";
}

If you want to print an array of arrays or need to exercise a more exacting format standard over array output, consider using the vprint() function, which allows you to easily display array contents using the same formatting syntax used by the printf() and sprintf() functions introduced earlier. Here’s an example:

$customers = array();
$customers[] = array("Jason Gilmore", "jason@example.com", "614-999-9999");
$customers[] = array("Jesse James", "jesse@example.net", "818-999-9999");
$customers[] = array("Donald Duck", "donald@example.org", "212-999-9999");
foreach ($customers AS $customer) {
vprintf("Name: %s E-mail: %s Phone: %s", $customer);
}

Executing this code produces the following output:

Name: Jason Gilmore 
E-mail: jason@example.com
 Phone: 614-999-9999


Name: Jesse James 
E-mail: jesse@example.net 
Phone: 818-999-9999


Name: Donald Duck 
E-mail: donald@example.org 
Phone: 212-999-9999

If you’d like to send the formatted results to a string, you can use the vsprintf() function. It is the same as using sprintf() function.

Printing Arrays for Testing Purposes

The array contents in most of the previous examples have been displayed using comments. While this works great for instructional purposes, in the real world you’ll need to know how to easily output their contents to the screen for testing purposes. This is most commonly done with the print_r() function. Its prototype follows:

boolean print_r(mixed variable [, boolean return])

The print_r() function accepts a variable and sends its contents to standard output, returning TRUE on success and FALSE otherwise. This in itself isn’t particularly exciting, until you realize it will organize an array’s contents (as well as an object’s) into a readable format. For example, suppose you want to view the contents of an associative array consisting of states and their corresponding state capitals. You could call print_r() like this:

print_r($states);

This returns the following:

Array ( [Ohio] => Columbus [Iowa] => Des Moines [Arizona] => Phoenix )

The optional parameter return modifies the function’s behavior, causing it to return the output to the caller, rather than sending it to the standard output ( which is the browser window ). Therefore, if you want to return the contents of the preceding $states array, you just set return to TRUE:

$stateCapitals = print_r($states, TRUE);

Keep in mind the print_r() function isn’t the only way to output an array; it just offers a convenient means for doing so. You’re free to output arrays using a looping conditional, such as while or for; in fact, using these sorts of loops is required to implement many application features.

Note:- Always use quotes around a string literal array index ( except inside a double-quoted string, it's valid to not surround array indexes with quotes so "$foo[bar]" is valid). For example, $foo['bar'] is correct, while $foo[bar] is not. This does not mean to always quote the key. Do not quote keys which are constants or variables, as this will prevent PHP from interpreting them.

As of PHP 5.4 you can also use the short array syntax, which replaces array() with [].

<?php
$array = array(
 "foo" => "bar",
 "bar" => "foo",
);
// as of PHP 5.4
$array = [
 "foo" => "bar",
 "bar" => "foo",
];
?>

Creating Arrays <-> Adding and Removing Array Elements

Creating Arrays

2013-07-02T00:38:00.000+05:30

Unlike other languages, PHP doesn’t require that you assign a size to an array at creation time. In fact, because it’s a loosely typed language, PHP doesn’t even require that you declare the array before using it, although you’re free to do so. Each approach is introduced here, beginning with the informal variety.

Individual elements of a PHP array are referenced by denoting the element between a pair of square brackets. Because there is no size limitation on the array, you can create the array simply by making reference to it, like this:

$state[0] = "Delaware";

You can then display the first element of the array $state, like this:

echo $state[0];

Additional values can be added by mapping each new value to an array index, like this:

$state[1] = "Pennsylvania";
$state[2] = "New Jersey";
...
$state[49] = "Hawaii";

Interestingly, if you intend for the index value to be numerical and ascending, you can omit the index value at creation time:

$state[] = "Pennsylvania";
$state[] = "New Jersey";
...
$state[] = "Hawaii";

Creating associative arrays in this fashion is equally trivial except that the key is always required. The following example creates an array that matches U.S. state names with their date of entry into the Union:

$state["Delaware"] = "December 7, 1787";
$state["Pennsylvania"] = "December 12, 1787";
$state["New Jersey"] = "December 18, 1787";
...
$state["Hawaii"] = "August 21, 1959";

Creating Arrays with array()

The array() construct takes as its input zero or more items and returns an array consisting of these input elements. Its prototype looks like this:

array array([item1 [,item2 ... [,itemN]]])

Here is an example of using array() to create an indexed array:

$languages = array("English", "Gaelic", "Spanish");
// $languages[0] = "English", $languages[1] = "Gaelic", $languages[2] = "Spanish"

You can also use array() to create an associative array, like this:

$languages = array("Spain" => "Spanish",
"Ireland" => "Gaelic",
"United States" => "English");
// $languages["Spain"] = "Spanish"
// $languages["Ireland"] = "Gaelic"
// $languages["United States"] = "English"

Extracting Arrays with list()

The list() construct is similar to array(), though it’s used to make simultaneous variable assignments (more about variables) from values extracted from an array in just one operation. Its prototype looks like this:

void list(mixed...)

This construct can be particularly useful when you’re extracting information from a database or file. For example, suppose you wanted to format and output information read from a text file named users.txt. Each line of the file contains user information, including name, occupation, and favorite color with each item delimited by a vertical bar. A typical line would look similar to the following:

Nino Sanzi | professional golfer | green

Using list(), a simple loop could read each line, assign each piece of data to a variable, and format and display the data as needed. Here’s how you could use list() to make multiple variable assignments simultaneously:

// Open the users.txt file
$users = fopen("users.txt", "r");
// While the EOF hasn't been reached, get next line
while ($line = fgets($users, 4096))
{
// use explode() to separate each piece of data.
list($name, $occupation, $color) = explode("|", $line);
// format and output the data
printf("Name: %s ", $name);
printf("Occupation: %s ", $occupation);
printf("Favorite color: %s ", $color);
}
fclose($users);

Each line of the users.txt file will be read and the browser output formatted similarly to this:

Name: Nino Sanzi
Occupation: professional golfer
Favorite Color: green

Reviewing the example, list() depends on the function explode() (which returns an array) to split each line into three elements, which explode() does by using the vertical bar ( | ) as the element delimiter. These elements are then assigned to $name, $occupation, and $color.

Populating Arrays with a Predefined Value Range

The range() function provides an easy way to quickly create and fill an array consisting of a range of low and high integer values. An array containing all integer values in this range is returned. Its prototype looks like this:

array range(int low, int high [, int step])

For example, suppose you need an array consisting of all possible face values of a die:

$die = range(1, 6);
// Same as specifying $die = array(1, 2, 3, 4, 5, 6)
//now putting step value of 2:
$even = range(0, 20, 2);
// $even = array(0, 2, 4, 6, 8, 10, 12, 14, 16, 18, 20);

The range() function can also be used for character sequences. For example, suppose you want to create an array consisting of the letters A through F:

$letters = range("A", "F");
// $letters = array("A", "B", "C", "D", "E", "F");

Testing for an Array

When you incorporate arrays into your application, you’ll sometimes need to know whether a particular variable is an array. A built-in function, is_array(), is available for accomplishing this task. Its prototype follows:

boolean is_array(mixed variable)

This function will return True if the variable is an array, otherwise False.

$states = array("Florida");
$state = "Ohio";
printf("\$states is an array: %s ", (is_array($states) ? "TRUE" : "FALSE"));
printf("\$state is an array: %s ", (is_array($state) ? "TRUE" : "FALSE"));

Executing this example produces the following:

$states is an array: TRUE
$state is an array: FALSE

Arrays <-> Outputting Arrays

Arrays

2013-07-01T00:37:00.000+05:30

Being a programmer you will be tackling large heaps of data many a times, in php also, like storing the username, email, password and other sensitive data of large no. of users. Such kind of data sets also need to be manipulated, sorted and retrieved. Luckily php as many other programming languages, also provides you with the feature of ARRAY which provides you with the ideal way to store, manipulate, sort and retrieve data sets.

You are already familiar with the array data type. In this series of lectures, arrays will be covered from basics of creating an array to merging and slicing an array. After this series of lectures, specifically, you will be able to do these things namely:

Create arrays
Output arrays
Test for an array
Add and remove array elements
Locate array elements
Traverse arrays
Determine array size and element uniqueness
Sort arrays
Merge and slice || splice and dissect arrays

Before rushing to these topics, let me first introduce you to our not so new data type- Array.

An array is traditionally defined as a group of items that share certain characteristics, such as similarity (car models, baseball teams, types of fruit, etc.) and type (e.g., all strings or integers). Each item is distinguished by a special identifier known as a key.

PHP takes this definition a step further, forgoing the requirement that the items share the same data type (more about data types). For example, an array could quite possibly contain items such as state names, ZIP codes, exam scores, or playing card suits. Each item consists of two components: the aforementioned key and a value. The key serves as the lookup facility for retrieving its counterpart, the value. Keys can be numerical or associative. Numerical keys bear no real relation to the value other than the value’s position in the array(Like many other programming languages, PHP’s numerically indexed arrays begins with position 0, and not 1).

As an example, the array could consist of an alphabetically sorted list of state names, with key 0 representing Alabama and key 49 representing Wyoming. Using PHP syntax, this might look like the following:

$states = array(0 => "Alabama", 1 => "Alaska"...49 => "Wyoming");
// $states[0] = “Alabama”

Whereas an associative key logically bears a direct relation to its corresponding value. Mapping arrays associatively is particularly convenient when using numerical index values just doesn’t make sense. For instance, you might want to create an array that maps state abbreviations to their names. Using PHP syntax, this might look like the following:

$states = array("HR" => "Haryana", "HP" => "Himachal Pradesh", "NY" => "New York")

You could then reference Haryana like this:

$states["HR"]

It’s also possible to create arrays of arrays, known as multidimensional arrays. For example, you could use a multidimensional array to store the state information. Using PHP syntax, it might look like this:

$states = array (
"Haryana" => array("population" => "11,353,140", "capital" => "Chandigarh"),
"Punjab" => array("population" => "1,711,263", "capital" => "Chandigarh") // capital of Haryana and Punjab is same
);

You could then reference Haryana’s population:

$states["Haryana"]["population"]

This would return the following:

11,353,140

Note: For the above example, Haryana and Punjab are the keys in the array $states whereas population and capital are the keys in both arrays Haryana and Punjab.

Creating Arrays

Functions in php – Part 4

2013-06-30T00:36:00.000+05:30

Recursive Functions

Recursive functions, or functions that call themselves, offer considerable practical value to the programmer and are used to divide an otherwise complex problem into a simple case, reiterating that case until the problem is resolved. Practically every introductory recursion example involves factorial computation. Let’s do something a tad more practical and create a loan payment calculator. Specifically, the following example uses recursion to create a payment schedule, telling you the principal and interest amounts required of each payment installment to repay the loan. The recursive function, amortizationTable(), is introduced in script 1. It takes as input four arguments: $pNum, which identifies the payment number; $periodicPayment, which carries the total monthly payment; $balance, which indicates the remaining loan balance; and $monthlyInterest, which determines the monthly interest percentage rate. These items are designated or determined in the script 2.

Script 1. The Payment Calculator Function, amortizationTable()

After setting pertinent variables and performing a few preliminary calculations, script 2 invokes the amortizationTable() function. Because this function calls itself recursively, all amortization table calculations will be performed internal to this function; once complete, control is returned to the caller.

Script 2. A Payment Schedule Calculator Using Recursion

<?php
// Loan balance
$balance = 10000.00;
// Loan interest rate
$interestRate = .0575;
// Monthly interest rate
$monthlyInterest = $interestRate / 12;
// Term length of the loan, in years.
$termLength = 5;
// Number of payments per year.
$paymentsPerYear = 12;
// Payment iteration
$paymentNumber = 1;
// Determine total number payments
$totalPayments = $termLength * $paymentsPerYear;
// Determine interest component of periodic payment
$intCalc = 1 + $interestRate / $paymentsPerYear;
// Determine periodic payment
$periodicPayment = $balance * pow($intCalc,$totalPayments) * ($intCalc - 1) / (pow($intCalc,$totalPayments) - 1);
// Round periodic payment to two decimals
$periodicPayment = round($periodicPayment,2);
// Create table
echo "<table width='50%' align='center' border='1'>";
echo "<tr>
<th>Payment Number</th><th>Balance</th>
<th>Payment</th><th>Principal</th><th>Interest</th>
</tr>";
// Call recursive function
amortizationTable($paymentNumber, $periodicPayment, $balance, $monthlyInterest);
// Close table
echo "</table>";
?>

Figure below shows sample output, based on monthly payments made on a five-year fixed loan of $10,000.00 at 5.75 percent interest. For reasons of space conservation, just the first 12 payment iterations are listed.

Function Libraries

Personally I feel this is the most important part of functions. Great programmers are lazy, and lazy programmers think in terms of reusability. Functions offer a great way to reuse code and are often collectively assembled into libraries and subsequently repeatedly reused within similar applications. PHP libraries are created via the simple aggregation of function definitions in a single file, like this:

<?php
function localTax($grossIncome, $taxRate) {
// function body here
}
function stateTax($grossIncome, $taxRate, $age) {
// function body here
}
function medicare($grossIncome, $medicareRate) {
// function body here
}
?>

Save this library, preferably using a naming convention that will clearly denote its purpose, such as taxes.library.php. Do not, however, save this file within the server document root using an extension that would cause the web server to pass the file contents unparsed. Doing so opens up the possibility for a user to call the file from the browser and review the code, which could contain sensitive data. You can insert this file into scripts using include(), include_once(), require(), or require_once(). (Alternatively, you could use PHP’s auto_prepend configuration directive to automate the task of file insertion for you.) For example, assuming that you titled this library taxation.library.php, you could include it into a script like this:

<?php
require_once("taxation.library.php");
...
?>

Once included, any of the three functions found in this library can be invoked (invoking functions) as needed.

Functions in php - Part 3 <-> ARRAYS

Functions in php – Part 3

2013-06-29T00:35:00.000+05:30

Using Type Hinting

PHP 5 introduced a new feature known as Type hinting, which gives you the ability to force parameters to be objects of a certain class or to be arrays. Unfortunately, type hinting using scalar data types such as integers and strings is not supported. If the provided parameter is not of the desired type, a fatal error will occur. As an example, suppose you created a class named Customer and wanted to be certain that any parameter passed to a function named processPayPalPayment() was of type Customer. You could use type hinting to implement this restriction:

function processPayPalPayment(Customer $customer) {
// Process the customer's payment
}

Returning Values from a Function

Often, simply relying on a function to do something is insufficient; a script’s outcome might depend on a function’s outcome or on changes in data resulting from its execution. Yet variable scoping prevents information from easily being passed from a function body back to its caller, so how can we accomplish this? You can pass data back to the caller by way of the return() statement.

The return Statement

The return() statement returns any ensuing value back to the function caller, returning program control back to the caller’s scope in the process. If return() is called from within the global scope, the script execution is terminated. Revising the calcSalestax() function again, suppose you don’t want to immediately echo the sales total back to the user upon calculation, but rather want to return the value to the calling block:

function calcSalesTax($price, $tax=.0675)
{
$total = $price + ($price * $tax);
return $total;
}

Alternatively, you could return the calculation directly without even assigning it to $total, like this:

function calcSalesTax($price, $tax=.0675)
{
return $price + ($price * $tax);
}

Here’s an example of how you would call this function:

<?php
$price = 6.99;
$total = calcSalesTax($price);
?>

To return a reference from a function, use the reference operator & in both the function declaration and when assigning the returned value to a variable(more about variables in php):

Example #3 Returning a reference from a function

<?php
function &returns_reference()
{
return $someref;
}
$newref =& returns_reference();
?>

Returning Multiple Values

It’s often convenient to return multiple values from a function. For example, suppose that you’d like to create a function that retrieves user data from a database (say the user’s name, e-mail address, and phone number) and returns it to the caller. Accomplishing this is much easier than you might think, with the help of a very useful language construct, list(). The list() construct offers a convenient means for retrieving values from an array, like so:

<?php
$colors = array("red","blue","green");
list($red, $blue, $green) = $colors;
?>

Once the list() construct executes, $red, $blue, and $green will be assigned red, blue, and green, respectively.
Building on the concept demonstrated in the previous example, you can imagine how the three prerequisite values might be returned from a function using list():

<?php
function retrieveUserProfile()
{
$user[] = "Jason Gilmore";
$user[] = "jason@example.com";
$user[] = "English";
return $user;
}
list($name, $email, $language) = retrieveUserProfile();
echo "Name: $name, email: $email, language: $language";
?>

Executing this script returns the following:

Name: Jason Gilmore, email: jason@example.com, language: English

This feature is quite useful and will be used repeatedly throughout your journey in php programming.

Functions – Part 2 <-> Functions – Part 4

Functions in php – Part 2

2013-06-27T00:34:00.000+05:30

Passing Arguments by Value

You‘ll often find it useful to pass data into a function. As an example, let’s create a function that calculates an item’s total cost by determining its sales tax and then adding that amount to the price:

function calcSalesTax($price, $tax)
{
$total = $price + ($price * $tax);
echo "Total cost: $total";
}

This function accepts two parameters, aptly named $price and $tax, which are used in the calculation. Although these parameters are intended to be floating points, because of PHP’s weak typing, nothing prevents you from passing in variables of any datatype, but the outcome might not be what you expect. In addition, you’re allowed to define as few or as many parameters as you deem necessary; there are no language-imposed constraints in this regard.

Once defined, you can then invoke the function as demonstrated in the Functions in php - Part 1. For example, the calcSalesTax() function would be called like so:

calcSalesTax(15.00, .075);

Of course, you’re not bound to passing static values into the function. You can also pass variables like this:

<?php
$pricetag = 15.00;
$salestax = .075;
calcSalesTax($pricetag, $salestax);
?>

When you pass an argument in this manner, it’s called passing by value. This means that any changes made to those values within the scope of the function are ignored outside of the function because not the actual value but a copy of the value is passed into the function and when the fucntion ends this value is destroyed. Hence, there is no change to the actual value.

Take this example for instance:-

<?php
$num1= 10
$num2= 20
function something($num1,$num2)
{
$num1 += $num2;
echo "$num1";
}
something($num1,$num2);
echo "$num1";
?>

Output:

30
10

If you want these changes to be reflected outside of the function’s scope, you can pass the argument by reference, introduced next.

Passing Arguments by Reference

On occasion, you may want any changes made to an argument within a function to be reflected outside of the function’s scope. Passing the argument by reference accomplishes this, because in this case a copy of the argument is not provided to function instead the argument itself is provided. Hence any change to the argument inside the function will be reflected outside of the function. Passing an argument by reference is done by appending an ampersand(&) to the front of the argument. Here’s an example:

<?php
$cost = 20.99;
$tax = 0.0575;
function calculateCost(&$cost, $tax)
{
 // Modify the $cost variable
 $cost = $cost + ($cost * $tax);
 // Perform some random change to the $tax variable.
 $tax += 4;
}
calculateCost($cost, $tax);
printf("Tax is %01.2f%% ", $tax*100);
printf("Cost is: $%01.2f", $cost);
?>

Here’s the result:

Tax is 5.75%
Cost is $22.20

Note the value of $tax remains the same, although $cost has changed.

Take this another example:-

<?php
function add_some_extra(&$string)
{
$string .= 'and something extra.';
}
http://letusdophp.blogspot.in/2013/06/functions-in-php-part-2.html $str = 'This is a string, ';
add_some_extra($str);
echo $str; // outputs 'This is a string, and something extra.'
?>

Ques. : Absent any actual need for choosing one method over the other, does passing arrays by value to a read-only function reduce performance compared to passing them by reference?
Ans. : "A copy of the original $array is created within the function scope. Once the function terminates, the scope is removed and the copy of $array with it.

Default Argument Values

Default values can be assigned to input arguments, which will be automatically assigned to the argument if no other value is provided. To revise the sales tax example, suppose that for majority of your sales $tax is 6.75 percent :-

function calcSalesTax($price, $tax=.0675)
{
$total = $price + ($price * $tax);
echo "Total cost: $total";
}

You can still pass $tax another taxation rate; 6.75 percent will be used only if calcSalesTax() is invoked without the second parameter like this:

$price = 15.47;
calcSalesTax($price);

Default argument values must appear at the end of the parameter list and must be constant expressions; you cannot assign non-constant values such as function calls or variables.

You can designate certain arguments as optional by placing them at the end of the list and assigning them a default value of nothing, like so:

function calcSalesTax($price, $tax="")
{
$total = $price + ($price * $tax);
echo "Total cost: $total";
}

This allows you to call calcSalesTax() without the second parameter if there is no sales tax:

calcSalesTax(42.00);

This returns the following output:

Total cost: $42

Now consider this example:

function calculate($price, $price2="", $price3="")
{
echo $price + $price2 + $price3;
}

You can then call calculate(), passing along just $price and $price3, like so:

calculate(10, "", 3);

This returns the following value:

Note again that when using default arguments, any defaults should be on the right side of any non-default arguments; otherwise, things will not work as expected.

Functions in php – Part 1 <-> Functions in php – Part 3

Functions in php – Part 1

2013-06-26T13:03:00.000+05:30

You’ll often find that some tasks are comprised of bits of logic which can be reused elsewhere, not only within the same application but also in many other applications. For example, an e-commerce application might need to validate an email address on several different pages, such as when a new user registers to use a Web site or when a visitor signs up for a newsletter. The logic used to validate an e-mail address is quite complex, and therefore it would be a smart act to maintain the logic in a single location rather than literally embed it into numerous pages, particularly if it one day needs to be modified to account for a new domain.

The concept of embodying these repetitive processes within a named section of code and then invoking this name when necessary has long been a key feature of modern computer languages which is known as a Function, and it grants you the convenience of a singular point of reference if the process it defines requires changes in the future, which greatly reduces both the possibility of programming errors and maintenance overhead.

In this series of lecture, we'll be covering each and every aspect of a Function, including how to create and invoke them, pass input to them(by value and by reference), use a relatively new feature known as type hinting, return both single and multiple values to the caller, and create and include function libraries. Additionally, you’ll learn about both recursive and variable functions.

Note:- Keep an eye on each and every aspect of function coz it's quite important.

Invoking a Function

More than 1,000 functions are built into the standard PHP distribution and you can include any function defined elsewhere by include() or require(). You can anytime invoke any of these functions by just specifying their names. For example, to raise five to the third power:-

<?php
$value = pow(5,3); // returns 125
echo $value;
?>

Note:- pow is predefined library function termed as power. pow(x,y) will raise x to the y power

In the example above, you can bypass assigning the value to a variable and simply get an output, like this:

<?php
echo pow(5,3);
?>

Output:

125

If you want to output the function outcome within a larger string, you can do this as :-

<?php
printf("Five raised to the power three is %d.", pow(5,3));
?>

Output:

Five raised to the power three is 125.

Note:- Refer to the php documentation for complete list of predefined functions.

Creating a Function

Although php offers a vast variety of predefined functions but sooner or later you will feel the need to go beyond these predefined functions and create custom functions or even entire function libraries.

You can easily create a function as follows:

function functionName(parameters)
{
function-body
}

Take an example:-

function helloworld()
{
echo "Hello world!";
}

Once defined you can call this function as follows:

<?php
helloworld();
?>

Output:

Hello world!

Note:- In the example above there are no parameters. Parameters are like variables in the function and there could be none or any number of parameters inside a function.

Now take this example:-

<html>
<head>
<title>PHP Function with Parameters</title>
</head>
<body>
<?php
function addFunction($num1, $num2)
{
$sum = $num1 + $num2;
echo "Sum of the two numbers is : $sum";
}
addFunction(10, 20);
?>
</body>
</html>

Output:

Most of the times it is not necessary to define a function before it is called except when it is conditionally defined. This is because of the fact that php looks over the entire script into engine before executing it. BUT THIS IS HAPHAZARD PRACTICE IS NOT RECOMMENDED. SO DON'T TRY THIS.

Take this as example:-

<?php
$makefoo = true;
/* We can't call function foo() from here
 since it doesn't exist yet,
 but we can call bar() */
bar();
if ($makefoo) {
function foo()
{
 echo "I don't exist until program execution reaches me.\n";
}
}
/* Now we can safely call foo()
 since $makefoo evaluated to true */
if ($makefoo) foo();
function bar()
{
echo "I exist immediately upon program start.\n";
}
?>

Function within function:-

<?php
function foo()
{
function bar()
{
 echo "I don't exist until foo() is called.\n";
}
}
/* We can't call bar() yet
 since it doesn't exist. */
foo();
/* Now we can call bar(),
 foo()'s processing has
 made it accessible. */
bar();
?>

Functions in php - Part 2