static. The static properties and methods do not belong to the instance of the class. They belong to the class itself. They are accessible through the scope resolution operator (::). <?phpIn the above PHP script, we have a
class Sys {
public static function println($string) {
echo "$string\n";
}
}
Sys::println("PHP");
Sys::println("PERL");
Sys::println("Python");
Sys::println("Pike");
?>
static println() method. It prints a string and starts a new line. This example is inspired by the Java language. Sys::println("PHP");
We do not need an object to call println() method. We call staticmethods by specifying the class name, followed by double colon operator and the method name. $ php static1.phpThis is the output of the script.
PHP
PERL
Python
Pike
<?phpAnd now we have an example with a
class Math {
public static $PI = 3.14159265359;
}
echo Math::$PI . "\n";
?>
static variable. echo Math::$PI . "\n";We access the variable by specifying the class name, followed by the scope resolution operator and the variable name.
final keyword is a matter of design of the application. Some classes should not be extended and some methods should not be overriden. This behaviour is enforced by the final keyword. <?phpThis PHP script won't compile. We get an error "Cannot override final method Base::say()".
class Base {
final function say() {
echo "Base class";
}
}
class Derived extends Base {
function say() {
echo "Derived class";
}
}
?>
<?phpIn the previous PHP script, we have a prototype base Math class. The sole purpose of this class is to provide some helpful methods and constants to the programmer. (In our case we have only one method for simplicity reasons.) It is not created to be extended. To prevent uninformed other programmers to derive from this class, the creators made the class
final class Math {
static function getPI() {
return 3.141592;
}
}
class DerivedMath extends Math {
function say() {
echo "DerivedMath class";
}
}
?>
final. If you try to run this PHP script, you get the following error: "Fatal error: Class DerivedMath may not inherit from final class (Math)". copy keyword, which performs a shallow copy by default. It calls the object's __clone() method. We can implement the method to create our custom deep copy. In PHP 5, all objects are assigned by reference. <?phpIn the above PHP script, we define two custom objects. Object and Color. The Object object will have a reference to the Color object.
class Object {
public $id;
public $size;
public $color;
function __construct($id, $size, $color) {
$this->id = $id;
$this->size = $size;
$this->color = $color;
}
}
class Color {
public $red;
public $green;
public $blue;
function __construct($red, $green, $blue) {
$this->red = $red;
$this->green = $green;
$this->blue = $blue;
}
}
$color = new Color(23, 42, 223);
$object1 = new Object(23, "small", $color);
$object2 = clone $object1;
$object2->id++;
$object2->color->red = 255;
$object2->size = "big";
print_r($object1);
print_r($object2);
?>
$color = new Color(23, 42, 223);We create an instance of the Color object.
$object1 = new Object(23, "small", $color);An instance of the Object object is created. It passes the instance of the Color object to its constructor.
$object2 = clone $object1;We perform a shallow copy of the Object object.
$object2->id++;Here we modify the member fields of the cloned object. We increment the id, change the red part of the color object and change the size to "big".
$object2->color->red = 255;
$object2->size = "big";
print_r($object1);We use the
print_r($object2);
print_r() function to compare the results. $ php shallowcopy.phpWe can see, that the ids are different. 23 vs 24. The size is different. "small" vs "big". But the red part of the color object is same for both instances. 255. Changing member values of the cloned object did not affect the original object. Changing members of the referenced object has affected the original object too. In other words, both objects refer to the same color object in memory.
Object Object
(
[id] => 23
[size] => small
[color] => Color Object
(
[red] => 255
[green] => 42
[blue] => 223
)
)
Object Object
(
[id] => 24
[size] => big
[color] => Color Object
(
[red] => 255
[green] => 42
[blue] => 223
)
)
<?phpIn this PHP script, we have implemented the
class Object {
public $id;
public $size;
public $color;
function __construct($id, $size, $color) {
$this->id = $id;
$this->size = $size;
$this->color = $color;
}
function __clone() {
$red = $this->color->red;
$green = $this->color->green;
$blue = $this->color->blue;
$this->color = new Color($red, $green, $blue);
}
}
class Color {
public $red;
public $green;
public $blue;
function __construct($red, $green, $blue) {
$this->red = $red;
$this->green = $green;
$this->blue = $blue;
}
}
$color = new Color(23, 42, 223);
$object1 = new Object(23, "small", $color);
$object2 = clone $object1;
$object2->id++;
$object2->color->red = 255;
$object2->size = "big";
print_r($object1);
print_r($object2);
?>
__clone() method. function __clone() {
$red = $this->color->red;
$green = $this->color->green;
$blue = $this->color->blue;
$this->color = new Color($red, $green, $blue);
}
Inside the __clone() method, we copy the red, green and blue member fields and create a new Color object. Now, the $color field points to a different Color object. $ php deepcopy.phpNow the red part of the referenced Color object is not the same. The original object has retained its previous 23 value.
Object Object
(
[id] => 23
[size] => small
[color] => Color Object
(
[red] => 23
[green] => 42
[blue] => 223
)
)
Object Object
(
[id] => 24
[size] => big
[color] => Color Object
(
[red] => 255
[green] => 42
[blue] => 223
)
)
set_error_handler() we can do a workaround for this. <?phpIn the above PHP script, we intentionally divide a number by zero. This leads to an error. The error is not an exception and is not caught by the
set_error_handler("error_handler");
function error_handler($errno, $errstring, $errfile, $line, $trace) {
throw new ErrorException($errstring, $errno, 0, $errfile, $line);
}
try {
$a = 0;
$b = 32;
$c = $b / $a;
} catch(ErrorException $e) {
echo "Error occurred\n";
echo $e->getMessage(), "\n";
}
?>
catch keyword. set_error_handler("error_handler");
The set_error_handler() function sets a user defined error handler function. function error_handler($errno, $errstring, $errfile, $line, $trace) {
throw new ErrorException($errstring, $errno, 0, $errfile, $line);
}
Inside the set_error_handler() function, we throw an ErrorException. This exception is later caught by the catch keyword. try {
$a = 0;
$b = 32;
$c = $b / $a;
}
The code, that we are checking against an error is put inside the block following the try keyword. } catch(Exception $e) {
echo $e->getMessage();
}
The catch keyword is used to catch an exception, which occurred. To find out more info, we call the getMessage() method on the exception object. $ php zerodiv.phpThis is the output of our PHP script.
Error occurred
Division by zero
Exception is a base class for all exceptions. We can create our own exceptions derived from this base class. <?phpLet's say, we have a situation in which we cannot deal with big numbers.
define("LIMIT", 333);
class BigValueException extends Exception {
public function __construct($message) {
parent::__construct($message);
}
}
$a = 34325;
try {
if ($a > LIMIT) {
throw new BigValueException("Exceeded the maximum value allowed\n");
}
} catch (BigValueException $e) {
echo $e->getMessage();
}
?>
define("LIMIT", 333);
Numbers bigger than this constant are considered to be "big" by our PHP script. class BigValueException extends Exception {
We have a BigValueException class. This class derives from the Exception class through the extends keyword. public function __construct($message) {
parent::__construct($message);
}
Inside the constructor, we call the parent's constructor. if ($a > LIMIT) {
throw new BigValueException("Exceeded the maximum value allowed\n");
}
If the value is bigger than the limit, we throw our custom exception. We give the exception a message "Exceeded the maximum value allowed". } catch (BigValueException $e) {
echo $e->getMessage();
}
We catch the exception and print its message to the console. func_get_args() function. The second solution uses a factory pattern. <?phpIn the above script, we have a Book class. We instantiate the class with 2 and 3 parameters.
class Book {
private $title = "not specified";
private $author = "not specified";
private $year = "not specified";
public function __construct() {
$args = func_get_args();
foreach(array("title", "author", "year") as $item)
{
if(empty($args)) {
break;
}
$this->$item = array_shift($args);
}
}
public function __toString() {
return "Author: $this->author\nTitle: $this->title\nPublished: $this->year\n\n";
}
}
$book1 = new Book("Stephen Prata", "C Primer Plus");
echo $book1;
$book2 = new Book("Joshua Bloch", "Effective Java", 2008);
echo $book2;
?>
private $author = "not specified";We have three member fields defined. Their initial value is "not specified".
private $title = "not specified";
private $year = "not specified";
$args = func_get_args();The
func_get_args() function returns an array comprising a function's argument list. So the idea is: the code inside the constructor is dynamic, it depends on the arguments passed to it. foreach(array("title", "author", "year") as $item)
We go through all member fields using the foreachkeyword. $this->$item = array_shift($args);One of the most basic tasks in constructors is to initialize the member fields of the class. This is done by the above code line. The
array_shift()function removes the first item from the array and returns it. $book1 = new Book("Stephen Prata", "C Primer Plus");
...
$book2 = new Book("Joshua Bloch", "Effective Java", 2008);
We have two different constructors. The first takes 2 parameters, the second takes 3. $ php constructors.phpThis is the outcome of the script.
Author: C Primer Plus
Title: Stephen Prata
Published: not specified
Author: Effective Java
Title: Joshua Bloch
Published: 2008
<?phpWe have a Cat factory class in the above PHP script. It has three different static functions. Each of them returns a specific cat object.
class Cat {
private $name = "unspecified";
private $age = "unspecified";
public static function withName($name) {
$cat = new Cat();
$cat->name = $name;
return $cat;
}
public static function withAge($age) {
$cat = new Cat();
$cat->age = $age;
return $cat;
}
public static function fullCat($name, $age) {
$cat = new Cat();
$cat->name = $name;
$cat->age = $age;
return $cat;
}
public function __toString() {
return "Name: $this->name, Age: $this->age\n";
}
}
$cici = Cat::withName("Cici");
echo $cici;
$missy = Cat::withAge(6);
echo $missy;
$lucky = Cat::fullCat("Lucky", 4);
echo $lucky;
?>
private $name = "unspecified";We have two member fields. Their initial value is "unspecified".
private $age = "unspecified";
public static function withName($name) {
$cat = new Cat();
$cat->name = $name;
return $cat;
}
Here is a withName() static function. This function creates an instance of the Cat class. Set the name member field and returns the object. $cici = Cat::withName("Cici");
echo $cici;
We create an instance of the cat with one of the factory methods. We echo the object. e.g. call the __toString() method of the class. $ php factory.phpThe output of the script.
Name: Cici, Age: unspecified
Name: unspecified, Age: 6
Name: Lucky, Age: 4
<?phpIn our first example, we create a simple object.
class Simple {}
$object = new Simple();
print_r($object);
echo gettype($object), "\n";
?>
class Simple {}
This is a simple class definition. The body of the template is empty. It does not have any data or methods. $object = new Simple();We create a new instance of the Simple class. For this we have the
newkeyword. The $object variable is the handle to the created object. print_r($object);We use the
echo gettype($object), "\n";
print_r() function to get information about the object and the gettype() function, to get the type of the variable. $ php class.phpWe don't get much info, since the class definition was empty. The type of the variable is
Simple Object
(
)
object
object. <?phpIn the above PHP script, we have a Person class with one member field.
class Person {
public $name = "";
}
$p1 = new Person();
$p1->name = "Jane";
$p2 = new Person();
$p2->name = "Beky";
echo $p1->name . "\n";
echo $p2->name . "\n";
?>
$p1 = new Person();We create an instance of the Person class. And set the $name variable to "Jane". We use the -> operator to access the attributes of objects.
$p1->name = "Jane";
$p2 = new Person();We create another instance of the Person class. Here we set the variable to "Beky".
$p2->name = "Beky";
echo $p1->name . "\n";We print the contents of the variables to the console.
echo $p2->name . "\n";
$ php memberfields.phpWe see the output of the script. Each instance of the Person class has a separate copy of the $name member field.
Jane
Beky
<?phpIn the code example, we have a Circle class. We define two methods.
class Circle {
public $radius;
function setRadius($radius) {
$this->radius = $radius;
}
function area() {
return $this->radius * $this->radius * M_PI;
}
}
$c = new Circle();
$c->setRadius(5);
echo $c->area(), "\n";
?>
public $radius;We have one member field. It is the radius of the circle. The
publickeyword is an access specifier. It tells that the variable is fully accessible from the outside world. function setRadius($radius) {
$this->radius = $radius;
}
This is the setRadius() method. It is a normal PHP function. We call functions defined inside classes methods. The $this variable is a special variable, which we use to access the member fields from methods. function area() {
return $this->radius * $this->radius * M_PI;
}
The area() method returns the area of a circle. The M_PI is a built-in constant. $ php circle.phpRunning the example.
78.5398163397
public, protected and private. public members can be accessed from anywhere. protected members can be accessed only within the class itself and by inherited and parent classes. private members may only be accessed by the class that defines the member. <?phpIn the above PHP script, we have two member fields. One is declared public, the other private.
class Person {
public $name = "";
private $age;
}
$p = new Person();
$p->name = "Jane";
#$p->age = 17;
echo $p->name . "\n";
?>
$p->name = "Jane";We access the $name member from the outside world. By the outside world, we mean 'not in the class'. It is OK, since the $name variable is declared
#$p->age = 17;
public. Accessing the $age member is not possible. The private modifier prohibits this. If we uncomment the code line, we will get the 'Fatal error: Cannot access private property Person::$age' error. <?phpIn this PHP script, we have a Derived class, which extends the Base class. The Base class has three member fields. All with different access modifiers. The $is_defined member is not inherited. The
class Base {
public $name = "Base";
protected $id = 6124;
private $is_defined = "yes";
}
class Derived extends Base {
public function info() {
echo "This is Derived class\n";
echo "Members inherited: \n";
echo $this->name . "\n";
echo $this->id . "\n";
echo $this->is_defined . "\n";
}
}
$derived = new Derived();
$derived->info();
?>
privatemodifier prevents this. public function info() {
The info() method has a public access modifier. This means, it can be called outside the class environment. $ php access.phpRunning the PHP script, we receive this output. The public and protected members are inherited, the private member is not.
This is Derived class
Members inherited:
Base
6124
$
<?phpIn this PHP script, we have a SysInfo class. It outputs some system information to the console. We have two private functions and one public. The private methods are here only for internal working of the SysInfo class. They are not meant to be called outside the class.
class SysInfo {
private function get_date() {
return date("Y/m/d");
}
private function get_version() {
return phpversion();
}
public function getInfo() {
$date = $this->get_date();
$version = $this->get_version();
echo "The date is: $date\n";
echo "The PHP version is: $version\n";
}
}
$sys = new SysInfo();
$sys->getInfo();
#$sys->get_date();
?>
$sys = new SysInfo();We create an instance of the SysInfo class and call the publicly available getInfo() method. The getInfo() method uses internally the private methods to do its job. Uncommenting the last code line yields to error.
$sys->getInfo();
#$sys->get_date();
<?phpThis is a method overloading, we know from languages like C#, Java or C++. But this does not work in PHP. Running this example, we get the following error: 'Fatal error: Cannot redeclare Sum::getSum()'. PHP functions can take arbitrary number of variables by default.
class Sum {
public function getSum() {
return 0;
}
public function getSum($x) {
return $x;
}
public function getSum($x, $y) {
return $x + $y;
}
}
$s = new Sum();
echo $s->getSum() . "\n" ;
echo $s->getSum(5) . "\n" ;
echo $s->getSum(3, 4) . "\n" ;
?>
func_get_args() function. <?phpThis time, the script will run.
class Sum {
public function getSum() {
$args = func_get_args();
if (empty($args)) return 0;
foreach ($args as $arg) {
$sum += $arg;
}
return $sum;
}
}
$s = new Sum();
echo $s->getSum() . "\n" ;
echo $s->getSum(5) . "\n" ;
echo $s->getSum(3, 4) . "\n" ;
echo $s->getSum(3, 4, 7) . "\n" ;
?>
$args = func_get_args();The
func_get_args() function returns an array comprising a function's argument list. foreach ($args as $arg) {
$sum += $arg;
}
We go throught all members of the array, and calculate the sum. echo $s->getSum() . "\n" ;We call the same method name with different number of inputs.
echo $s->getSum(5) . "\n" ;
echo $s->getSum(3, 4) . "\n" ;
echo $s->getSum(3, 4, 7) . "\n" ;
__construct(). (Two underscores) <?phpWe have a Song class. This class has a constructor, that prints message to the console.
class Song {
function __construct() {
echo "Song object is created \n";
}
}
$song = new Song();
?>
$song = new Song();This is the time, when the object is created and the constructor is called. We get a message in the console.
$ php constructor.phpThis is the output of the script.
Song object is created
<?phpWe modify the previous example a bit. We pass a value to the constructor.
class Song {
function __construct($song) {
echo "Song $song is created \n";
}
}
$song = new Song("Bad romance");
?>
function __construct($song) {
echo "Song $song is created \n";
}
The passed argument is stored in the local $song variable. $ php constructor2.phpNow we have a message with a song title printed to the console.
Song Bad romance is created
<?phpWe have a Friend class with data members and methods.
class Friend {
private $born;
private $name;
function __construct($name, $born) {
$this->name = $name;
$this->born = $born;
}
function getInfo() {
echo "My Friend $this->name was born in $this->born\n";
}
}
$friend = new Friend("Lenka", 1990);
$friend->getInfo();
?>
private $born;We have two variables in the class definition. The
private $name;
private keyword is an access modifier. It is a form of encapsulation. The private keyword is the most restrictive modifier. It allows only the object in question to access the variable. No descendants, no other objects. More about this topic later. function __construct($name, $born) {
$this->name = $name;
$this->born = $born;
}
In the constructor, we initiate the two data members. The $this variable is a handler used to reference the object variables. $friend = new Friend("Lenka", 1990);
$friend->getInfo();
We create a Friend object with two arguments. Then we call the getInfo() method of the object. To call object methods, we use the -> operator. $ php friend.php
My Friend Lenka was born in 1990
<?phpWe have a Math class with a PI constant.
class Math {
const PI = 3.14159265359;
public function getPI() {
echo self::PI;
}
}
$math = new Math();
echo Math::PI, "\n";
echo $math->getPI(), "\n";
?>
const PI = 3.14159265359;The
const keyword is used to define a constant. public function getPI() {
echo self::PI;
}
Class constants are accessed from within methods using the self keyword followed by two colons. echo Math::PI, "\n";We print the PI constant to the console. In the first case, we get the constant value by referring to the class name, followed by two colons and a constant name. Note that no object was needed to get the class constant. In the second case, we use the object method.
echo $math->getPI(), "\n";
instanceof keyword is used to determine whether a PHP variable is an instantiated object of a certain class. <?phpIn the above script, we have three classes. Cat, Dog and Bird. We traverse the array and print the class for each array value.
class Cat {}
class Dog {}
class Bird {}
$objects = array(new Cat(), new Dog(), new Cat(),
new Bird(), new Bird(), new Dog(),
new Dog(), new Cat(), new Bird()
);
shuffle($objects);
foreach ($objects as $object) {
if ($object instanceof Cat) {
echo "It is a Cat\n";
} elseif ($object instanceof Dog) {
echo "It is a Dog\n";
} else if ($object instanceof Bird) {
echo "It is a Bird\n";
}
}
?>
$objects = array(new Cat(), new Dog(), new Cat(),We create an array of these objects.
new Bird(), new Bird(), new Dog(),
new Dog(), new Cat(), new Bird()
);
shuffle($objects);We shuffle the array. At this point, we don't know the class types for the values of the array.
if ($object instanceof Cat) {
echo "It is a Cat\n";
}
Here we use the instanceof keyword to find out the type of the class. $ php instanceof.phpYou might get this output.
It is a Bird
It is a Cat
It is a Cat
It is a Dog
It is a Dog
It is a Cat
It is a Dog
It is a Bird
It is a Bird
print or the echo keyword with the object instance, the __toString() special method is called. We will demonstrate this in the following example. <?phpWe have a Cat class with a
class Cat {
public $name;
public $age;
function __construct($name, $age) {
$this->age = $age;
$this->name = $name;
}
function __toString() {
return "Cat: $this->name, Age: $this->age \n";
}
}
$missy = new Cat("Missy", 6);
$lucky = new Cat("Lucky", 4);
print $missy;
echo $lucky;
?>
__toString() special method defined. function __toString() {
return "Cat: $this->name, Age: $this->age \n";
}
The method prints the basic info about the object. $missy = new Cat("Missy", 6);
$lucky = new Cat("Lucky", 4);
We create two objects of the Cat class. print $missy;And we use the
echo $lucky;
print or the echo keywords on them. $ php tostring.phpThis is what we get, when we run the script.
Cat: Missy, Age: 6
Cat: Lucky, Age: 4
<?phpIn this PHP script, we have two classes. A Base class and a Derived class. The Derived class inherits from the Base class.
class Base {
function __construct() {
echo "Construction of Base class \n";
}
}
class Derived extends Base {
function __construct() {
parent::__construct();
echo "Construction of Derived class \n";
}
}
$obj1 = new Base();
$obj2 = new Derived();
?>
class Derived extends Base {
In PHP, we use the extends keyword to create inheritance relations. function __construct() {
parent::__construct();
echo "Construction of Derived class \n";
}
In the constructor of the Derived class, we call the parent constructor. We use the parent keyword, followed by two colons and the __construct() method. The constructors of the parent classes must be called explicitly. $obj1 = new Base();We instantiate both the Base and the Derived classes.
$obj2 = new Derived();
$ php derived.phpThis is the output of the PHP script.
Construction of Base class
Construction of Base class
Construction of Derived class
<?phpWe have used several new concepts here. In the code example, we have three classes. Being, Animal and Cat. The Animal class inherits from the Being class. The Cat class inherits from the Animal class. Classes inherit methods and data members, that are not declared as private.
abstract class Being {
protected $isAlive = true;
public function isAlive() {
if ($this->isAlive) {
echo "Being is alive\n";
} else {
echo "Being is not alive\n";
}
}
public function kill() {
$this->isAlive = false;
}
}
abstract class Animal extends Being {
protected $age;
public function __construct($age) {
$this->age = $age;
}
protected function setAge($age) {
$this->age = $age;
}
public function getAge() {
return $this->age;
}
}
class Cat extends Animal {
private $name;
public function __construct($name, $age) {
$this->name = $name;
parent::__construct($age);
}
public function getName() {
return $this->name;
}
}
$cat = new Cat("Cici", 4);
$cat->isAlive();
echo $cat->getName() . " is " . $cat->getAge() . " years old\n";
$cat->kill();
$cat->isAlive();
?>
abstract class Being {
The Being class is declared to be abstract. The abstract keyword prohibits instantiation of classes. It does not make much sense to create an instance of the class Being. protected $isAlive = true;The $isAlive data member is declared to be
protected. Such members can be accessed only by the classes, that define them and by their descendants. abstract class Animal extends Being {
The Animal class is also declared to be abstract. It inherits from class Being. For this, we use the extends keyword. The Animal is descendant. It inherits methods and variables of the base Being class. class Cat extends Animal {
The Cat class inherits from the Animal class. It inherits from the Animal class and indirectly from the Being class too. It is not declared abstract, which means, we can instantiate it. parent::__construct($age);In the constructor of the Cat class, we call the parent constructor using the
parent keyword, followed by two colons and the __construct() method. The constructors of the parent classes must be called explicitly. $cat = new Cat("Cici", 4);
$cat->isAlive();
echo $cat->getName() . " is " . $cat->getAge() . " years old\n";
$cat->kill();
$cat->isAlive();
We create a new Cat. Cici, 4 years old. Then we call functions on the cici object. Note the usage of methods, that were not created in the Cat class, but rather inherited from the parent classes. $ php inheritance.phpOutput of the script.
Being is alive
Cici is 4 years old
Being is not alive
<?phpIn our PHP script, we have an abstract base Drawing class. The class defines two member fields, defines one method and declares one method. One of the methods is abstract, the other one is fully implemented. The Drawing class is abstract, because we cannot draw it. We can draw a circle, a dot or a square. The Drawing class has some common functionality to the objects, that we can draw.
abstract class Drawing {
protected $x = 0;
protected $y = 0;
public abstract function area();
public function getCoordinates() {
echo "\$x is $this->x\n";
echo "\$y is $this->y\n";
}
}
class Circle extends Drawing {
private $radius;
public function __construct($x, $y, $r) {
$this->radius = $r;
$this->x = $x;
$this->y = $y;
}
public function area() {
return $this->radius * $this->radius * pi();
}
public function __toString() {
return "Circle, at x: $this->x, y: $this->y, radius: $this->radius";
}
}
$o = new Circle(12, 45, 22);
echo "$o \n";
echo "Area of the circle: " . $o->area() . "\n";
echo $o->getCoordinates();
?>
class Circle extends Drawing {
A Circle is a subclass of the Drawing class. It must implement the abstract area method. $ php abstract.phpOutput of the script.
Circle, at x: 12, y: 45, radius: 22
Area of the circle: 1520.53084434
$x is 12
$y is 45
interface keyword. Interfaces can only have method signatures and constants. All method signatures declared in an interface must be public. They cannot have fully implemented methods, nor member fields. A PHP class may implement any number of interfaces. An interface can also extend any number of interfaces. A class that implements an interface must implement all method signatures of an interface. <?phpThis is a simple PHP script demonstrating an interface.
interface IInfo {
public function do_inform();
}
class Some implements IInfo {
public function do_inform() {
echo "This is a Some class\n";
}
}
$sm = new Some();
$sm->do_inform();
?>
interface IInfo {
public function do_inform();
}
This is an interface IInfo. It has the do_inform() method signature. class Some implements IInfo {
We use the implements to implement from an interface. public function do_inform() {
echo "This is a Some class\n";
}
The class provides an implementation for the do_inform() method. <?phpWe have a CellPhone class that inherits from three interfaces.
interface Device {
public function switch_on();
public function switch_off();
}
interface Volume {
public function volume_up();
public function volume_down();
}
interface Pluggable {
public function plug_in();
public function plug_off();
}
class CellPhone implements Device, Volume, Pluggable {
public function switch_on() { echo "Switching on\n"; }
public function switch_off() { echo "Switching off\n"; }
public function volume_up() { echo "Volume up\n"; }
public function volume_down() { echo "Volume down\n"; }
public function plug_in() { echo "Plugging in\n"; }
public function plug_off() { echo "Plugging off\n"; }
}
$o = new CellPhone();
$o->switch_on();
$o->volume_up();
$o->plug_in();
?>
class CellPhone implements Device, Volume, Pluggable {
The class implements all three interfaces, which are divided by a comma. The CellPhone class must implement all method signatures from all three interfaces. $ php interface.phpRunning the PHP script.
Switching on
Volume up
Plugging in
<?phpIn this PHP script, we define three interfaces. Extending interfaces allows us to organize them.
interface IInfo {
public function do_inform();
}
interface IVersion {
public function get_version();
}
interface ILog extends IInfo, IVersion {
public function do_log();
}
class DBConnect implements ILog {
public function do_inform() {
echo "This is a DBConnect class\n";
}
public function get_version() {
echo "Version 1.02\n";
}
public function do_log() {
echo "Logging\n";
}
public function connect() {
echo "Connecting to the database\n";
}
}
$db = new DBConnect();
$db->do_inform();
$db->get_version();
$db->do_log();
$db->connect();
?>
interface ILog extends IInfo, IVersion {
public function do_log();
}
The ILog interface extends other two interfaces. public function do_inform() {
echo "This is a DBConnect class\n";
}
The DBConnect class implements the do_inform() method. This method was inherited by the ILog interface, which the class implements. <?phpIn the above PHP script, we have an abstract Shape class. This class morphs into two descendant classes, Rectangle and Square. Both provide their own implementation of the area() method. Polymorphism brings flexibility and scalability to the OOP systems.
abstract class Shape {
private $x = 0;
private $y = 0;
public abstract function area();
}
class Rectangle extends Shape {
function __construct($x, $y) {
$this->x = $x;
$this->y = $y;
}
function area() {
return $this->x * $this->y;
}
}
class Square extends Shape {
function __construct($x) {
$this->x = $x;
}
function area() {
return $this->x * $this->x;
}
}
$shapes = array(
new Square(5),
new Rectangle(12, 4),
new Square(8)
);
foreach ($shapes as $shape) {
echo $shape->area() . "\n";
}
?>
| . | Matches any single character. |
| * | Matches the preceding element zero or more times. |
| [ ] | Bracket expression. Matches a character within the brackets. |
| [^ ] | Matches a single character, that is not contained within the brackets. |
| ^ | Matches the starting position within the string. |
| $ | Matches the ending position within the string. |
| | | Alternation operator. |
preg_split() - splits a string by regex patternpreg_match() - performs a regex matchpreg_replace() - search and replace string by regex patternpreg_grep() - returns array entries that match the regex pattern php > print_r(preg_split("@\s@", "Jane\tKate\nLucy Marion"));
Array
(
[0] => Jane
[1] => Kate
[2] => Lucy
[3] => Marion
)
We have four names divided by spaces. The \s is a character class, which stands for spaces. The preg_split() function returns the split strings. php > echo preg_match("#[a-z]#", "s");
1
The preg_match() function looks if the 's' character is in the character class [a-z]. The class stands for all characters from a to z. It returns 1 for success. php > echo preg_replace("/Jane/","Beky","I saw Jane. Jane was beautiful.");
I saw Beky. Beky was beautiful.
The preg_replace() function replaces all occurrences of the word 'Jane' for the word 'Beky'. php > print_r(preg_grep("#Jane#", array("Jane", "jane", "Joan", "JANE")));
Array
(
[0] => Jane
)
The preg_grep() function returns an array of words, that match the given pattern. In the script example, only one word is returned in the array. This is because by default, the search is case sensitive. php > print_r(preg_grep("#Jane#i", array("Jane", "jane", "Joan", "JANE")));
Array
(
[0] => Jane
[1] => jane
[3] => JANE
)
In this example, we perform a case insensitive grep. We put the i modifier after the right delimiter. The returned array has three words. <?phpIn the $words array, we have five words.
$words = array("Seven", "even", "Maven", "Amen", "Leven");
$pattern = "/.even/";
foreach ($words as $word) {
if (preg_match($pattern, $word)) {
echo "$word matches the pattern\n";
} else {
echo "$word does not match the pattern\n";
}
}
?>
$pattern = "/.even/";Here we define the search pattern. The pattern is a string. The regular expression is placed within delimiters. The delimiters are not optional. They must be present. In our case, we use forward slashes / / as delimiters. Note, we can use different delimiters, if we want. The dot character stands for any single character.
if (preg_match($pattern, $word)) {
echo "$word matches the pattern\n";
} else {
echo "$word does not match the pattern\n";
}
We test all five words, if they match with the pattern. $ php single.phpThe Seven and Leven words match our search pattern.
Seven matches the pattern
even does not match the pattern
Maven does not match the pattern
Amen does not match the pattern
Leven matches the pattern
<?phpWe have two sentences. The pattern is ^Jane. The pattern asks, is the 'Jane' string located at the beginning of the text?
$sentence1 = "Everywhere I look I see Jane";
$sentence2 = "Jane is the best thing that happened to me";
if (preg_match("/^Jane/", $sentence1)) {
echo "Jane is at the beginning of the \$sentence1\n";
} else {
echo "Jane is not at the beginning of the \$sentence1\n";
}
if (preg_match("/^Jane/", $sentence2)) {
echo "Jane is at the beginning of the \$sentence2\n";
} else {
echo "Jane is not at the beginning of the \$sentence2\n";
}
?>
$ php begin.php
Jane is not at the beginning of the $sentence1
Jane is at the beginning of the $sentence2
php > echo preg_match("#Jane$#", "I love Jane");
1
php > echo preg_match("#Jane$#", "Jane does not love me.");
0
The Jane$ pattern matches a string, in which the word Jane is at the end. php > echo preg_match("/mother/", "mother");
1
php > echo preg_match("/mother/", "motherboard");
1
php > echo preg_match("/mother/", "motherland");
1
The mother pattern fits the words mother, motherboard and motherland. Say, we want to look just for exact word matches. We will use the aforementioned anchor ^, $ characters. php > echo preg_match("/^mother$/", "motherland");
0
php > echo preg_match("/^mother$/", "Who is your mother?");
0
php > echo preg_match("/^mother$/", "mother");
1
Using the anchor characters, we get an exact word match for a pattern. ? - 0 or 1 matchThe above is a list of common quantifiers.
* - 0 or more
+ - 1 or more
{n} - exactly n
{n,} - n or more
{,n} - n or less (??)
{n,m} - range n to m
<?phpWe have four words in the $words array.
$words = array("jar", "jazz", "jay", "java", "jet");
$pattern = "/ja.?/";
foreach ($words as $word) {
if (preg_match($pattern, $word)) {
echo "$word matches the pattern\n";
} else {
echo "$word does not match pattern\n";
}
}
?>
$pattern = "/colo.?r/";This is the pattern. The .? combination means, zero or one arbitrary single character.
$ php zeroormore.phpThe * metacharacter matches the preceding element zero or more times.
Seven matches the pattern
even matches the pattern
Maven does not match the pattern
Amen does not match the pattern
Leven matches the pattern
<?phpIn the above script, we have added the * metacharacter. The .* combination means, zero, one or more single characters.
$words = array("Seven", "even", "Maven", "Amen", "Leven");
$pattern = "/.*even/";
foreach ($words as $word) {
if (preg_match($pattern, $word)) {
echo "$word matches the pattern\n";
} else {
echo "$word does not match the pattern\n";
}
}
?>
$ php zeroormore.phpNow the pattern matches three words. Seven, even and Leven.
Seven matches the pattern
even matches the pattern
Maven does not match the pattern
Amen does not match the pattern
Leven matches the pattern
php > print_r(preg_grep("#o{2}#", array("gool", "root", "foot", "dog")));
Array
(
[0] => gool
[1] => root
[2] => foot
)
The o{2} pattern matches strings, that have exactly two 'o' characters. php > print_r(preg_grep("#^\d{2,4}$#", array("1", "12", "123", "1234", "12345")));
Array
(
[1] => 12
[2] => 123
[3] => 1234
)
We have this ^\d{2,4}$ pattern. The \d is a character set. It stands for digits. So the pattern matches numbers, that have 2,3 or 4 digits. <?phpWe have 8 names in the $names array.
$names = array("Jane", "Thomas", "Robert", "Lucy",
"Beky", "John", "Peter", "Andy");
$pattern = "/Jane|Beky|Robert/";
foreach ($names as $name) {
if (preg_match($pattern, $friend)) {
echo "$name is my friend\n";
} else {
echo "$name is not my friend\n";
}
}
?>
$pattern = "/Jane|Beky|Robert/";This is the search pattern. It says, Jane, Beky and Robert are my friends. If you find either of them, you have found my friend.
$ php friends.phpOutput of the script.
Jane is my friend
Thomas is not my friend
Robert is my friend
Lucy is not my friend
Beky is my friend
John is not my friend
Peter is not my friend
Andy is not my friend
php > echo preg_match("/book(worm)?$/", "bookworm");
1
php > echo preg_match("/book(worm)?$/", "book");
1
php > echo preg_match("/book(worm)?$/", "worm");
0
We have the following regex pattern: book(worm)?$. The (worm) is a subpattern. The ? character follows the subpattern, which means, that the subpattern might appear 0,1 times in the final pattern. The $ character is here for the exact end match of the string. Without it, words like bookstore, bookmania would match too. php > echo preg_match("/book(shelf|worm)?$/", "book");
1
php > echo preg_match("/book(shelf|worm)?$/", "bookshelf");
1
php > echo preg_match("/book(shelf|worm)?$/", "bookworm");
1
php > echo preg_match("/book(shelf|worm)?$/", "bookstore");
0
Subpatterns are often used with alternation. The (shelf|worm) subpattern enables to create several word combinations. <?phpWe define a character set with two characters.
$words = array("sit", "MIT", "fit", "fat", "lot");
$pattern = "/[fs]it/";
foreach ($words as $word) {
if (preg_match($pattern, $word)) {
echo "$word matches the pattern\n";
} else {
echo "$word does not match the pattern\n";
}
}
?>
$pattern = "/[fs]it/";This is our pattern. The [fs] is the character class. Note, that we work only with one character at a time. We either consider f, or s. Not both.
$ php chclass.phpThis is the outcome of the script.
sit matches the pattern
MIT does not match the pattern
fit matches the pattern
fat does not match the pattern
lot does not match the pattern
<?phpIn the above script, we test for words consisting of alphanumeric characters. The \w{6} says, six alphanumeric characters match. Only the word mitt## does not match, because it contains non-alphanumeric characters.
$words = array("Prague", "111978", "terry2", "mitt##");
$pattern = "/\w{6}/";
foreach ($words as $word) {
if (preg_match($pattern, $word)) {
echo "$word matches the pattern\n";
} else {
echo "$word does not match the pattern\n";
}
}
?>
php > echo preg_match("#[^a-z]{3}#", "ABC");
1
The #[^a-z]{3}# pattern stands for three characters, that are not in the class a-z. The "ABC" characters match the condition. php > print_r(preg_grep("#\d{2,4}#", array("32", "234", "2345", "3d3", "2")));
Array
(
[0] => 32
[1] => 234
[2] => 2345
)
In the above example, we have a pattern, that matches 2,3,4 digit numbers. <?phpNote that this example provides only one solution. It does not have to be the best one.
$emails = array("luke@gmail.com", "andy@yahoocom", "34234sdfa#2345", "f344@gmail.com");
# regular expression for emails
$pattern = "/^[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\.[a-zA-Z.]{2,5}$/";
foreach ($emails as $email) {
if (preg_match($pattern, $email)) {
echo "$email matches \n";
} else {
echo "$email does not match\n";
}
}
>?
$pattern = "/^[a-zA-Z0-9._-]+@[a-zA-Z0-9-]+\.[a-zA-Z.]{2,5}$/";
This is the pattern. The first ^ and the last $ characters are here to get an exact pattern match. No characters before and after the pattern are allowed. The email is divided into five parts. The first part is the local part. This is usually a name of a company, individual or a nickname. The [a-zA-Z0-9._-]+ lists all possible characters, we can use in the local part. They can be used one or more times. The second part is the literal @ character. The third part is the domain part. It is usually the domain name of the email provider. Like yahoo, gmail etc. [a-zA-Z0-9-]+ It is a character set providing all characters, than can be used in the domain name. The + quantifier makes use of one or more of these characters. The fourth part is the dot character. It is preceded by the escape character. (\.) This is because the dot character is a metacharacter and has a special meaning. By escaping it, we get a literal dot. Final part is the top level domain. The pattern is as follows: [a-zA-Z.]{2,5}Top level domains can have from 2 to 5 characters. Like sk, net, info, travel. There is also a dot character. This is because some top level domains have two parts. For example, co.uk. Jane the 'Jane' stringIn this chapter, we have covered the regular expressions in PHP.
^Jane 'Jane' at the start of a string
Jane$ 'Jane' at the end of a string
^Jane$ exact match of the string 'Jane'
[abc] a, b, or c
[a-z] any lowercase letter
[^A-Z] any character that is not a uppercase letter
(Jane|Becky) Matches either 'Jane' or 'Becky'
[a-z]+ one or more lowercase letters
^[98]?$ digits 9, 8 or empty string
([wx])([yz]) wy, wz, xy, or xz
[0-9] any digit
[^A-Za-z0-9] any symbol (not a number or a letter)
phpinfo(), round() or abs(). The user defined functions are created by application programmers to cover their needs. They are created with the function keyword. function keyword. <?phpThe function keyword is followed by the function name with round brackets. The body of the function lies between the curly brackets. We say that we call a function. If we call a function, the statements inside the function body are executed.
function displayVersion() {
echo "this is PHP " . phpversion();
echo "\n";
}
displayVersion();
?>
displayVersion();This line of the code calls the function.
$ php simple.phpHere we see the outcome of the script.
this is PHP 5.2.6-2ubuntu4.5
<?phpWe have a maximum() function. It returns a max for two numbers. We could not name it max, because there is already a built-in max() function.
function maximum($x, $y) {
if ($x > $y) return $x;
else return $y;
}
$a = 23;
$b = 32;
$val = maximum($a, $b);
echo "The max of $a, $b is $val \n";
?>
if ($x > $y) return $x;If the $x variable is greater than $y, we return $x. Otherwise we return $y.
else return $y;
$val = maximum($a, $b);The value returned by the maximum() function is assigned to the $val variable.
echo "The max of $a, $b is $val \n";We print the max value of the two numbers to the console.
<?phpIn our example, we convert Fahrenheit temperature to Celsius. The FTC function accepts one argument $c, which is the Celsious temperature.
function FTC($c) {
return $c * 9/5 + 32;
}
echo FTC(100);
echo "\n";
echo FTC(0);
echo "\n";
echo FTC(30);
echo "\n";
?>
$ php fahrenheit.php
212
32
86
<?phpHere we created a power function. The function has one argument with an implicit value. We can call the function with one or two arguments.
function power($a, $b=2) {
if ($b == 2) {
return $a*$a;
}
$value = 1;
for ($i = 0; $i < $b; $i++) {
$value *= $a;
}
return $value;
}
$v1 = power(5);
$v2 = power(5, 4);
echo "5^2 is $v1 \n";
echo "5^4 is $v2 \n";
?>
$ php implicit.php
5^2 is 25
5^4 is 625
<?phpIn the above example, we have a normal, nonstatic variable. We increment the variable each time the function is called. We call the function 5 times. However, nonstatic variables are initiated for each call of the function. After 5 function calls the $value equals to 1.
function nonstatic() {
$value = 0;
$value += 1;
return $value;
}
nonstatic();
nonstatic();
nonstatic();
nonstatic();
echo nonstatic(), "\n";
?>
<?phpAfter 5 consecutive calls, the $value is equal to 5.
function staticfun() {
static $value = 0;
$value += 1;
return $value;
}
staticfun();
staticfun();
staticfun();
staticfun();
echo staticfun(), "\n";
?>
$ php nonstatic.php
2
$ php static.php
6
<?phpThe swap function swaps the numbers between the $a, $b variables. The original variables are not affected.
function swap($a, $b) {
$temp = $a;
$a = $b;
$b = $temp;
echo "inside swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";
}
$a = 4;
$b = 7;
echo "outside swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";
swap($a, $b);
echo "outside swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";
?>
$a = 4;At the beginning, these two variables are initiated.
$b = 7;
swap($a, $b);We call the swap function. The function takes $a, $b variables as parameters.
$temp = $a;Inside the swap function, we change the values. Note that the $a, $b variables are defined locally. They are valid only inside the swap function.
$a = $b;
$b = $temp;
$ php swap.phpThe output shows, that the original variables were not affected.
outside swap function:
$a is 4
$b is 7
inside swap function:
$a is 7
$b is 4
outside swap function:
$a is 4
$b is 7
<?phpWe use the & character to pass values by reference.
function swap(&$a, &$b) {
$temp = $a;
$a = $b;
$b = $temp;
echo "Inside the swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";
}
$a = 4;
$b = 7;
echo "Outside the swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";
swap($a, $b);
echo "Outside the swap function:\n";
echo "\$a is $a \n";
echo "\$b is $b \n";
?>
function swap(&$a, &$b) {
...
}
The example is almost identical to the previous one. Except for the ampersand characters. $ php swap2.phpHere we see, that the swap function really changed the values of the variables.
Outside the swap function:
$a is 4
$b is 7
Inside the swap function:
$a is 7
$b is 4
Outside the swap function:
$a is 7
$b is 4
<?phpIn this code example, we calculate the factorial of two numbers.
function factorial($n) {
if ($n==0) {
return 1;
} else {
return $n * factorial($n - 1);
}
}
echo factorial(4), "\n";
echo factorial(10), "\n";
?>
return $n * factorial($n - 1);Inside the body of the factorial function, we call the factorial function with a modified argument. The function calls itself.
$ php recursion.phpThese are the results.
24
3628800
<?phpA variable defined outside a function body cannot be referenced within a function.
$value = 1;
function simple() {
var_dump($value);
}
simple();
?>
$ php scope.phpThe $value variable is NULL in the simple() function.
NULL
<?phpIn this example, we have two variables with the same name. They do not collide, because they exist in different scopes.
$value = 4;
function simple() {
$value = 3;
echo $value, "\n";
}
simple();
echo $value, "\n";
?>
$ php scope1.phpThe value is 3 inside the function. 4 outside the function.
3
4
<?phpWe use the
$value = 1;
function simple() {
global $value;
$value = 2;
}
echo $value, "\n";
simple();
echo $value, "\n";
?>
global keyword to reference a variable defined outside the body of the function. $ php scope2.phpThe $value was successfully modified inside the simple() function.
1
2
<?phpIn the above script, we have a $names array. We use the
$names = array("Jane", "Rebecca", "Lucy", "Lenka", "Ada");
foreach ($names as $name) {
echo "$name ";
}
echo "\n";
sort($names);
foreach ($names as $name) {
echo "$name ";
}
echo "\n";
?>
sort() function to sort the contents of the array. $ php sort.phpThe output of the script shows unsorted and sorted female names.
Jane Rebecca Lucy Lenka Ada
Ada Jane Lenka Lucy Rebecca
<?phpIn the example, we have an array of numbers. We use the
$numbers = array(1, 2, 4, 5, 2, 3, 5, 2);
$nums = count($numbers);
$sum = array_sum($numbers);
echo "In the array, there are $nums numbers\n";
echo "The sum of the numbers is $sum\n";
?>
count() function to count the number of elements in the array. And the array_sum() function to calculate the sum of all values. $ php sumcount.phpThis is the output of the script.
In the array, there are 8 numbers
The sum of the numbers is 24
<?phpIn this script, we have duplicates in the array. The
$numbers = array(3, 4, 4, 3, 2, 4);
$count_values = array_count_values($numbers);
print_r($count_values);
$unique = array_unique($numbers);
print_r($unique);
?>
array_count_values()function returns an array with the number of occurrences for each value. The array_unique() function returns an array without duplicates. $ php unique.phpThe first array says, that 3 is present twice, 4 three times and 2 once. The second array says that there are three values present in the array. 3, 4 and 2. 3 has index 0, 4 has index 1 and 2 has index 4. The
Array
(
[3] => 2
[4] => 3
[2] => 1
)
Array
(
[0] => 3
[1] => 4
[4] => 2
)
array_unique()function keeps the indexes untouched. <?phpIn this example, we traverse the array using the functions, that move the internal array pointer.
$continents = array("America", "Africa", "Europe", "Asia", "Antarctica");
$item1 = current($continents);
$item2 = next($continents);
$item3 = next($continents);
$item4 = end($continents);
$item5 = prev($continents);
echo "$item1, $item2, $item3, $item4, $item5\n";
reset($continents);
while(list($idx, $val) = each($continents)) {
echo "Index: $idx, Value: $val\n";
}
?>
$item1 = current($continents);The
$item2 = next($continents);
$item3 = next($continents);
$item4 = end($continents);
$item5 = prev($continents);
current() function returns the current element in the array. At the beginning, it is the first element of the array. The next() function advances the pointer by one position. The end() function returns the last element. The prev() element returns the element, one position before the current one. In our case it is the next to the last element. reset($continents);Here we use the
while(list($idx, $val) = each($continents)) {
echo "Index: $idx, Value: $val\n";
}
reset() function to set the internal pointer to the first element again. And peruse the $continents array one more time. <?phpIn this example, we have two arrays. $names1 and $names2. We use the
$names1 = array("Jane", "Lucy", "Rebecca");
$names2 = array("Lenka", "Timea", "Victoria");
$names = array_merge($names1, $names2);
foreach ($names as $name) {
echo "$name ";
}
echo "\n";
?>
array_merge() function to create $names array by merging the previous two arrays. $ php merge.phpThe new array has six names.
Jane Lucy Rebecca Lenka Timea Victoria
<?phpIn the above script, we use functions that modify the contents of an array. We have a $nubmers array, that has 4 numbers. 1, 2, 3, 4.
$numbers = array(1, 2, 3, 4);
array_push($numbers, 5, 6);
foreach ($numbers as $num) {
echo $num, " ";
}
echo "\n";
array_pop($numbers);
foreach ($numbers as $num) {
echo $num, " ";
}
echo "\n";
array_unshift($numbers, -1, 0);
foreach ($numbers as $num) {
echo $num, " ";
}
echo "\n";
array_shift($numbers);
foreach ($numbers as $num) {
echo $num, " ";
}
echo "\n";
?>
array_push($numbers, 5, 6);The
array_push() function inserts one or more items to the end of the array. Our array now has 1, 2, 3, 4, 5, 6. array_pop($numbers);The
array_pop() function removes the last item from the array. Our array stores now 1, 2, 3, 4, 5. array_unshift($numbers, -1, 0);The
array_unshift() function adds -1, 0 to the beginning of the array. The array has -1, 0, 1, 2, 3, 4, 5. array_shift($numbers);Finally, the
array_shift() function removes the first item from the array. Now we have 0, 1, 2, 3, 4, 5 in the array. <?phpIn this script, we have two array functions. The
$numbers = range(1, 15);
foreach ($numbers as $number) {
echo "$number ";
}
echo "\n";
shuffle($numbers);
foreach ($numbers as $number) {
echo "$number ";
}
echo "\n";
?>
range() function enables us to create a list of consecutive numbers easily. In our case, numbers 1, 2, ..15. We do not have to type them manually. And the shuffle() function shuffles e.g. randomly relocates the elements of the array. $ php range.phpYour output might look like this.
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15
9 15 13 7 3 10 11 4 12 5 6 14 1 2 8
<?phpThe
$names = array("Jane", "Adriana", "Lucy", "Rebecca");
if (in_array("Jane", $names)) {
echo "Jane is in the array\n";
} else {
echo "Jane is not in the array\n";
}
?>
in_array() function checks, if a specific element is inside an array. Our script checks, if 'Jane' is in the $names array. The name is there, so we get the 'Jane is in the array' message to the console. <?phpThe
$domains = array("sk" => "Slovakia", "de" => "Germany",
"hu" => "Hungary", "ru" => "Russia");
$keys = array_keys($domains);
$values = array_values($domains);
foreach ($keys as $key) {
echo "$key ";
}
echo "\n";
foreach ($values as $value) {
echo "$value ";
}
echo "\n";
?>
array_keys() function returns all the keys of an array. The array_values() function returns all the values of an array. $ php keysvalues.phpThe first line consists of top level domain names. These were the keys of the $domains array. The second line are the names of the corresponding countries. These were the values of the array.
sk de hu ru
Slovakia Germany Hungary Russia
<?phpFinally, in our last example, we mention the
$countries = array("de" => "Germany", "sk" => "Slovakia",
"us" => "United States", "ru" => "Russia",
"hu" => "Hungaria", "pl" => "Poland");
function show_values($value, $key)
{
echo "The $key stands for the $value\n";
}
array_walk($countries, show_values);
?>
array_walk() function. This function applies a user defined function to every member of the array. We have a $countries array. We apply the show_values function to each element of the array. The function simply prints the key and the value for each element. array() function to create an array. In its simplest form, the function takes an arbitrary number of comma separated values. <?phpHere we create a $names array. It stores 5 female names. The
$names = array("Jane", "Lucy", "Timea", "Beky", "Lenka");
print_r($names);
?>
print_r() function prints a human readable information about the variable. $ php init1.phpFrom the output we can see the names and their indexes by which we can access them.
Array
(
[0] => Jane
[1] => Lucy
[2] => Timea
[3] => Beky
[4] => Lenka
)
<?phpThis is another way of initializing an array in PHP. We create the $continents array by assigning values to array indexes. "America" has index 0, "Europe" has index 2 etc.
$continents[0] = "America";
$continents[1] = "Africa";
$continents[2] = "Europe";
$continents[3] = "Asia";
$continents[4] = "Antarctica";
$continents[5] = "Australia";
print_r($continents);
?>
<?phpIn this example, we create the $continents array with the indexes specified. By default, the first index is zero. In our case, we start with 1.
$continents = array(
1 => "America", 2 => "Africa",
3 => "America", 4 => "Asia",
5 => "Antarctica");
print_r($continents);
?>
$ php init22.phpNow we have an array of continents with indexes, that we have chosen.
Array
(
[1] => America
[2] => Africa
[3] => America
[4] => Asia
[5] => Antarctica
)
<?phpThe indexes do not have to be consecutive numbers. In our example, we have chosen numbers 10, 20, 30, 40 and 50 to be the indexes for the $languages array.
$languages[10] = "PHP";
$languages[20] = "Python";
$languages[30] = "Ruby";
$languages[40] = "PERL";
$languages[50] = "Java";
print_r($languages);
?>
<?phpWhen we do assignment initialization of a PHP array, we can omit the indexes. The PHP will automatically create the indexes for us.
$actors[] = "Philip Seymour Hoffman";
$actors[] = "Tom Cruise";
$actors[] = "Bill Paxton";
$actors[] = "Adrien Brody";
$actors[] = "Danie Craig";
print_r($actors);
?>
$ php init4.phpThe PHP interpreter has created consecutive indexes starting from zero.
Array
(
[0] => Philip Seymour Hoffman
[1] => Tom Cruise
[2] => Bill Paxton
[3] => Adrien Brody
[4] => Danie Craig
)
<?phpIn this script, we have omitted two indexes. The PHP will add them. It will create index 12 and index 21.
$novels[10] = "Doctor Zhivago";
$novels[11] = "War and Peace";
$novels[] = "In Cold Blood";
$novels[20] = "Crime and Punishment";
$novels[] = "Catch XII";
print_r($novels);
?>
$ php init5.phpPHP has automatically created indexes 12 and 21.
Array
(
[10] => Doctor Zhivago
[11] => War and Peace
[12] => In Cold Blood
[20] => Crime and Punishment
[21] => Catch XII
)
<?phpWe create a $countries array. The indexes that we have mentioned earlier are actually keys in an associative array. The keys may be strings too.
$countries = array(
"de" => "Germany", "sk" => "Slovakia",
"us" => "United States", "ru" => "Russia",
"hu" => "Hungary", "pl" => "Poland");
print_r($countries);
?>
<?phpWe can access data from an array by their index.
$languages[10] = "PHP";
$languages[20] = "Python";
$languages[30] = "Ruby";
$languages[40] = "PERL";
$languages[50] = "Java";
echo $languages[10], "\n";
echo $languages[20], "\n";
echo $languages[30], "\n";
echo $languages[40], "\n";
echo $languages[50], "\n";
?>
$ php peruse1.phpWe have printed all five languages to the console.
PHP
Python
Ruby
PERL
Java
<?phpIn this example, we use the
$continents = array("America", "Africa", "Europe", "Asia", "Antarctica");
$len = count($continents);
for ($i = 0; $i < $len; $i++) {
echo $continents[$i], "\n";
}
?>
for statement to peruse a $continents array. $len = count($continents);First, we count the number of elements in the array.
for ($i = 0; $i < $len; $i++) {
echo $continents[$i], "\n";
}
The for loop prints elements from the array by indexes 0..$len-1. <?phpThe easiest way to peruse an array is to use the
$continents = array("America", "Africa", "Europe", "Asia", "Antarctica");
foreach ($continents as $continent) {
echo $continent, "\n";
}
?>
foreachstatement. The statement goes through the array one by one and puts a current element to the temporary $continent variable. It accesses data without using their index or key. <?phpIn the last example, we use the
$countries = array("de" => "Germany", "sk" => "Slovakia",
"us" => "United States", "ru" => "Russia",
"hu" => "Hungary", "pl" => "Poland");
function show_values($value, $key)
{
echo "The $key stands for the $value\n";
}
array_walk($countries, show_values);
?>
array_walk() function to peruse an array. It applies a user function to every member of an array. The user function takes the key and the value of the item as parameters. $ php walk.phpWe print both the key and the value to the console in the sentence.
The de stands for the Germany
The sk stands for the Slovakia
The us stands for the United States
The ru stands for the Russia
The hu stands for the Hungary
The pl stands for the Poland
