PHP Crat

Realtime Media Streaming Applicaions on the Web

noreply@blogger.com (anton) — Sun, 23 Jan 2011 13:38:00 +0000

For a long time, streaming media contents on the web seems to be more expensive as it challenges over the bandwidth and server cost. There are few comparable number of media streaming servers are available, and to name a few of them: FMS(Flash Media Server) from Adobe, Wowza, Red5(Open source) (See comparisons) and Erlyvideo. The recent version of FMS(FMS4) supports multi-cast with P2P streaming, which eliminate the need of costly servers and bandwidth cost(but still available only as a beta service with limited access through developer API key).

Streaming media contents like static images and video are also a bit complicated with mostly used general web servers like Apache, when comparing with response time. And hence it is also required to identify special purpose web servers to increase the response time while serving these static contents. Few web servers like Lighttpd and NginX are notable web servers which performs quite better in serving static contents. The popular rich content serving websites like Youtube and Wikipedia are using NginEx to serve their images and video contents.

Cisco's WebEx provides an excellent platform to integrate their online meeting center with any web applications. WebEx's integrated meeting center is a licensed cloud solution to facilitate both one-to-one and multi-cast video/audio conferencing system with all required meeting components like desktop sharing, chatting, tele-conferencing and shared whiteboard. WebEx's recordng feature is doing an excellent stuff as it's capability to record the complete meeting activity in a single playback stream.

Ruby On Rail (RoR) - the De-Facto for Enterprise Application Development Platform

noreply@blogger.com (anton) — Sun, 09 Jan 2011 17:43:00 +0000

Ruby

Ruby is a dynamic, reflective, general purpose object-oriented programming language with a super clean syntax that makes programming elegant and fun. It combines Smalltalk's conceptual elegance with Python's ease of use and learning, and Perl's pragmatism.

It's language design said to be follow the principle of least astonishment(POLA), which means it minimize the confusion for experienced users.

Ruby was originally designed by Yukihiro Matsumoto in 1993 and the first version has released on December 25, 1996.

Rails (The Framework for Ruby)

Less software
Less software means you write fewer lines of code to implement your application. Keeping the code small means faster development and fewer bugs, which makes the code easier to understand, maintain, and enhance. In contrast, you will see how Rails cuts your code burden.

Convention over configuration
Ruby on Rails uses the Model-View-Controller (MVC) architecture pattern to organize application programming. Rails seemed to make everything easier, with its Convention Over Configuration and Don't Repeat Yourself principles(DRY). Convention over configuration means an end to verbose XML configuration files; -there aren't any in Rails! Instead of configuration files, a Rails application uses a few simple programming conventions that allow it to figure out everything through reflection and discovery.

The key factors to be considered on enterprise web application development

Scaling and Performance
Development Speed
Development Tools
Maintainability

The Rail's Hot-Spots

Standardized project layout,
Scaffolding and generators,
MVC framework,
ActiveRecord
Web forms and Form helpers
Custom Routing
I/O filters
Plugins
Rail's CLI Rake tasks
HAML
Capistrano

With JRuby/Warbler, Rails can be run on Java Application Servers. Learning RoR would be much easier than JSP / Struts / Spring / Hibernate. Rails has built in support for the idea of having a different set of settings for Development, Test and Production.

Web Servers
Applications built on RoR can be run on web servers like Mongrel, WEBrick. But it can also be run on many other web servers(as a module - Passenger for example - or via CGI, FastCGI or mod_ruby) such as Lighttpd, Abyss, Apache, nginx and many others. More recently, the Passenger web servers replaced Mongrel as the most used web server.

A few case studies to compare RoR's capabilities: Twitter, Scribd, Hulu, Blinksale, Crunchbase, Slideshare, Medhelp, Github, Jobster.

Building real time web applications with XMPP

noreply@blogger.com (anton) — Sat, 25 Dec 2010 19:01:00 +0000

Ajax has been used on the web for a long, to make the web pages updates their content instantly without reloading the page again and again. But the fall back is to make the page poll to the server every time for new updates. The possibility that the server may encounter unnecessary request overhead, if at all there are no new content updates from the server.

The term Comet, Reverse Ajax, Ajax Push, are coined to take up advantage using the content push or content streaming technology on the web pages. Although web-sockets are another similar technology, but challenged with the browser compatibility and security issues

The XMPP(Extensible Messaging and Presence Protocol) is an open technology for real-time communication. This XMPP candidate seem to be the more appropriate contender in implementing Comet, Ajax push or Content streaming on the web. There are a plenty of of XMPP Client implementation are curently available for most of the platforms including javascript, php, python, flex and etc. I thrilled to see the javascript implementation xmpp4js, and it works fantastic on cross-browser.

I did an experiment with Openfire xmpp server and apache/nginx, with both javascript and php xmpp client(xmppphp) implementations. It seems promising, that more web apps to come with these kind of Ajax-Push and Real-time http content streaming technologies.

PHP5 - Performance tuning using static variables

noreply@blogger.com (anton) — Sat, 26 Sep 2009 14:51:00 +0000

In general, the php static variables would hold the value, which has been set by a last known action.

Since the static variables are not just bound within a scope of an object or an instance, and rather these variable's can be accessed within a global context by the use of Scope Resolution Operator(::) instead of access using objects.

Problem

Say, if you have a table in the database called "config" and it holds all basic configurations required to your website. Your code will make a repeated call in every routines to refer these configurations. And now the problem occurring is the necessity to fire query to db each time, when trying to refer the configurations.

Solution

If we can able to cache the variable in a global context, the unnecessary query overhead to the database can be minimized.

Whenever a query has been fired to the config table, cache the return value and assign it to a static variable. If the static variable has some values already exists, do not query again the database; instead, use the value in the static variable.

Example

<?php
class Config{
public static $arrConfigData;
public function getSetting($settingName){

if(isset(self::$arrConfigData[$settingName]) && !empty(self::$arrConfigData[$settingName])){
return self::$arrConfigData[$settingName];
}else{
//..Write sql's to retreive the value of the requested setting and assign it to as $retVal
$retVal = $dbResultVal;
}

//Assign back value to static variable
self::$arrConfigData[$settingName] = $retVal;
return $retVal;

}
}

//Calling the method:
$objConfig = new Config();
$objConfig->getSetting('setting1');
$objConfig->getSetting('setting1');
$objConfig->getSetting('setting1');
?>

Now, even though you have actually making multiple call to the same setting, the db will get accessed only once. For each other tries, it will simply refer the data from the static variable itself; and thus reducing the overhead to the database. Note that, this is the same way as the normal singleton objects works.

Customization and Internalization of Symfony-Doctrine Forms

noreply@blogger.com (anton) — Fri, 21 Aug 2009 18:50:00 +0000

In general we create a doctrine schema from the database by using the following command
c:\xampp\htdocs\testproject\> symfony doctrine:build-schema

To build forms which are associated with the database, we have to run the following command
c:\xampp\htdocs\testproject\> symfony doctrine:build-forms

The next step after built the forms, we can configure and customize the form labels, widgets, error-texts, and help-texts

The default function configure() will work for all common customization required for a form. The below are the symfony functions used to customize the forms.

To assign custom label to form field:
$this->widgetSchema->setLabel('firstname', 'Enter your first name');

To assign help text to form field:
$this->widgetSchema->setHelp('firstname','Provide your first name');

Rendering forms in template:
To render a form input field with custom style:
echo $form['firstname']->render(array('style'=>'mystyle', 'id'=>'field id'));

To render a label of the form input field with custom style:
echo $form['firstname']->renderLabel(array('style'=>'mystyle', 'id'=>'field id'));

To render a error string for a form input field with custom style:
echo $form['firstname']->renderError(array('style'=>'mystyle', 'id'=>'field id'));

Displaying errors in template:


<?php if ($sf_request-<hasError()): ?>
  <ul class="error_list">
    <?php foreach ($sf_request->getError() as $error): ?>
      <li><?php echo $error ?></li>
    <?php endforeach; ?>
  </ul>
<?php endif; ?>

Display help text of a form in template:
$form->getWidgetSchema()->getHelp('firstname');

To apply a translation scheme to the form:
$this->widgetSchema->getFormFormatter()->setTranslationCatalogue('catalog');

firstname.[language].xml

Sample XLIFF file 'catalog.fr.xml' placed in apps/applicationName/i18n/firstname.fr.xml


<?xml version="1.0" ?>
<xliff version="1.0">
  <file original="global" language="en" datatype="plaintext">
    <body>
      <trans-unit>
        <source>Name</source>
        <target>Nom</target>
      </trans-unit>
      <trans-unit>
        <source>Email address</source>
        <target>Adresse email</target>
      </trans-unit>
      <trans-unit>
        <source>Body</source>
        <target>Message</target>
      </trans-unit>
    </body>
  </file>
</xliff>

To get user-submited-form data in action:
$this->getRequestParameter($elementName)

To get all posted data as array
$request->getPostParameters();

To get all post and get data as array
$this->getRequest()->getParameterHolder()->getAll();

Custom validators in action file:
public function validateActionname(){
if(validation successful){
return true;
}else{
return false;
}
}

Form validation using YAML files:
create actionname.yml under validate/ folder of the module. And define validation schema for necessary fields as below:

fields:
  name:
    required:
      msg: The name field cannot be left blank
    sfStringValidator:
      min: 2
      min_error: This name is too short (2 characters minimum)
      max: 100
      max_error: This name is too long. (100 characters maximum)

Form data re-population if validation fails:
Specify your validation YAMAL file also the fillin feature as below:

fillin:
  enabled: true # Enable the form repopulation
  param:
    name: test # Form name, not needed if there is only one form in the page
    skip_fields: [email] # Do not repopulate these fields
    exclude_types: [hidden, password] # Do not repopulate these field types
    check_types: [text, checkbox, radio, select, hidden] # Do repopulate these
    content_type: html # html is the tolerant default. Other option is xml an

Note: Any changes on the yml files, requires 'clearing the symfony cache', to reflect changes to the application.

more details..

Sending e-mail/SMTP e-mails using sfMail addon from Symfony framework

noreply@blogger.com (anton) — Sun, 26 Jul 2009 08:24:00 +0000

Finally I was able to send emails in my recent pet-project using sfMail. Simply Amazing!

1. Creating templates for your emails

Create a separate module to create our e-mail templates for sending mails. In this tutorial we create a module "mailTemplate" to generate all email-templates. To create the module run the below command at command line:

c:\xampp\htdocs\myproject\> symfony generate:module frontend mailTemplate

-here myproject is your project directory
-frontend is your application name, which you already created
-mailTemplate is the new module we create.

Configuring view layer for the mail-templates

To configure the mailTemplate module to use the 'sfMailView' to generate templates for the e-mail presentation, create module.yml file under the 'config' directory under the directory mailTemplate. So it will be looks like for our project:

..\myproject\apps\frontend\modules\mailTemplate\config\module.yml

The configuration for accessing the special mail view layer is as below:
(download the module.yml file used in this tutorial)

all:
view_class: sfMail

Securing the mailtemplates from accessing outside

To secure our mail templates from accesing outside, the configuration in the module.yml is as below:

all:
  is_internal: on

So now our final module file will look like,
(download the module.yml file used in this tutorial)

all:
  view_class: sfMail
  is_internal: on

2. Configuring the mailer

sfMail is simple, but a powerfull symfony addon built on top of phpMailer. sfMail will will look for it's configurations under your mailTemplate module. So we need to create a file mailer.yml and put in the config directory under the mailTemplate folder. So the file path will looks like as below:

..\myproject\apps\frontend\modules\mailTemplate\config\mailer.yml

See below the e-mail configured for sending smtp e-mails:
(download the mailer.yml file used in this tutorial)

default:
  deliver: on
  mailer: smtp
  domain: localhost.localdomain
  hostname: smtpHostname
  port: 25
  username: smtpUsername
  password: smtpPassword

  wordwrap: 80

  .headers:
    priority: 3
    content_type: text/plain
    charset: utf-8
    encoding: 8bit

3. Creating a sample mail template

The action class

..\myproject\apps\frontend\modules\mailTemplate\actions\actions.class.php

(download the actions.class.php file used in this tutorial)

<?php

/**
* mailTemplate actions.
*
* @package sfd
* @subpackage mailTemplate
* @author Your name here
* @version SVN: $Id: actions.class.php 12479 2008-10-31 10:54:40Z fabien $
*/
class mailTemplateActions extends sfActions
{
/**
* Executes index action
*
* @param sfRequest $request A request object
*/
public function executeGetSampleTemplate(sfWebRequest $request)
{
//Get the receipient email set in the calling action
$recepientEmail = $this->getRequest()->getAttribute('recepientEmail');

$objMail = new sfMail();
$objMail->addAddress($recepientEmail);
$objMail->setFrom('Marshal Anto Robin <antorobin@gmail.com>');
$objMail->setSubject('Symfony sample sfmail test');
$objMail->setPriority(1);

//To embed images
$objMail->addEmbeddedImage(sfConfig::get('sf_web_dir').'/images/logo.gif', 'CID1', 'Logo', 'base64', 'image/gif');

// To attachment documents
$objMail->addAttachment(sfConfig::get('sf_data_dir').'/MyDocumentSample.doc');

// To attachment simple string
$objMail->addStringAttachment('this is few cool text to embed', 'file.txt');

//This line is importand; otherwise you mail wont send.
$this->mail = $objMail;

//These variables are from the action where the email-call function is supposed to be called
//You may assign variables available to the email-action from your calling action as below:
//$this->getRequest()->setAttribute('nickname', $nickname);

//Here you are passing some data available to the email template
$this->nickname = $this->getRequest()->getAttribute('nickname');
}
}

The template for the action

..\myproject\apps\frontend\modules\mailTemplate\templates\getSampleTemplateSuccess.php

(download the getSampleTemplateSuccess.php file used in this tutorial)

Dear <?php echo $nickname ?>,

Thanks for reading this tutorial "Symfony - Using sfmail to sending your e-mails".

sfMail is simple but a powerful email addon from symfony. You can create much configurable e-mail templates on the fly. Translate email contents using i18N based on your receipient's language. Thanks to symfony's great i18n support using __() function, and easy translation catalogues.

Thanks,
Marshal Anto Robin
(antorobin@gmail.com)

4. Sending the emails from action

Send emails from your action file like the sample given below:

(download the sample action.class.php file used in this tutorial, for calling sendEmail method)

<?php

/**
* user actions.
*
* @package sfd
* @subpackage user
* @author Your name here
* @version SVN: $Id: actions.class.php 12479 2008-10-31 10:54:40Z fabien $
*/
class userActions extends sfActions
{
/**
* Executes index action
*
* @param sfRequest $request A request object
*/
public function executeSendEmail(sfWebRequest $request)
{
$nickname = 'marshalR';
$recepientEmail = 'antorobin@gmail.com';

$this->getRequest()->setAttribute('nickname', $nickname);
$this->getRequest()->setAttribute('recepientEmail', $recepientEmail);

//Parameters used in sendEmail: mailer-module-name, mailer-action-name
$objController = sfContext::getInstance()->getController();
$raw_email = $objController->sendEmail('mailTemplate', 'getSampleTemplate');

//To log the mail content
$this->logMessage($raw_email, 'debug');

}
}

5. Test the scripts

Clear the cache before test the scripts:
Use the following command in command line to clear the cache

symfony cc

c:\xampp\htdocs\myproject\> symfony cc

Go to the url where your email-calling scripts are written,
say if it's in user module and sendEmail action,

http://localhost/myproject/web/user/sendEmail

Now hopefully you are sending emails successfully. Thanks to symfony's sfMail addon.

6. Sending the emails from batch-scripts

(From outside of the action class)

If you want to send emails from outside of an action, say you want to send emails as batch0process, then you need to use the following method to do that

<?php

define('SF_ROOT_DIR', realpath(dirname(__FILE__).'/..'));
define('SF_APP', 'myapp');
define('SF_ENVIRONMENT', 'test');
define('SF_DEBUG', false);

require_once(SF_ROOT_DIR.DIRECTORY_SEPARATOR.'apps'.DIRECTORY_SEPARATOR.SF_APP.DIRECTORY_SEPARATOR.'config'.DIRECTORY_SEPARATOR.'config.php');

$raw_email = sfContext::getInstance()->getController()->sendEmail('mailTemplate', 'getSampleTemplate');

7. Download the mailTemplate module used in this tutorial

Click here to download the source code of the mailTemplate module

Installing Symfony Framework

noreply@blogger.com (anton) — Sun, 19 Jul 2009 13:58:00 +0000

Before installing symfony using pear, you need pear installed in your machine. To install php-pear in your system, you can run the "go-pear.bat" file in your xampp-php installation folder.

if you have installed the pear in your machine, follow the below at your command-prompt to install symfony

c:\>pear upgrade
c:\>pear channel-discover pear.symfony-project.com
c:\>pear install symfony/symfony

Now that you have successfully installed symfony in your system.

To create new projects using symfony framework, we need to run some tools using command line inteface. For that we need to add the PHP's binary path to the system environment variable.

Goto start > settings > control panel. Click on the system icon, Select the advanced tab, and click "Environment variable" button as shown in the screen shot:

Now you will get a screen like below:

In the system variable box choose path and click edit, and the dialog will prompt you to edit the path variable. Add the path of the php binary with the path value following a semicolon as below:

Symfony requires at least PHP 5.2. To check your php version, type the following in command prompt
c:\>php -v

it will display the version informatiom as below:

Now test your symfony's installation by type the following in command prompt:
c:\>php symfony -V
this will display you the newly installed symfony's version information.

Creating Project in Symfony

Symfony organize each project by a specific folder structure, that helps manage the project's code easily. Symfony's command line tool itself generate all the folder structure for your project. To do this type the following in your command line:

1. navigate to your projct folder inside the apache's htdocs folder.
say you created myproject directory under the we root c:\xampp\htdocs.

2. Run the following symfony's command line tool to create your new project 'myproject'
c:\xampp\htdocs\myproject\> php C:\xampp\php\symfony generate:project myproject

This will create the file structure for your new project as below

Creating the Application

One symfony project may contain multiple applications; generally any we application has atleast two applications as the "frontend presentation(frontend)" and the "admin interface(backend)"

To create new application(say frontend) navigate to your project folder in command prompt and run the following command:

c:\xampp\htdocs\myproject\> php symfony generate:app frontend

This will create a unique folder structure inside the frontend directory as below:

For more information about creating a project in symfony

Creating a Module

A module is a part of an application which has n number of actions based on the size of the module. In this sample application i am creating module called "login"
For this run the following command:
C:\xampp\htdocs\myproject>php symfony generate:module frontend login

This will create a login module under the frontend application. And this module has two folders generated under this, and are actions and templates as the screenshot below:

Creating Actions

Inside actions folder within every module there is a file named actions.class.php. This file is used to define all actions belonged to that module. And all corresponding template files will be placed inside the templates folder under that module.

Naming conventions

To describe an action, the name should be "executeActionname()" and the template name would be "actionnameSuccess.php"

Sample action named as index

Template for the action named as index

To access the application in browser:
http://localhost/myproject/<modulename>/<actionname>

So for our sample application, it will be
http://localhost/myproject/login/index

Why Symfony

noreply@blogger.com (anton) — Sun, 19 Jul 2009 13:54:00 +0000

Symfony is a MVC(Model-View-Controller) framework, and It establishes a set of best practices, which helps to develop maintainable, secure and scalable Enterprise Level web applications.

Why symfony:

Open Source (MIT License)
Deploy Enterprise Applications quickly using RAD (Rapid Application Development) methodology
Manageable even for larger applications
Completely Object Oriented
Switch between any databases with no modifications on the code level
Easy Form Handling: Fillin, Validation and Connecting with ORM(doctrine and propel)
Large and ever growing community support ( more than 650 available plugins)
In-built cache support
Internationalization and Localization(I18n, L10n)
Bridges to other frameworks
Development/debugging environments
Themes based on url
Extending the framework is easy with writing own filters, helpers, plugins.
Easily overriding the control layers to support with smarty like template frameworks

Symfony is developed and promoted by Sensio Labs, a French Web Agency well known for its innovative views on web development.

How to select 'database storage engine' for your MySQL tables

noreply@blogger.com (anton) — Tue, 07 Apr 2009 14:06:00 +0000

MySQL supports several storage engines and, are MyISAM, InnoDB, MERGE, MEMORY (HEAP), BDB (BerkeleyDB), EXAMPLE, FEDERATED, ARCHIVE, CSV and BLACKHOLE storage engine.

MyISAM is the storage engine which is used for non-transactional tables, and where these tables undergo huge volume of access with search and select queries, other than storing and updating the data. MyISAM is the default storage engine for MySQL database unless otherwise if you are explicitly declared for.

The InnoDB and BDB storage engines are used for transaction-safe tables. The InnoDB storage engine supports FOREIGN KEY referential-integrity constraints.

The MEMORY storage engine provides in-memory tables, which are . Tvisible only on the run-time and destroys itself after the script ends it execution. The MERGE storage engine allows a collection of identical MyISAM tables to be handled as a single table. The MEMORY and MERGE storage engines also used for non-transactional tables similar to that of MyISAM.

The NDBCLUSTER (also known as NDB) storage engine is used by MySQL Cluster to implement tables that are partitioned over many computers such as cloud computing.

The ARCHIVE storage engine is used for storing large amounts of data without indexes with a very small footprint. And it supports only INSERT and SELECT operations, but not DELETE, REPLACE, or UPDATE. It does support ORDER BY operations and BLOB columns.

The CSV storage engine stores data in text files as the comma-separated values format. This storage engine does not support indexing.

The BLACKHOLE storage engine is a 'no-op' storage engine, which can't able to store any data, but used only for logging and analysing the query performances.

In FEDERATED storage engine the queries on the local server are automatically executed on the remote tables. No data will eb stored on the local tables.

The EXAMPLE storage engine is a sample engine that does nothing. The purpose of keeping this engine is to showcase as an example in the MySQL source code which illustrates how to begin writing new storage engines.

The differences between mysql_pconnect() and mysql_connect()

noreply@blogger.com (anton) — Tue, 07 Apr 2009 12:51:00 +0000

mysql_pconnect()

Open a persistent connection to a MySQL server.

mysql_pconnect() acts very similar to mysql_connect() with the following two major differences.

1. When trying to connect with the database, the function would first try to find if any persistent link that's already open with the same host, username and password. It would use the existing one if found and will return an identifier for the connection. These connection identifiers are usually called as child connections and must not produce equal overhead as a fresh new connection would do.

2. These persistent connection to the Database server will not be closed when the execution of the script ends, and the link will remain open and accessible for future use. And also the function mysql_close() can not close links established by these persistent conection.

Persistent connections are good if the overhead to create a connection to the database server is high.

There should be some drawbacks using persistent connections, that if you are using a database with connection limits that are exceeded by persistent child connections. For example, say if your database has a limit of 100 simultaneous connections, and in the course of a busy server session, the 101th child thread will not be able to connect. And again if any connection on your database caused an infinite loop or a similar bug on your script, then it will be the major problem with a databases with limited persistent child connections.

mysql_connect()

Opens or reuses a connection to a MySQL server.

The link to the server will be closed as soon as the execution of the script ends, unless it's closed earlier by explicitly calling mysql_close().

syntax: resource mysql_connect ( [string $server [, string $username [, string $password [, bool $new_link [, int $client_flags]]]]] )

The fourth argument (bool $new_link) is notable here as it will instruct the script engine to always open a new link whenever a connection is requested, even if a connection with the same parameter has already established.

Classes and Objects in PHP 5

noreply@blogger.com (anton) — Tue, 07 Apr 2009 07:05:00 +0000

Class:

syntax: class classname{ }

In php5 the handling of objects has been completely rewritten, and specifically to allowing for better performance and more features to use objects efficient.

Classes begins with the keyword 'class', followed by a the class name which the user may choose. The keyword 'new' used to create object from a class.

Inside the scope of a current class context, it is possible to create a objects by using keywords 'self' and 'parent';
eg: new self; new parent;

A class can inherit methods and members of another class by using the keyword 'extends';
eg: class inheritedclass extends parentclassname{ }

Any inherited methods and members of the parent class can be overridden, unless the parent class has defined a method byusing the keyword 'final', by re declaring those methods or members with the same name defined in the parent class.

Autoloading

By defining an __autoload function, during the object creation, the scripting engine is given a last chance to load the required class before PHP fails with an error.

The function __autoload gets the class name whenever any object gets created. so we can include the class definition for the particular class. So the main usage is to avoid include lot of class file in every page.

eg:
function __autoload($nameOfClass) {
require_once $nameOfClass . '.php';
}

Any exceptions thrown in __autoload function cannot be caught in the catch block and thus it results in a fatal error.

Namespaces

we can have our classes within unique namespace and prevent code clashes.

namespace must be the first statement in the script

eg:
//in file1.php
namespace ProjectOne;
class myClass{ }

//in file2.php
require "file1.php";
use ProjectOne as One;
$myObj = new One::myClass;

Constructors and destructors

Constructor

Constructor is suitable for any initialization that the object may require before it is used.
syntax: void __construct(args){}

Destructor

The destructor method will be called automatically when as all references to a particular object are removed or when the object is explicitly destroyed or in any order in shutdown sequence.

parent destructors will not be called implicitly/ automatically by the engine. we need call manually by calling parent::__destruct() in the destructor body.

Attempting to throw an exception from a destructor (called in the time of script termination) causes a fatal error.

syntax: void __destruct ( void ){}

Visibility

The visibility of a member property or method of a class can be defined by prefixing the declaration with the keywords: public, protected or private. Public declared items can be accessed everywhere. Protected limits access to inherited and parent classes (and to the class that defines the item). Private limits visibility only to the class that defines the item.

Parent and child class can have a private set of private variables that no-one else has access to, other than the class itself even it was inherited. Which means private members of a class cant be overridden.

Scope resolution operator (::)

The Scope Resolution Operator is a token that allows access to static, constant, and other members or methods of a class. Two special keywords self and parent are used to access members or methods from inside the class definition. Call it by the name of the class, when referencing these from outside the class.

Static keyword

Declaring class members or methods as static makes them accessible without needing an instantiation of the class. A member declared as static can not be accessed with an instantiated class object (though a static method can).

static methods are callable without an instance of the object created, the pseudo variable '$this' is not available inside the method declared as static.
Static properties cannot be accessed through the object using the arrow operator ->, use :: instead.

static variable are used to store data inside a function or method. see: http://phpblog.info/2008/07/26/when-to-use-static-php-variables

Class constants

keyword used to declare a constant is 'const'. Constants differ from normal variables in that you don't use the '$' symbol to declare or use them. The value must be a constant expression, and should not be a variable, a class member, result of a mathematical operation or a function call.

Class abstraction

It is not allowed to create an instance from a class that has been defined as abstract. Any class that contains at least one abstract method must also be abstract. Methods defined as abstract simply declare the method's signature they cannot define the implementation.

when overridding an abstarce method or abstarct member property, the visibility would be less restrictive or same; For example, if the abstract method is defined as protected, the function implementation must be defined as either protected or public, but not private.
An abstract class that extends another abstract class doesn't need to define the abstract methods from the parent class.

Usage: sometime different classes have same methods which are differ in their functionalities.

Difference between abstarct and interface:
The difference between an interface and an abstract class, is that an interface does not define the behavior of an object. Rather, it defines how you work with a class.

eg:
class X implements Y { } // this is saying that "X" agrees to speak language "Y" with your code.
class X extends Y { } // this is saying that "X" is going to complete the partial class "Y".

Overloading

PHP's interpretation of "overloading" is different than most object oriented languages. Overloading traditionally provides the ability to have multiple methods with the same name but different quantities and types of arguments.

Overloading in PHP provides means to dynamically "create" members and methods. These dynamic entities are processed via magic methods; and are as below:
Member overloading:
void __set ( string $name , mixed $value ) - is run when writing data to inaccessible members.
mixed __get ( string $name ) - is utilized for reading data from inaccessible members
bool __isset ( string $name ) - is triggered by calling isset() or empty() on inaccessible members.
void __unset ( string $name ) - is invoked when unset() is used on inaccessible members.

Method overloading
mixed __call ( string $name , array $arguments ) - is triggered when invoking inaccessible methods in an object context.
mixed __callStatic ( string $name , array $arguments ) - is triggered when invoking inaccessible methods in a static context.

Object iteration

object's elements can be viewed as array format by using the print_r() function.

Magic methods

The function names __construct, __destruct, __call, __callStatic, __get, __set, __isset, __unset, __sleep, __wakeup, __toString, __invoke, __set_state and __clone are magical in PHP classes. You cannot have functions with these names in any of your classes unless you want the magic functionality associated with them.

The __invoke method is called when a script tries to call an object as a function. eg: $obj(5);
The __toString method allows a class to decide how it will react when it is converted to a string. eg: echo $obj;

Final keyword

The keyword 'final' prevents child classes from overriding a method. If the class itself is being defined final then it cannot be extended.

Object cloning

It is nothing but a 'copy constructors'. we can extend the functionality by using the __close function inside the class. __clone function will be invoked when any object cloned using clone keyword.

If you intend to pass a copy of an object to a function, then you should use 'clone' to create a copy explicity. In PHP5, objects appear to always be passed by reference (unlike PHP4).

Type hinting

PHP 5 introduces Type Hinting. Functions are now able to force parameters to be objects (by specifying the name of the class in the function prototype) or arrays.
eg:
class class1(class2 $obj1){}
function funct1 (array $my_array)