Geek Files » PHP

Writing Website Scrapers in PHP

admin — Tue, 26 Feb 2008 15:35:01 +0000

This article discusses about how to write a website scraper using PHP for web site data extraction. The concepts taught can be applied and programmed in Java, C#, etc. Basically any language that has a powerful string processing capability. This article will teach you the basics of website scraping. The article will further cover a tutorial to find web ranking from Yahoo.com search engine.

Steps involved to write a scraping program

Visit the URL
Understand the pattern
Validate the structure of pattern on different URLs
Write the program
Test the program using various input parameters

Lets visit each of these steps one bit at a time.

1. Visit the URL

For this tutorial, we will extract Yahoo’s “Today’s Top Searches” section towards the end of their home page (http://www.yahoo.com/).

2. Understand the pattern

Before you begin to write a web scraping program, its important to understand the pattern of the data that you wish to extract. View the page source to understand the pattern. Mentioned below.

The string of text that we should parse is given below:

 

Heidi Klum
Sarah Larson
Oscar Videos
Brad Renfro
Gary Busey
Barack Obama
Razzie Awards
Raisin in the Sun
Stay Home Moms
Net Neutrality

The pattern is that each Search Phrase is enclosed within a

tag. Therefore, we should parse everything between of this text piece to get the text.

3. Validate the structure of pattern on different URLs

If you are writing a script to fetch data that has pagination, you should remember to validate the structure on 3 – 4 pages before you start developing code. The reason behind doing this is that the presentation of the first page could differ in subsequent pages.

4. Write the program

You could use any programming language like Java, C#, PHP, PERL, etc. for this processing. I have used PHP for this example.

 
//change fso() to f sock open (my blog was causing an error)
//change fwt() to f write (my blog was causing an error)
//change fgs() to f gets (my blog was causing an error)
//change fc() to f close (my blog was causing an error)
 
$fp = fso("www.yahoo.com", 80, $errno, $errstr, 30);
if (!$fp) {
    echo "$errstr ($errno)
\n";
} else {
	$out = "GET / HTTP/1.1\r\n";
	$out .= "Host: www.yahoo.com\r\n";
	$out .= "User-Agent: Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.12) Gecko/20080201 Firefox/2.0.0.12\r\n";
	$out .= "Connection: Close\r\n\r\n";
 
	$str = "";
 
	fwt($fp, $out);
	while (!feof($fp)) {
		$str .= fgs($fp, 1024);
	}
	fc($fp);
}
 
$pos = strpos($str, "\"popsearchbd\"");
$pos = $pos + strlen("\"popsearchbd\"");
 
if($pos == false) {
	echo "No information available";
}
else {
 
	while(1) {
		$pos = strpos($str, "fp-buzzmod\">", $pos);
 
		if($pos === false) {
			break;
		}
 
		$pos = $pos + strlen("fp-buzzmod\">");
		$temppos = $pos;
		$pos = strpos($str, "", $pos);
 
		$datalength = $pos - $temppos;
 
		$data = substr($str, $temppos , $datalength);
		echo $data;
		echo "\n";
	}
 
}

5. Test the program using various input parameters

You should test your program for all the parameters that the web page can take. I have experienced change in layout & data based on the parameters that are passed.

Notes on processing forms and cookies

Some pages use form data and cookies to render data. In such cases you should remember to check the Request and Response headers and identify what is necessary to get the results that you want. If the page requires a cookie value, you should then use the cookie information in your Request Headers. Look at the note below that I use to inspect Request and Response headers.

Tool to inspect Request and Response Headers

I use Live HTTP Headers (a plug in for FireFox) to check for Request and Response Headers. Visit http://livehttpheaders.mozdev.org for more details. To install this plug in visit http://livehttpheaders.mozdev.org/installation.html and click on the ‘download it’ link on the latest release. Please read the release notes before installing a particular version.

Please feel free to use the comments section down to share other tools that you guys use to monitor Request and Response Headers.

Future Maintenance of the program

From a maintenance perspective you should monitor the page frequently and re-validate the HTML structure. The reason for this is because nothing in this world is constant and so is the website. Design changes could result in a change in the HTML code. I recommend scheduling this activity for at least once a month.

This is all that is there in this tutorial. In the next tutorial, I will guide you step-by-step on how to create a program to check for yahoo.com search engine ranking. Use the subscribe form below to keep yourself updated when the tutorial goes live.

Would you like to check out some of my PHP5 Tutorials as well?

PHP 5 Tutorial – Handling Exceptions in PHP5

admin — Thu, 14 Feb 2008 08:58:21 +0000

In this tutorial we will cover the following:

What is an exception?
The use of a try…catch block
Anatomy of PHP5 Exception class
Extending the Exception class
A note on unhanded exceptions

What is an exception?

An exception is a logical/system error that occurs during the normal execution of a script. The exception could either be raised by the system or the program itself it the exception cannot be handled and the caller script/function needs to be informed about the same.

The use of a try…catch block

PHP5 introduces the try…catch block to trap exceptions. Look at the example below.

 
try {
   check();
}
catch(Exception $e) {
   echo "Message : " . $e->getMessage();
   echo "Code : " . $e->getCode();
}
 
function check() {
   if(some error condition) {
      throw new Exception("Error String",Error Code);
   }
}

In the above example, the method check() is called between the try {} block. The try{} block is the area where you will place your code that could raise an exception. Below the try{} block is the catch() {} block. The catch block expects the Exception type of object as a parameter. Within the catch() {} block you will place your logic to either fix the issue or log the error.

In the function check(), we raise an Exception using the ‘throw’ keyword. The statement following ‘throw’ is the syntax of creating a new object of Exception type. The exception class accepts two parameters. The left parameter is a string that is the error message and the right parameter is the integer error code that you wish to assign to that error.

Anatomy of PHP5 Exception class

 
class Exception {
	protected $message;
	protected $code;
	protected $file;
	protected $line;
 
	private $string;
	private $trace;
 
	public function __construct($message = null, $code = 0);
	public function __toString();
 
	final public function getCode();
	final public function getMessage();
	final public function getFile();
	final public function getLine();
	final public function getTrace();
	final public function getTraceAsString();
	final private __clone();
}

In the above example, except for __construct and __toString(), no other method can be overridden as all other methods are ‘final’.

Related Reading:

PHP5 Tutorial – Creating a PHP5 Constructor __construct()

PHP5 Tutorial – Defining Attributes of a PHP5 Class

PHP5 Tutorial OOPS – PHP5 Class Access Specifiers – public, private and protected

PHP 5 Tutorial – Final Class and Methods

PHP5 Tutorial – Magic Methods – __toString() method

Extending the Exception class

You can also extend the exception class as follows:

 
class CustomerException extends Exception {
 
  public function __construct($message = null, $code = 0) {
 
    $t_message = "Exception raised in CustomerException ";
    $t_message .= "with message : " . $message;
 
    parent::__construct($t_message, $code);
 
    }
 
}
 
 
function testException() {
 
	throw new CustomerException("CustomerException has been raised",101);
 
}
 
try {
	testException();
}
catch(CustomerException $e) {
	echo "Error Message : " $e->getMessage();
	echo "Error Code : " $e->getCode();
}

Output:

Error Message : CustomerException has been raised
Error Code : 101

Related Reading:
PHP5 Tutorial – Inheritance

A note on unhanded exceptions

All un-handled exceptions are passed up the function stack order till the time either a try…catch block is not made available. If a try…catch block is unavailable it is passed to the PHP core and the program execution stops there.

Please feel free to write back for any clarification.

Subscribe to my free newsletter:

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP 5 Tutorial – Final Class and Methods

admin — Thu, 14 Feb 2008 06:41:17 +0000

In this PHP tutorial we will understand the following:

Meaning of Final Class
Meaning of Final Method
When to declare a class as final
When to declare a method as final

Meaning of Final Class

A final class is a class that cannot be extended. To declare a class as final, you need to prefix the ‘class’ keyword with ‘final’. Example below.

 
final class BaseClass {
   public function myMethod() {
      echo "BaseClass method called";
   }
}
 
//this will cause Compile error
class DerivedClass extends BaseClass {
   public function myMethod() {
      echo "DerivedClass method called";
   }
}
 
$c = new DerivedClass();
$c->myMethod();

In the above example, BaseClass is declared as final and hence cannot be extended (inherited). DerivedClass tries to extend from BaseClass and hence the compiler will throw a compile error.

Meaning of Final Method

A final method is a method that cannot be overridden. To declare a method as final, you need to prefix the function name with the ‘final’ keyword. Example below:

 
class BaseClass {
   final public function myMethod() {
      echo "BaseClass method called";
   }
}
 
class DerivedClass extends BaseClass {
   //this will cause Compile error
   public function myMethod() {
      echo "DerivedClass method called";
   }
}
 
$c = new DerivedClass();
$c->myMethod();

In the above example, DerivedClass extends from BaseClass. BaseClass has the method myMethod() declared as final and this cannot be overridden. In this case the compiler causes a compile error.

When to declare a class as final

You should declare a class as final when you think that you implementation of that class should not change in the derived class. You should do this mainly for Utility classes where you don’t want the behavior/implementation of your class to change.

When to declare a method as final

You should declare a class method as final when you think that the method you develop contains necessary functionality to support your application and any modification or change to the functionality can cause unexpected errors/bugs.

Please feel free to write back for any clarification.

Subscribe to my free newsletter:

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP 5 Tutorials – Static Data Members and Methods

admin — Tue, 12 Feb 2008 09:47:49 +0000

In this tutorial you will learn all about static data members and methods

Meaning of static data members
Meaning of static methods
Defining static data members in PHP5
Defining static methods in PHP5
Accessing static data members in PHP5
Accessing static methods in PHP5
Rules to keep in mind for static methods

Meaning of static data members

A data member that is commonly available to all objects of a class is called a static member. Unlike regular data members, static members share the memory space between all objects of the same class.

Meaning of static methods

A static method is a class method that can be called without creating an instance of a class. Such methods are useful when creating utility classes.

Defining static data members in PHP5

To define a static member in PHP5 you need to prefix the class member name with the keyword ‘static’. Look at the example below.

 
class Customer {
 
	private $first_name; // regular member
	static public $instance_count; //static data member
 
}

In the above example $instance_count is declared as a static data member

Defining static methods in PHP5

To define a static data methods in PHP5 you need to prefix the class method name with the keyword ‘static’. Look at the example below.

 
class Customer {
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		//body of method
	}
}

In the above example getInstanceCount is declared as a static method

Accessing static data members in PHP5

A static member data can be accessed using the name of the class along with the scope resolution operator (::) i.e. you donâ€™t need to create an instance of that class

Look at the example below:

 
class Customer {
 
	static public $instance_count = 0; //static data member
 
	public function __construct() {
		Customer::$instance_count++;
	}
 
	public function __destruct() {
		Customer::$instance_count--;
	}
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		//body of method
	}
}
 
$c1 = new Customer();
$c2 = new Customer();
 
echo Customer::$instance_count;

Output:
2

In the above example, $instance_count is a static data member. Every time a new object is created the constructor is executed and the $instance_count variable is incremented by one. To echo the value contained in $instance_count variable, we use the :: (scope resolution) operator.

Accessing static method in PHP5

A static method can be accessed using the name of the class along with the scope resolution operator (::) i.e. you donâ€™t need to create an instance of that class. However, you can also access it with an instance variable.

Look at the example below:

 
class Customer {
 
	static public $instance_count = 0; //static data member
 
	public function __construct() {
		Customer::$instance_count++;
	}
 
	public function __destruct() {
		Customer::$instance_count--;
	}
 
	public function getFirstName() {
		//body of method
	}
 
	static public function getInstanceCount() {
		return Customer::$instance_count;
	}
}
 
$c1 = new Customer();
$c2 = new Customer();
 
echo Customer::getInstanceCount(); //this is using the scope resolution operator
echo $c1->getInstanceCount(); //this is using the instance variable

Output:
2
2

Rules to keep in mind for static methods

A static method can only access static data members
A static method does not have access to the $this variable

Please feel free to write back for any clarification.

Subscribe to my newsletter:

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 OOPS Tutorials – Polymorphism

admin — Mon, 11 Feb 2008 07:09:09 +0000

In this tutorial we will learn the following:

Meaning of Polymorphism
Why method polymorphism cannot be achieved in PHP
PHP 5 Object Polymorphism

Meaning of Polymorphism

Polymorphism is derived from two Greek words. Poly (meaning many) and morph (meaning forms). Polymorphism means many forms. In C you have two methods with the same name that have different function signatures and hence by passing the correct function signature you can invoke the correct method.

This is how polymorphism is achieved in languages like C where in a function sum(int, int) differs from sum(float, float). Therefore the method sum() has many forms depending on the parameters being passed to it.

The meaning with Object Oriented languages changes. With Object Oriented language polymorphism happens:

When the decision to invoke a function call is made by inspecting the object at runtime it is called Polymorphism

Why method polymorphism cannot be achieved

The reason why polymorphism for methods is not possible in PHP is because you can have a method that accepts two parameters and call it by passing three parameters. This is because PHP is not strict and contains methods like func_num_args() and func_get_arg() to find the number of arguments passed and get a particular parameter.

Because PHP is not type strict and allows variable arguments, this is why method polymorphism is not possible.

PHP 5 Polymorphism

Since PHP 5 introduces the concept of Type Hinting, polymorphism is possible with class methods. The basis of polymorphism is Inheritance and overridden methods.

Lets look at an example:

 
class BaseClass {
   public function myMethod() {
      echo "BaseClass method called";
   }
}
 
class DerivedClass extends BaseClass {
   public function myMethod() {
      echo "DerivedClass method called";
   }
}
 
function processClass(BaseClass $c) {
   $c->myMethod();
}
 
$c = new DerivedClass();
processClass($c);

In the above example, object $c of class DerievedClass is executed and passed to the processClass() method. The parameter accepted in processClass() is that of BassClass. Within the processClass() the method myMethod() is being called. Since the method is being called on the class variable of BaseClass, it would not be wrong to assume that myMethod() of class BaseClass will be called. But, as per the definition “When the decision to invoke a function call is made by inspecting the object at runtime it is called Polymorphism”, myMethod() will be called on object DerievedClass. The reason why this happens is because the object of DerievedClass is being passed and hence the method myMethod() of DerievedClass will be called.

Please feel free to write back for any clarification.

Subscribe to my newsletter:

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 Tutorials – Abstract Class and Interface

admin — Sun, 03 Feb 2008 08:26:29 +0000

In this post, we learn what is an abstract class and an interface.

What is an Abstract Class?
Private methods cannot be Abstract
What is an Interface?
Defining an Interface
Abstract Class v/s Interface

What is an Abstract Class?

An abstract class is a class with or without data members that provides some functionality and leaves the remaining functionality for its child class to implement. The child class must provide the functionality not provided by the abstract class or else the child class also becomes abstract.

Objects of an abstract and interface class cannot be created i.e. only objects of concrete class can be created

To define a class as Abstract, the keyword abstract is to be used e.g. abstract class ClassName { }

Example of Abstract Class

 
abstract class Furniture {
	private $height, width, length;
 
	public function setData($h, $w, $l) {
		$this->height = $h;
		$this->width = $w;
		$this->length = $l;
	}
 
        //this function is declared as abstract and hence the function
        //body will have to be provided in the child class
	public abstract function getPrice();
 
}
 
 
class BookShelf extends Furniture {
 
   private $price;
 
   public setData($h, $w, $l, $p) {
      parent::setData($h, $w, $l);
      $this->price = $p;
   }
 
 
   //this is the function body of the parent abstract method
   public function getPrice() {
      return $this->price;
   }
}

In the above example, the method getPrice() in class Furniture has been declared as Abstract. This means that its the responsibility of the child class to provide the functionality of getPrice(). The BookShelf class is a child of the Furniture class and hence provides the function body for getPrice().

Private methods cannot be abstract

If a method is defined as abstract then it cannot be declared as private (it can only be public or protected). This is because a private method cannot be inherited.

abstract class BaseClass {
 
   private abstract function myFun();
 
}
 
class DerivedClass extends BaseClass {
   public function myFun() {
	   //logic here
   }
}
 
$d = new DerivedClass(); //will cause error

What is an Interface?

An interface is a contract between unrelated objects to perform a common function. An interface enables you to specify that an object is capable of performing a certain function, but it does not necessarily tell you how the object does so, this means that it leaves for classes implementing an interface to define its behaviour.

To extend from an Interface, keyword implements is used.

We can have a class extend from more than one Interface.

 
interface Storable {
	function getContentsAsText();
}
 
class Document implements Storable {
	public function getContentsAsText() {
		return "This is Text of the Document\n";
	}
}
 
class Indexer {
	public function readAndIndex(Storable $s) {
		$textData = $s->getContentsAsText();
		//do necessary logic to index
		echo $textData;
	}
}
 
$p = new Document();
 
$i = new Indexer();
$i->readAndIndex($p);

In the above example, Document and the Indexer class are two independant classes. The Indexer class is designed to index the contents of any text. Using the Storable interface above, we declare a method getContentsAsText() in the Document class. Because the Indexer class is only concerned with the TEXT, hence we can call getContentsAsText() method on the object of Document. This way any class if it implements the method getContentsAsText() can get indexed

Difference between Abstract Class and Interface

Abstract Classes

An abstract class can provide some functionality and leave the rest for derived class
The derived class may or may not override the concrete functions defined in base class
The child class extended from an abstract class should logically be related

Interface

An interface cannot contain any functionality. It only contains definitions of the methods
The derived class must provide code for all the methods defined in the interface
Completely different and non-related classes can be logically be grouped together using an interface

Subscribe below for article updates

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP Script to print nested array

admin — Fri, 16 Nov 2007 05:28:35 +0000

Here is a script that will allow you to print a nested array upto any level. Can I request you to please review this and let me know how this can be further optimized.

$array["sunil"] = "Bhatia";
$array[0] = array("one"=>"two",array(1,2,3,array(4,5,6)));
$array["sunil2"] = "Bhatia2";
 
processArray($array);
 
$count=0;
 
function processArray($array) {
 
	global $count;
 
	$count++; //this variable is for calculating tab space
 
	if(is_array($array) === true) {
 
		foreach($array as $key => $value) {
			if(is_array($array[$key]) === true) {
				processArray($array[$key]);
			}
			else {
				for($i = 1 ; $i < $count ; $i++) echo "  "; //change this to space ' ' if running from CLI
				echo $value."
";
			}
		}
	}
 
	$count--;
}

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 Tutorial – Inheritance in PHP5

admin — Thu, 15 Nov 2007 05:21:50 +0000

In the tutorial we will understand what is Inheritance in general and how to inherit classes in PHP5.

Definition of Inheritance:

Inheritance is the mechanism of deriving a new class from an existing class. It allows a sub-class / child class to share/inherit the attributes and behaviors of a base-class or parent class. These inherited attributes and behaviors are usually modified by means of extension.

PHP5 Inheritance

To inherit in PHP5, you should use the keyword ‘extends’ in the class definition. In PHP5 only single inheritance is allowed. Look at the example below:

class Person {
	private $name;
	private $address;
 
	public function getName() {
		return $this->name;
	}
}
 
class Customer extends Person {
	private $customer_id;
	private $record_date;
 
	public getCustomerId() {
		return $this->customer_id;
	}
 
	public getCustomerName() {
		return $this->getName();// getName() is in Person
	}
}

In the above example, class Customer extends from the Person class. This means that Customer class is the child class and the Person base class. The child class Customer extends the method getName() and calls it in the getCustomerName() method of the Customer class.

Inheritance and Access Specifiers
You can refer to the Access specifiers tutorial to understand what it means. Let’s understand the use of Access Specifiers with context to Inheritance.

Access specifiers specify the level of access that the outside world (other objects and functions) have on the data members / member functions of the class. Please note that all data members and member functions are public by default.

Lets look at how three access specifiers viz. private, public and protected behave in Inheritance:

1. private

A private access specifier is used to hide data and member functions. A method or data member declared as private can only be accessed by the class itself and neither the outside program nor the derived class can have access to it. Lets look at an example below:

class Customer {
	private $name;
	public $age;
 
	public function __construct($name, $age) {
		$this->name = $name;
		$this->age = $age;
	}
}
 
$c = new Customer("Sunil","28");
echo "Name : " . $c->name; //causes an error

In the above example, the statement;

echo “Name : ” . $c->name;

causes an error as we are trying to access $name that has been declared as a private member variable. We can however access the $age data member without any limitation as its public. We will learn more about public later in this tutorial.

The reason why data members are declared private is to avoid the outside programs to either accidently modify the values without necessary validation. If you make a data member private you should provide accessor/mutator methods to access. Read more about accessor/mutator methods here (You will have to scroll a bit down and reach to “Notes on Accessor and Mutator methods”)

Note: When you define a method as private that method can only be called from within that class and not from outside that is the global level script.

2. public

A public access specifier allows the data members and methods to be access from anywhere in the script. Lets look at an example below:

class Customer {
	private $name;
	public $age;
 
	public function __construct($name, $age) {
		$this->name = $name;
		$this->age = $age;
	}
}
 
$c = new Customer("Sunil","28");
echo "Age : " . $c->age; //prints 28

In the above example, the statement;

echo “Age : ” . $c->;age;

prints 28 on the screen as $age is a public variable and hence can be accessed from anywhere in the script. Please note that if you declare any data member or method without a access specifier it is considered as ‘public’.

3. protected

A protected access specifier allows the derived class to access the data member or member functions of the base class, whereas disallows global access to other objects and functions.

class Person {
	protected $name;
}
 
class Customer extends Person {
	function setName($name) {
		//this works as $name is protected in Person
		$this->name = $name;
	}
}
 
$c1 = new Customer();
$c1->setName("Sunil");
$c1->name = "Sunil"; //this causes error as $name is protected and not public

In the above example, the statement;

$this->name = $name;

in the setName() function is referring to the $name data member of the Person class. This access is only possible because the $name variable has been declared as protected. Had this been private; the above statement would have raised an error. Further, in the statement towards the end;

$c1->name = “Sunil”;

raises an error as $name in the Person class has been declared as protected and not public.

PHP5 Inheritance – Method Overriding
Lets learn how to override methods in PHP5, but before we understand how to override methods in PHP5; lets define method overriding.

Definition of Method Overriding:
Method overriding is when the function of base class is re-defined with the same name, function signature and access specifier (either public or protected) of the derived class.

The reason to override method is to provide additional functionality over and above what has been defined in the base class. Imagine that you have a class by the name of Bird from which you derive two child classes viz. Eagle and Swift. The Bird class has methods defined to eat, fly, etc, but each of the specialized classes viz Eagle and Swift will have its own style of flying and hence would need to override the flying functionality.

Lets look at an example with Bird:

class Bird {
	public function fly() {
		echo "Fly method of Bird Class called";
	}
}
 
class Eagle extends Bird {
	public function fly() {
		echo "Fly method of the Eagle Class called";
	}
}
 
class Swift extends Bird {
	public function fly() {
		echo "Fly method of the Swift Class called";
	}
}
 
$e = new Eagle();
$s = new Swift();
 
$e->fly();
echo "\n";
$s->fly();

Output:
Fly method of the Eagle Class called
Fly method of the Swift Class called

In the above example, we create two objects of class Eagle and Swift. Each of these classes have overridden the method fly() and have provided their own implementation of the fly() method that has been extended from the Bird class. The manner in which they have been extended the Bird class fly() method is not called as both these classes have provided a new functionality for the fly() method.

Another example of function overriding in Inheritance

class Person {
	function calculateAge($dob) {
		echo "calculateAge called of Person Class\n";
	}
 
}
 
class Customer extends Person {
	function calculateAge($dob) {
		echo "calculateAge called of Customer Class\n";
	}
}
 
$c1 = new Customer();
$p1 = new Person();
 
$c1->calculateAge("something");
$p1->calculateAge("something More");

Output:
calculateAge called of Customer Class
calculateAge called of Person Class

PHP5 Inheritance – Invoking parent methods
When you override a method of the base class, it’s functionality is completely hidden unless it has been explicitly invoked from the child class. To invoke a parent class method you should use the keyword parent followed by the scope resolution operator followed by the name of the method as mentioned below:

	parent::function_name();

Look at the example below:

class Person {
	public function showData() {
		echo "This is Person's showData()\n";
	}
}
 
class Customer extends Person{
	public function showData() {
		parent::showData();
		echo "This is Customer's showData()\n";
	}
}
 
$c = new Customer();
$c->showData();

Output:
This is Person’s showData()
This is Customer’s showData()

In the above example, look at the way in which the showData() function in the Customer child class is invoking the the Person parent class’s showData() function. When the program executes the showData() method if the Customer class is called which inturn calls the showData() function of the parent class. After the parent class’s showData() function complets its execution the remaining code in showData() function of the Customer class is executed.

PHP5 Inheritance – Invoking parent Constructor and Destructor
We can get the parent PHP5 constructor and PHP5 Destructor to be invoked in the same way as invoking the parent method, refer to the example below:

class Person{
	public function __construct() {
		echo "This is Person's __construct()\n";
	}
 
	public function __destruct() {
		echo "This is Person's __destruct()\n";
	}
}
 
class Customer extends Person{
	public function __construct() {
		parent::__construct();
		echo "This is Customer's __construct()\n";
	}
 
	public function __destruct() {
		parent::__destruct();
		echo "This is Customer's __destruct()\n";
	}
}
 
$c = new Customer();

Output:
This is Person’s __construct()
This is Customer’s __construct()
This is Person’s __destruct()
This is Customer’s __destruct()

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 Tutorial – Defining Class Constants

admin — Thu, 15 Nov 2007 04:46:36 +0000

In PHP4 the only constants that we would declare were global constants. In PHP5 it is possible to define a class level constant. These constants are specific to the class and hence don’t clutter the global level constant space.

To declare a constant in a class, PHP5 provides developers with a new keyword i.e. const; look at the example below:

class Customer {
	const TYPES = "Anything";
}
 
echo "Types are : " . Customer::TYPES;

In the above example, const is a keyword and TYPES is the name of the constant. Outside the class definition we echo the value of the constant by using the scope resolution operator (::) like this Customer::TYPES. Observe that we don’t need to create an object of the class to make use of the constant.

The next logical question is if we can create an object of the Customer class and using the scope resolution operator access the constant. The answer is no; reason – because a constant belongs to the class definition scope and not to an object.
Example of accessing Constants within a function

class Customer {
	const TYPES = "Anything";
 
	public function showConstant() {
		echo "Echo from showConstant() : " . Customer::TYPES;
	}
 
}
 
$c = new Customer();
$c->showConstant();

Output:
Echo from showConstant() : Anything

Some observations on Constants

Variables defined as constants cannot be changed.
Only a string or numeric value can be assigned to a constant.
Arrays, Objects & Expressions cannot be assigned to a constant.
A class constant can only be accessed via the scope resolution operator (::) executed on the class name.
A class constant cannot have access specifiers assigned to it (private, public & protected)

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)

PHP5 Tutorial – instanceOf Operator Explained

admin — Thu, 15 Nov 2007 03:52:46 +0000

PHP5 introduces a new operator by the name of instanceOf. instanceOf is used to check if two objects passed as operands belong to the same class. This check can also happen when an object is compared with a class name.

In PHP4 a similar functionality existed with a method is_a(), which has been replaced by the instanceOf operator in PHP5.

Lets look at an example below:

class Person {
	...
}
 
$p1 = new Person();
$p2 = new Person();
 
if($p1 instanceof $p2)
    echo "True";
else
    echo "False";

In the above example, we are comparing to check if $p1 and $p2 belong to the same class i.e. Person. In this case $p1 and $p2 both belong to the same class Person and hence the output is True. Please note that line number 8 can also be written as if($p2 instanceof $p1) and will yield the same output.

You can also use instanceOf operator to compare an object with the name of the class, look at the example below:

class Person {
	...
}
 
$p1 = new Person();
 
if($p1 instanceof Person)
    echo "True";
else
    echo "False";

In the above example, on line number 7 $p1 object is being compared to check if its a Person type of object. In this case $p1 is a Person type of object and hence the output is True.

Behaviour of instanceOf operator in inheritance

class Customer extends Person {
	...
}
 
$p1 = new Person();
$c1 = new Customer();
 
if($c1 instanceof $p1)
    echo "True";
else
    echo "False";

In the above example, on line number 8 $c1 child class object is being compared with $p1 which is a parent class object. This is possible because Customer class is a child of the Person Class, just that the Customer class is a specialized form of the Person class and therefore this becomes possible. However the reverse is not possible, we cannot compare if($p1 instanceof $c1) and will result in an error.

Related Posts on PHP5 Tutorial – Object Oriented Programming (OOPS)