PHP is a server-side scripting language designed for web development
but also used as a general-purpose programming language. It was
originally created by
Rasmus Lerdorf in 1994, the
implementation is now produced by The
stood for Personal Home Page, but it now stands for the recursive
acronym PHP: Hypertext Preprocessor
PHP code may be embedded into
HTML code, or it can be used in
combination with various web template systems, web content management
systems, and web frameworks.
PHP code is usually processed by a PHP
interpreter implemented as a module in the web server or as a Common
Gateway Interface (CGI) executable. The web server combines the
results of the interpreted and executed
PHP code, which may be any
type of data, including images, with the generated web page.
may also be executed with a command-line interface (CLI) and can be
used to implement standalone graphical applications.
PHP interpreter, powered by the
Zend Engine, is free
software released under the
PHP has been widely ported
and can be deployed on most web servers on almost every operating
system and platform, free of charge.
PHP language evolved without a written formal specification or
standard until 2014, leaving the canonical
PHP interpreter as a de
facto standard. Since 2014 work has gone on to create a formal PHP
During the 2010s there have been increased efforts towards
standardisation and code sharing in
PHP applications by projects such
as PHP-FIG in the form of PSR-initiatives as well as Composer
dependency manager and the Packagist repository.
PHP hosts a diverse
array of web frameworks requiring framework-specific knowledge, with
Laravel recently emerging as a popular option by incorporating ideas
made popular from other competing non-
PHP web frameworks, like Ruby on
1.1 Early history
PHP 3 and 4
PHP 6 and Unicode
1.6 Release history
3.1 Data types
6 Development and community
7 Installation and configuration
10 See also
12 Further reading
13 External links
Rasmus Lerdorf, who wrote the original
Common Gateway Interface (CGI)
component, together with
Andi Gutmans and Zeev Suraski, who rewrote
the parser that formed
PHP development began in 1994 when
Rasmus Lerdorf wrote several Common
Gateway Interface (CGI) programs in C, which he used to
maintain his personal homepage. He extended them to work with web
forms and to communicate with databases, and called this
implementation "Personal Home Page/Forms Interpreter" or PHP/FI.
PHP/FI could be used to build simple, dynamic web applications. To
accelerate bug reporting and improve the code, Lerdorf initially
announced the release of PHP/FI as "Personal Home Page Tools (PHP
Tools) version 1.0" on the
Usenet discussion group
comp.infosystems.www.authoring.cgi on June 8, 1995. This
release already had the basic functionality that
PHP has today. This
included Perl-like variables, form handling, and the ability to embed
HTML. The syntax resembled that of
Perl but was simpler, more limited
and less consistent.
PHP was not intended to be a new programming language, and grew
organically, with Lerdorf noting in retrospect: "I don’t know how to
stop it, there was never any intent to write a programming language
[…] I have absolutely no idea how to write a programming language, I
just kept adding the next logical step on the way." A development
team began to form and, after months of work and beta testing,
officially released PHP/FI 2 in November 1997.
The fact that
PHP was not originally designed but instead was
developed organically has led to inconsistent naming of functions and
inconsistent ordering of their parameters. In some cases, the
function names were chosen to match the lower-level libraries which
PHP was "wrapping", while in some very early versions of
length of the function names was used internally as a hash function,
so names were chosen to improve the distribution of hash values.
PHP 3 and 4
This is an example of custom
PHP code for the CMS WordPress.
Zeev Suraski and
Andi Gutmans rewrote the parser in 1997 and formed
the base of
PHP 3, changing the language's name to the recursive
acronym PHP: Hypertext Preprocessor. Afterwards, public testing
PHP 3 began, and the official launch came in June 1998. Suraski and
Gutmans then started a new rewrite of PHP's core, producing the Zend
Engine in 1999. They also founded
Zend Technologies in Ramat Gan,
On May 22, 2000,
PHP 4, powered by the
Zend Engine 1.0, was
released. As of August 2008 this branch reached version 4.4.9. PHP
4 is no longer under development nor will any security updates be
On July 14, 2004,
PHP 5 was released, powered by the new
PHP 5 included new features such as improved support for
object-oriented programming, the
PHP Data Objects (PDO) extension
(which defines a lightweight and consistent interface for accessing
databases), and numerous performance enhancements. In 2008
became the only stable version under development. Late static binding
had been missing from
PHP and was added in version 5.3.
Many high-profile open-source projects ceased to support
PHP 4 in new
code as of February 5, 2008, because of the GoPHP5 initiative,
provided by a consortium of
PHP developers promoting the transition
PHP 4 to
PHP interpreters became available on most existing 32-bit
64-bit operating systems, either by building them from the PHP
source code, or by using pre-built binaries. For the
5.3 and 5.4, the only available
Windows binary distributions
32-bit x86 builds, requiring
mode while using
Internet Information Services
Internet Information Services (IIS) on a 64-bit
PHP version 5.5 made the
64-bit x86-64 builds
PHP 6 and Unicode
PHP received mixed reviews due to lacking native
Unicode support at
the core language level. In 2005, a project headed by Andrei
Zmievski was initiated to bring native
Unicode support throughout PHP,
by embedding the International Components for
Unicode (ICU) library,
and representing text strings as
UTF-16 internally. Since this
would cause major changes both to the internals of the language and to
user code, it was planned to release this as version 6.0 of the
language, along with other major features then in development.
However, a shortage of developers who understood the necessary
changes, and performance problems arising from conversion to and from
UTF-16, which is rarely used in a web context, led to delays in the
project. As a result, a
PHP 5.3 release was created in 2009, with
Unicode features back-ported from PHP 6, notably
namespaces. In March 2010, the project in its current form was
officially abandoned, and a PHP 5.4 release was prepared
containing most remaining non-
Unicode features from PHP 6, such
as traits and closure re-binding. Initial hopes were that a new
plan would be formed for
Unicode integration, but as of 2014 none have
During 2014 and 2015, a new major
PHP version was developed, which was
PHP 7. The numbering of this version involved some
debate. While the
Unicode experiment had never been
released, several articles and book titles referenced the
PHP 6 name,
which might have caused confusion if a new release were to reuse the
name. After a vote, the name PHP 7 was chosen.
The foundation of
PHP 7 is a
PHP branch that was originally dubbed PHP
next generation (phpng). It was authored by Dmitry Stogov, Xinchen Hui
and Nikita Popov, and aimed to optimize
PHP performance by
Zend Engine while retaining near-complete language
compatibility. As of 14 July 2014[update],
WordPress-based benchmarks, which served as the main benchmark suite
for the phpng project, showed an almost 100% increase in performance.
Changes from phpng are also expected to make it easier to improve
performance in the future, as more compact data structures and other
changes are seen as better suited for a successful migration to a
just-in-time (JIT) compiler. Because of the significant changes,
Zend Engine is called
Zend Engine 3, succeeding Zend
Engine 2 used in
Because of major internal changes in phpng, it must receive a new
major version number of PHP, rather than a minor
PHP 5 release,
according to PHP's release process. Major versions of
allowed to break backward-compatibility of code and therefore
presented an opportunity for other improvements beyond phpng that
require backward-compatibility breaks. In particular, it involved the
Many fatal- or recoverable-level legacy
PHP error mechanisms were
replaced with modern object-oriented exceptions
The syntax for variable dereferencing was reworked to be internally
more consistent and complete, allowing the use of the operators ->,
, (), , and :: with arbitrary meaningful left-hand-side
Support for legacy
PHP 4-style constructor methods was deprecated
The behavior of the foreach statement was changed to be more
Constructors for the few classes built-in to
PHP which returned null
upon failure were changed to throw an exception instead, for
Several unmaintained or deprecated server application programming
interfaces (SAPIs) and extensions were removed from the
PHP core, most
notably the legacy mysql extension
The behavior of the list() operator was changed to remove support for
Support for legacy ASP-style
PHP code delimiters (<% and %>,
<script language=php> and </script>) was removed
An oversight allowing a switch statement to have multiple default
clauses was fixed
Support for hexadecimal number support in some implicit conversions
from strings to number types was removed
The left-shift and right-shift operators were changed to behave more
consistently across platforms
Conversions between integers and floating point numbers were tightened
and implemented more consistently across platforms
PHP 7 also included new language features. Most notably, it introduces
return type declarations for functions, which complement the
existing parameter type declarations, and support for the scalar types
(integer, float, string, and boolean) in parameter and return type
Bug and security fixes
8 June 1995
Officially called "Personal Home Page Tools (
PHP Tools)". This is the
first use of the name "PHP".
1 November 1997
Officially called "PHP/FI 2.0". This is the first release that could
actually be characterised as PHP, being a standalone language with
many features that have endured to the present day.
6 June 1998
20 October 2000
Development moves from one person to multiple developers. Zeev Suraski
Andi Gutmans rewrite the base for this version.
22 May 2000
23 June 2001
Added more advanced two-stage parse/execute tag-parsing system called
10 December 2001
12 March 2002
Introduced "superglobals" ($_GET, $_POST, $_SESSION, etc.)
22 April 2002
6 September 2002
Disabled register_globals by default. Data received over the network
is not inserted directly into the global namespace anymore, closing
possible security holes in applications.
27 December 2002
31 March 2005
Introduced the command-line interface (CLI), to supplement the
11 July 2005
7 August 2008
Fixed a memory corruption bug, which required breaking binary
compatibility with extensions compiled against
PHP version 4.3.x.
13 July 2004
5 September 2005
Zend Engine II with a new object model.
24 November 2005
24 August 2006
Performance improvements with introduction of compiler variables in
PHP Engine. Added
PHP Data Objects (PDO) as a
consistent interface for accessing databases.
2 November 2006
6 January 2011
Enabled the filter extension by default. Native
30 June 2009
14 August 2014
Namespace support; late static bindings, jump label (limited goto),
PHP archives (phar), garbage collection for circular
Windows support, sqlite3, mysqlnd as a
replacement for libmysql as underlying library for the extensions that
work with MySQL, fileinfo as a replacement for mime_magic for better
MIME support, the Internationalization extension, and deprecation of
1 March 2012
3 September 2015
Trait support, short array syntax support. Removed items:
register_globals, safe_mode, allow_call_time_pass_reference,
session_register(), session_unregister() and session_is_registered().
Built-in web server. Several improvements to existing features,
performance and reduced memory requirements.
20 June 2013
10 July 2016
Support for generators, finally blocks for exceptions handling,
OpCache (based on
Zend Optimizer+) bundled in official
28 August 2014
31 December 2018
Constant scalar expressions, variadic functions, argument unpacking,
new exponentiation operator, extensions of the use statement for
functions and constants, new phpdbg debugger as a SAPI module, and
other smaller improvements.
Abandoned version of
PHP that planned to include native Unicode
3 December 2015
3 December 2018
Zend Engine 3 (performance improvements and
64-bit integer support
on Windows), uniform variable syntax, AST-based compilation
process, added Closure::call(), bitwise shift consistency
across platforms, ?? (null coalesce) operator, Unicode
codepoint escape syntax, return type declarations, scalar type
(integer, float, string and boolean) declarations, <=>
"spaceship" three-way comparison operator, generator
delegation, anonymous classes, simpler and more consistently
CSPRNG API, replacement of many remaining internal PHP
"errors" with the more modern exceptions, and shorthand syntax for
importing multiple items from a namespace.
1 December 2016
1 December 2019
void return type, class constant visibility modifiers
30 November 2017
30 November 2020
Counting of non-countable objects 
Beginning on June 28, 2011, the
PHP Group implemented a timeline for
the release of new versions of PHP. Under this system, at least
one release should occur every month. Once per year, a minor release
should occur which may include new features. Every minor release
should at least be supported for two years with security and bug
fixes, followed by at least one year of only security fixes, for a
total of a three-year release process for every minor release. No new
features, unless small and self-contained, are to be introduced into a
minor release during the three-year release process.
The mascot of the
PHP project is the elePHPant, a blue elephant with
PHP logo on its side, designed by Vincent Pontier in 1998.
The elePHPant is sometimes differently colored when in plush toy form.
PHP syntax and semantics
"Hello, World!" program
"Hello, World!" program is written in
PHP code embedded
<?php echo '<p>Hello World</p>'; ?>
However, as no requirement exists for
PHP code to be embedded in HTML,
the simplest version of Hello, World! may be written like this, with
the closing tag omitted as preferred in files containing pure PHP
PHP interpreter only executes
PHP code within its delimiters.
Anything outside its delimiters is not processed by PHP, although
PHP text is still subject to control structures described in PHP
code. The most common delimiters are <?php to open and ?> to
PHP sections. The shortened form <? also exists. This short
delimiter makes script files less portable, since support for them can
be disabled in the local
PHP configuration and it is therefore
discouraged. However, there is no recommendation against the
use of the echo short tag <?=. Prior to
PHP 5.4.0, this short
syntax for echo() only works with the short_open_tag configuration
setting enabled, while for
PHP 5.4.0 and later it is always
available. The purpose of all these delimiters is to
PHP code from non-
PHP content, such as
The first form of delimiters, <?php and ?>, in X
HTML and other
XML documents, creates correctly formed
instructions. This means that the resulting mixture of
and other markup in the server-side file is itself well-formed XML.
Variables are prefixed with a dollar symbol, and a type does not need
to be specified in advance. PHP 5 introduced type hinting that
allows functions to force their parameters to be objects of a specific
class, arrays, interfaces or callback functions. However, before PHP
7.0, type hints could not be used with scalar types such as integer or
Unlike function and class names, variable names are case sensitive.
Both double-quoted ("") and heredoc strings provide the ability to
interpolate a variable's value into the string.
newlines as whitespace in the manner of a free-form language, and
statements are terminated by a semicolon.
PHP has three types of
comment syntax: /* */ marks block and inline comments; // as well as #
are used for one-line comments. The echo statement is one of
PHP provides to output text, e.g., to a web
In terms of keywords and language syntax,
PHP is similar to the C
style syntax. if conditions, for and while loops, and function returns
are similar in syntax to languages such as C, C++, C#, Java and Perl.
PHP stores integers in a platform-dependent range, either a
32-bit signed integer equivalent to the C-language long type. Unsigned
integers are converted to signed values in certain situations; this
behavior is different from other programming languages. Integer
variables can be assigned using decimal (positive and negative),
octal, hexadecimal, and binary notations.
Floating point numbers are also stored in a platform-specific range.
They can be specified using floating point notation, or two forms of
PHP has a native Boolean type that is
similar to the native Boolean types in Java and C++. Using the Boolean
type conversion rules, non-zero values are interpreted as true and
zero as false, as in
Perl and C++.
The null data type represents a variable that has no value; NULL is
the only allowed value for this data type.
Variables of the "resource" type represent references to resources
from external sources. These are typically created by functions from a
particular extension, and can only be processed by functions from the
same extension; examples include file, image, and database
Arrays can contain elements of any type that
PHP can handle, including
resources, objects, and even other arrays. Order is preserved in lists
of values and in hashes with both keys and values, and the two can be
PHP also supports strings, which can be used with
single quotes, double quotes, nowdoc or heredoc syntax.
PHP Library (SPL) attempts to solve standard problems and
implements efficient data access interfaces and classes.
PHP defines a large array of functions in the core language and many
are also available in various extensions; these functions are well
documented in the online
PHP documentation. However, the built-in
library has a wide variety of naming conventions and associated
inconsistencies, as described under history above.
Custom functions may be defined by the developer, e.g.:
function myAge(Int $birthYear) : String
// defines a function, this one is
$yearsOld = date('Y') - $birthYear; //
calculates the age
return $yearsOld . ' year' . ($yearsOld != 1 ? 's' : ''); //
returns the age in a descriptive form
echo 'I am currently ' . myAge(1981) . ' old.'; //
outputs the text concatenated
the return value of myAge()
// As the result of this syntax, myAge() is called.
In 2018, the output of the above sample program is 'I am currently 37
In lieu of function pointers, functions in
PHP can be referenced by a
string containing their name. In this manner, normal
PHP functions can
be used, for example, as callbacks or within function tables.
User-defined functions may be created at any time without being
prototyped. Functions may be defined inside code blocks,
permitting a run-time decision as to whether or not a function should
be defined. There is a function_exists function that determines
whether a function with a given name has already been defined.
Function calls must use parentheses, with the exception of
zero-argument class constructor functions called with the
new, in which case parentheses are optional.
PHP 5.3, support for anonymous functions and closures did not
exist in PHP. While create_function() exists since
PHP 4.0.1, it is
merely a thin wrapper around eval() that allows normal
to be created during program execution.
PHP 5.3 added syntax to
define an anonymous function or "closure" which can capture
variables from the surrounding scope:
return function($y) use ($x)
return $x + $y;
$adder = getAdder(8);
echo $adder(2); // prints "10"
In the example above, getAdder() function creates a closure using
passed argument $x (the keyword use imports a variable from the
lexical context), which takes an additional argument $y, and returns
the created closure to the caller. Such a function is a first-class
object, meaning that it can be stored in a variable, passed as a
parameter to other functions, etc.
Unusually for a dynamically typed language,
PHP supports type
declarations on function parameters, which are enforced at runtime.
This has been supported for classes and interfaces since PHP 5.0,
for arrays since PHP 5.1, for "callables" since
PHP 5.4, and
scalar (integer, float, string and boolean) types since
PHP 7.0. PHP 7.0 also has type declarations for function
return types, expressed by placing the type name after the list of
parameters, preceded by a colon. For example, the getAdder
function from the earlier example could be annotated with types like
so in PHP 7:
function getAdder(int $x): Closure
return function(int $y) use ($x) : int
return $x + $y;
$adder = getAdder(8);
echo $adder(2); // prints "10"
echo $adder(null); // throws an exception because an incorrect
type was passed
$adder = getAdder(); // would also throw an exception
By default, scalar type declarations follow weak typing principles.
So, for example, if a parameter's type is int,
PHP would allow not
only integers, but also convertible numeric strings, floats or
booleans to be passed to that function, and would convert them.
PHP 7 has a "strict typing" mode which, when used, disallows
such conversions for function calls and returns within a file.
Basic object-oriented programming functionality was added in
PHP 3 and
PHP 4. This allowed for
PHP to gain further
abstraction, making creative tasks easier for programmers using the
language. Object handling was completely rewritten for
expanding the feature set and enhancing performance. In previous
versions of PHP, objects were handled like value types. The
drawback of this method was that code had to make heavy use of PHP's
"reference" variables if it wanted to modify an object it was passed
rather than creating a copy of it. In the new approach, objects are
referenced by handle, and not by value.
PHP 5 introduced private and protected member variables and methods,
along with abstract classes, final classes, abstract methods, and
final methods. It also introduced a standard way of declaring
constructors and destructors, similar to that of other object-oriented
languages such as C++, and a standard exception handling model.
PHP 5 added interfaces and allowed for multiple
interfaces to be implemented. There are special interfaces that allow
objects to interact with the runtime system. Objects implementing
ArrayAccess can be used with array syntax and objects implementing
IteratorAggregate can be used with the foreach language
construct. There is no virtual table feature in the engine, so static
variables are bound with a name instead of a reference at compile
If the developer creates a copy of an object using the reserved word
Zend engine will check whether a __clone() method has been
defined. If not, it will call a default __clone() which will copy the
object's properties. If a __clone() method is defined, then it will be
responsible for setting the necessary properties in the created
object. For convenience, the engine will supply a function that
imports the properties of the source object, so the programmer can
start with a by-value replica of the source object and only override
properties that need to be changed.
The following is a basic example of object-oriented programming in
public function __construct($firstName, $lastName = '') //
optional second argument
$this->firstName = $firstName;
$this->lastName = $lastName;
public function greet()
return 'Hello, my name is ' . $this->firstName .
(($this->lastName != '') ? (' ' .
$this->lastName) : '') . '.';
public static function staticGreet($firstName, $lastName)
return 'Hello, my name is ' . $firstName . ' ' . $lastName .
$he = new Person('John', 'Smith');
$she = new Person('Sally', 'Davis');
$other = new Person('iAmine');
echo $he->greet(); // prints "Hello, my name is John Smith."
echo '<br />';
echo $she->greet(); // prints "Hello, my name is Sally Davis."
echo '<br />';
echo $other->greet(); // prints "Hello, my name is iAmine."
echo '<br />';
echo Person::staticGreet('Jane', 'Doe'); // prints "Hello, my name is
The visibility of
PHP properties and methods is defined using the
keywords public, private, and protected. The default is public, if
only var is used; var is a synonym for public. Items declared public
can be accessed everywhere. protected limits access to inherited
classes (and to the class that defines the item). private limits
visibility only to the class that defines the item. Objects of
the same type have access to each other's private and protected
members even though they are not the same instance. PHP's member
visibility features have sometimes been described as "highly
useful." However, they have also sometimes been described as "at
best irrelevant and at worst positively harmful."
The original, only complete and most widely used
PHP implementation is
powered by the
Zend Engine and known simply as PHP. To disambiguate it
from other implementations, it is sometimes unofficially referred to
Zend PHP". The
Zend Engine compiles
PHP source code on-the-fly
into an internal format that it can execute, thus it works as an
interpreter. It is also the "reference implementation" of
PHP has no formal specification, and so the semantics of Zend
PHP define the semantics of
PHP itself. Due to the complex and nuanced
semantics of PHP, defined by how
Zend works, it is difficult for
competing implementations to offer complete compatibility.
PHP's single-request-per-script-execution model, and the fact the Zend
Engine is an interpreter, leads to inefficiency; as a result, various
products have been developed to help improve
PHP performance. In order
to speed up execution time and not have to compile the
PHP source code
every time the web page is accessed,
PHP scripts can also be deployed
PHP engine's internal format by using an opcode cache, which
works by caching the compiled form of a
PHP script (opcodes) in shared
memory to avoid the overhead of parsing and compiling the code every
time the script runs. An opcode cache,
Zend Opcache, is built into PHP
since version 5.5. Another example of a widely used opcode cache
Alternative PHP Cache (APC), which is available as a PECL
PHP is still the most popular implementation, several other
implementations have been developed. Some of these are compilers or
support JIT compilation, and hence offer performance benefits over
PHP at the expense of lacking full
PHP compatibility. Alternative
implementations include the following:
HHVM (HipHop Virtual Machine) – developed at
available as open source, it converts
PHP code into a high-level
bytecode (commonly known as an intermediate language), which is then
translated into x86-64 machine code dynamically at runtime by a
just-in-time (JIT) compiler, resulting in up to 6× performance
Parrot – a virtual machine designed to run dynamic languages
efficiently; Pipp transforms the
PHP source code into the Parrot
intermediate representation, which is then translated into the
Parrot's bytecode and executed by the virtual machine.
Phalanger – compiles
PHP into Common Intermediate Language
Quercus – compiles
PHP into Java bytecode
HipHop – developed at
Facebook and available as open source,
it transforms the
PHP scripts into
C++ code and then compiles the
resulting code, reducing the server load up to 50%. In early 2013,
Facebook deprecated it in favor of
HHVM due to multiple reasons,
including deployment difficulties and lack of support for the whole
PHP language, including the create_function() and eval()
PHP is free software released under the
PHP License, which stipulates
Products derived from this software may not be called "PHP", nor may
"PHP" appear in their name, without prior written permission from
firstname.lastname@example.org. You may indicate that your software works in
PHP by saying "
Foo for PHP" instead of calling it
PHP Foo" or "phpfoo".
This restriction on use of "PHP" makes the
PHP License incompatible
General Public License
General Public License (GPL), while the
Zend License is
incompatible due to an advertising clause similar to that of the
original BSD license.
Development and community
PHP includes various free and open-source libraries in its source
distribution, or uses them in resulting
PHP binary builds.
fundamentally an Internet-aware system with built-in modules for
File Transfer Protocol (FTP) servers and many database
servers, including PostgreSQL, MySQL,
Microsoft SQL Server
Microsoft SQL Server and SQLite
(which is an embedded database), LDAP servers, and others. Numerous
functions familiar to C programmers, such as those in the stdio
family, are available in standard
PHP allows developers to write extensions in C to add functionality to
PHP extensions can be compiled statically into PHP
or loaded dynamically at runtime. Numerous extensions have been
written to add support for the
Windows API, process management on
Unix-like operating systems, multibyte strings (Unicode), cURL, and
several popular compression formats. Other
PHP features made available
through extensions include integration with IRC, dynamic generation of
Adobe Flash content,
PHP Data Objects (PDO) as an
abstraction layer used for accessing
databases, and even speech
synthesis. Some of the language's core functions, such as those
dealing with strings and arrays, are also implemented as
PHP Extension Community Library (PECL) project is
a repository for extensions to the
Some other projects, such as Zephir, provide the ability for PHP
extensions to be created in a high-level language and compiled into
PHP extensions. Such an approach, instead of writing PHP
extensions directly in C, simplifies the development of extensions and
reduces the time required for programming and testing.
PHP Group consists of ten people (as of 2015[update]): Thies C.
Arntzen, Stig Bakken, Shane Caraveo, Andi Gutmans, Rasmus Lerdorf, Sam
Ruby, Sascha Schumann, Zeev Suraski, Jim Winstead, Andrei
Zend Technologies provides a
PHP Certification based on
exam for programmers to become certified
documentation is available at PHP.net and eir.me .
Installation and configuration
There are two primary ways for adding support for
PHP to a web
server – as a native web server module, or as a CGI
PHP has a direct module interface called Server
Application Programming Interface (SAPI), which is supported by many
web servers including Apache HTTP Server,
defunct) and iPlanet. Some other web servers, such as OmniHTTPd,
Server Application Programming Interface (ISAPI),
which is a Microsoft's web server module interface. If
PHP has no
module support for a web server, it can always be used as a Common
Gateway Interface (CGI) or
FastCGI processor; in that case, the web
server is configured to use PHP's CGI executable to process all
FastCGI Process Manager) is an alternative FastCGI
implementation for PHP, bundled with the official
since version 5.3.3. When compared to the older FastCGI
implementation, it contains some additional features, mostly useful
for heavily loaded web servers.
PHP for command-line scripting, a
interface (CLI) executable is needed.
PHP supports a CLI SAPI as of
PHP 4.3.0. The main focus of this SAPI is developing shell
applications using PHP. There are quite a few differences between the
CLI SAPI and other SAPIs, although they do share many of the same
PHP has a direct module interface called SAPI for different web
servers; in case of PHP 5 and Apache 2.0 on Windows, it
is provided in form of a DLL file called php5apache2.dll, which
is a module that, among other functions, provides an interface between
PHP and the web server, implemented in a form that the server
understands. This form is what is known as a SAPI.
There are different kinds of SAPIs for various web server extensions.
For example, in addition to those listed above, other SAPIs for the
PHP language include the
Common Gateway Interface (CGI) and
command-line interface (CLI).
PHP can also be used for writing desktop graphical user interface
(GUI) applications, by using the
PHP-GTK is not
included in the official
PHP distribution, and as an extension it
can be used only with
PHP versions 5.1.0 and newer. The most common
way of installing
PHP-GTK is compiling it from the source code.
PHP is installed and used in cloud environments, software
development kits (SDKs) are provided for using cloud-specific
features. For example:
Amazon Web Services
Amazon Web Services provides the AWS SDK for PHP
Windows Azure can be used with the
Windows Azure SDK for PHP.
Numerous configuration options are supported, affecting both core PHP
features and extensions. Configuration file php.ini is
searched for in different locations, depending on the way
used. The configuration file is split into various sections,
while some of the configuration options can be also set within the web
A broad overview of the LAMP software bundle, displayed here together
PHP is a general-purpose scripting language that is especially suited
to server-side web development, in which case
PHP generally runs on a
web server. Any
PHP code in a requested file is executed by the PHP
runtime, usually to create dynamic web page content or dynamic images
used on websites or elsewhere. It can also be used for
command-line scripting and client-side graphical user interface (GUI)
PHP can be deployed on most web servers, many operating
systems and platforms, and can be used with many relational database
management systems (RDBMS). Most web hosting providers support
use by their clients. It is available free of charge, and the PHP
Group provides the complete source code for users to build, customize
and extend for their own use.
Dynamic web page: example of server-side scripting (
PHP and MySQL).
PHP acts primarily as a filter, taking input from a file or
stream containing text and/or
PHP instructions and outputting another
stream of data. Most commonly the output will be HTML, although it
could be JSON,
XML or binary data such as image or audio formats.
PHP 4, the
PHP parser compiles input to produce bytecode for
processing by the
Zend Engine, giving improved performance over its
Originally designed to create dynamic web pages,
PHP now focuses
mainly on server-side scripting, and it is similar to other
server-side scripting languages that provide dynamic content from a
web server to a client, such as Microsoft's ASP.NET, Sun Microsystems'
JavaServer Pages, and mod_perl.
PHP has also attracted the
development of many software frameworks that provide building blocks
and a design structure to promote rapid application development (RAD).
Some of these include PRADO, CakePHP, Symfony, CodeIgniter, Laravel,
Yii Framework, Phalcon and
Zend Framework, offering features similar
to other web frameworks.
The LAMP architecture has become popular in the web industry as a way
of deploying web applications.
PHP is commonly used as the P in
this bundle alongside Linux, Apache and MySQL, although the P may also
refer to Python, Perl, or some mix of the three. Similar packages,
WAMP and MAMP, are also available for
Windows and OS X, with the first
letter standing for the respective operating system. Although both PHP
and Apache are provided as part of the Mac
OS X base install, users of
these packages seek a simpler installation mechanism that can be more
easily kept up to date.
As of April 2007[update], over 20 million
Internet domains had
web services hosted on servers with
PHP installed and mod_php was
recorded as the most popular
Apache HTTP Server
Apache HTTP Server module. As of
PHP was used as the server-side programming
language on 83% of 10 million most popular websites. Web content
management systems written in
PHP include MediaWiki, Joomla,
eZ Publish, eZ Platform, SilverStripe, WordPress,
Drupal, and Moodle. Websites written in PHP, in back-end
and/or user-facing portion, include Facebook, Digg,
Tumblr, Dailymotion, and Slack.
For specific and more advanced usage scenarios,
PHP offers a well
defined and documented way for writing custom extensions in C or
C++. Besides extending the language
itself in form of additional libraries, extensions are providing a way
for improving execution speed where it is critical and there is room
for improvements by using a true compiled language.
offers well defined ways for embedding itself into other software
projects. That way
PHP can be easily used as an internal scripting
language for another project, also providing tight interfacing with
the project's specific internal data structures.
PHP received mixed reviews due to lacking support for multithreading
at the core language level, though using threads is made possible
by the "pthreads" PECL extension.
As of January 2013[update],
PHP was used in more than 240 million
websites (39% of those sampled) and was installed on 2.1 million web
A command line interface, php-cli, and two
Windows Script Host
scripting engines for
PHP have been produced.
In 2013, 9% of all vulnerabilities listed by the National
Database were linked to PHP; historically, about
30% of all vulnerabilities listed since 1996 in this database are
linked to PHP. Technical security flaws of the language itself or of
its core libraries are not frequent (22 in 2009, about 1% of the total
PHP applies to about 20% of programs listed).
Recognizing that programmers make mistakes, some languages include
taint checking to automatically detect the lack of input validation
which induces many issues. Such a feature is being developed for
PHP, but its inclusion into a release has been rejected several
times in the past.
There are advanced protection patches such as
Hardening-Patch, especially designed for web hosting
There are certain language features and configuration parameters
(primarily the default values for such runtime settings) that make PHP
applications prone to security issues. Among these, magic_quotes_gpc
and register_globals configuration directives are the best known;
the latter made any URL parameters become
PHP variables, opening a
path for serious security vulnerabilities by allowing an attacker to
set the value of any uninitialized global variable and interfere with
the execution of a
PHP script. Support for "magic quotes" and
"register globals" has been deprecated as of
PHP 5.3.0, and removed as
Another example for the runtime settings vulnerability comes from
failing to disable
PHP execution (via engine configuration
directive) for the directory where uploaded images are stored;
leaving the default settings can result in execution of malicious PHP
code embedded within the uploaded images. Also, leaving
enabled the dynamic loading of
PHP extensions (via enable_dl
configuration directive) in a shared web hosting environment can
lead to security issues.
Also, implied type conversions that result in incompatible values
being treated as identical against the programmer's intent can lead to
security issues. For example, the result of the comparison 0e1234 == 0
comparison is true because the first compared value is treated as
scientific notation having the value
(5000000000000000000♠0×101234), i.e. zero. This feature resulted in
authentication vulnerabilities in Simple Machines Forum,
Typo3 and phpBB when
MD5 password hashes were compared.
Instead, either the function strcmp or the identity operator (===)
should be used; 0e1234 === 0 results in false.
In a 2013 analysis of over 170,000 website defacements, published by
Zone-H, the most frequently (53%) used technique was exploitation of
file inclusion vulnerability, mostly related to insecure usage of the
PHP functions include, require, and allow_url_fopen.
Computer programming portal
Free software portal
PHP Extension and Application Repository)
PHP Extension Community Library (PECL)
List of AMP packages
XAMPP (Free and open source cross-platform web server solution stack
Hack (programming language)
Comparison of programming languages
Comparison of web frameworks
^ a b Lerdorf, Rasmus (2007-04-26). "
PHP on Hormones – history
PHP presentation by
Rasmus Lerdorf given at the
MySQL Conference in
Santa Clara, California". The Conversations Network. Retrieved
^ a b "News Archive – 2018:
PHP 7.2.2 Released". php.net.
2018-01-31. Retrieved 2017-11-30.
^ a b "History of PHP". php.net.
^ a b c d e f g h i "History of
PHP and related projects". The PHP
Group. Retrieved 2008-02-25.
PHP Manual: Preface, www.php.net
^ "Introduction: What can
PHP Manual. Retrieved
^ a b "Embedding
PHP in HTML". O'Reilly. 2001-05-03. Retrieved
^ Jackson, Joab (2014-07-31). "
PHP gets a formal specification, at
last". ITworld. IDG.
^ Lerdorf, Rasmus (2012-07-20). "I wonder why people keep writing that
PHP was ever written in Perl. It never was. #php". Twitter. Retrieved
^ Lerdorf, Rasmus (2007-04-26). "
PHP on Hormones" (mp3). The
Conversations Network. Retrieved 2009-06-22.
^ Lerdorf, Rasmus (2007). "Slide 3". slides for '
PHP on Hormones'
PHP Group. Retrieved 2009-06-22.
^ Lerdorf, Rasmus (June 8, 1995). "Announce: Personal Home Page Tools
PHP Tools)". Retrieved 7 June 2011.
^ Lerdorf, Rasmus (1995-06-08). "Announce: Personal Home Page Tools
PHP Tools)". Newsgroup: comp.infosystems.www.authoring.cgi.
^ "Rasmus Lerdorf, Senior Technical Yahoo: PHP, Behind the Mic".
2003-11-19. Archived from the original on 2013-07-28. , cited at
Felipe Ribeiro (Aug 7, 2012). "This Is Not Another "
Article". [permanent dead link]
^ "Problems with PHP". Retrieved 20 December 2010.
^ "php.internals: Re: Function name consistency". news.php.net.
2013-12-28. Retrieved 2014-02-09.
Rasmus Lerdorf (Dec 16, 2013). "Re: Flexible function naming".
Newsgroup: php.internals. Retrieved December 26, 2013.
Acronym Meaning Vote". PHP.net. Archived from the original on
August 15, 2000.
Zend Engine version 2.0: Feature Overview and Design". Zend
Technologies Ltd. Retrieved 2006-09-17.
^ "php.net 2007 news archive". The
PHP Group. 2007-07-13. Retrieved
^ Kerner, Sean Michael (2008-02-01). "
PHP 4 is Dead—Long Live PHP
5". InternetNews. Retrieved 2008-03-16.
^ Trachtenberg, Adam (2004-07-15). "Why
PHP 5 Rocks!". O'Reilly.
^ "Late Static Binding in PHP". Digital Sandwich. 2006-02-23.
^ "Static Keyword". The
PHP Group. Retrieved 2008-03-25.
^ "GoPHP5". Archived from the original on 2011-07-17.
^ GoPHP5. "
PHP projects join forces to Go
PHP 5" (PDF). GoPHP5 Press
Release. Archived from the original (PDF) on 2009-12-10. Retrieved
^ "GoPHP5". GoPHP5. Archived from the original on 2011-04-27.
PHP Installation and Configuration". php.net. Retrieved
PHP for Windows: Binaries and sources releases (5.3)". php.net.
PHP for Windows: Binaries and sources releases (5.4)". php.net.
PHP for Windows: Binaries and sources releases (5.5)". php.net.
^ "Types: Strings (
PHP Manual)". PHP.net. Retrieved 2013-09-22.
^ "Details of the String Type (
PHP Manual)". PHP.net. Retrieved
Andrei Zmievski (2005-08-10). "
Unicode support design document
(mailing list post)". Retrieved 2014-02-09.
PHP 5.5 or 6.0". Retrieved 2014-02-09.
^ Andrei Zmievski. "The Good, the Bad, and the Ugly: What Happened to
PHP 6". Retrieved 2014-02-09.
Rasmus Lerdorf (2010-03-11). "
PHP 6 (mailing list post)". Retrieved
^ "RFC: Name of Next Release of PHP". php.net. 2014-07-07. Retrieved
^ "Re: [PHP-DEV] [VOTE][RFC] Name of Next Release of
2014-07-30. Retrieved 2014-07-30.
^ "PHP: rfc:phpng". php.net. Retrieved 16 December 2014.
^ a b "PHP: phpng". php.net. Retrieved 2014-07-15.
^ "Merge branch 'ZendEngine3'". github.com. 2014-12-05. Retrieved
^ a b c "PHP: Release Process". 2011-06-20. Retrieved
^ a b "
PHP RFC: Exceptions in the engine (for
PHP 7)". php.net.
^ a b "
PHP RFC: Uniform Variable Syntax". php.net. 2014-05-31.
PHP shell 150+ versions + stats + vld + hhvm".
PHP RFC: Fix "foreach" behavior". php.net. Retrieved
PHP RFC: Constructor behaviour of internal classes". php.net.
PHP RFC: Removal of dead or not yet PHP7 ported SAPIs and
extensions". php.net. Retrieved 2015-05-21.
PHP RFC: Fix list() behavior inconsistency". php.net. Retrieved
PHP RFC: Remove alternative
PHP tags". php.net. Retrieved
PHP RFC: Make defining multiple default cases in a switch a syntax
error". php.net. Retrieved 2015-05-21.
PHP RFC: Remove hex support in numeric strings". php.net. Retrieved
^ a b "
PHP RFC: Integer Semantics". php.net. Retrieved
PHP RFC: ZPP Failure on Overflow". php.net. Retrieved
^ a b c "RFC: Return Types". php.net. 2015-01-27. Retrieved
^ a b c d e f "RFC: Scalar Type Declarations". php.net. 2015-03-16.
^ a b c d e f g h i j k l "Unsupported Branches". php.net. Retrieved
^ a b c d "PHP:
PHP 4 ChangeLog". The
PHP Group. 2008-01-03. Retrieved
PHP from the command line".
PHP Manual. The
PHP 4.4.0 Release Announcement".
PHP Mannual. The
^ a b c "PHP:
PHP 5 ChangeLog". The
PHP Group. 2007-11-08. Retrieved
PHP manual: PDO". The
PHP Group. 2011-11-15. Retrieved
^ "Built-in web server". Retrieved March 26, 2012.
^ a b c d "Supported Versions". php.net. Retrieved 2017-12-13.
PHP 5.5.0 changes". php.net. Retrieved 2015-03-03.
^ "Migrating from
PHP 5.5.x to
PHP 5.6.x". php.net. Retrieved
PHP 6". There have been books on the shelves purporting
PHP 6 since at least 2008. But, in March 2010, the
release is not out - in fact, it is not even close to out. Recent
events suggest that
PHP 6 will not be released before 2011 - if,
indeed, it is released at all.
PHP 7 moves full speed ahead". Recent versions of
PHP have been
part of the 5.x release series, but there will be no
PHP 6. “We’re
going to skip [version] 6 because years ago, we had plans for a 6 but
those plans were very different from what we’re doing now,”
Gutmans said. Going right to version 7 avoids confusion.
^ "PHP: rfc:size_t_and_int64_next". php.net. Retrieved 16 December
^ "PHP: rfc:abstract_syntax_tree". php.net. Retrieved 16 December
^ "PHP: rfc:closure_apply". php.net. Retrieved 16 December 2014.
^ "PHP: rfc:integer_semantics". php.net. Retrieved 16 December
^ "PHP: rfc:isset_ternary". php.net. Retrieved 16 December 2014.
Unicode Codepoint Escape Syntax". 2014-11-24. Retrieved
^ "Combined Comparison (Spaceship) Operator". php.net. Retrieved
PHP RFC: Generator Delegation". php.net. Retrieved
PHP RFC: Anonymous Classes". php.net. Retrieved 2015-05-21.
PHP RFC: Easy User-land CSPRNG". php.net. Retrieved
PHP RFC: Group Use Declarations". php.net. Retrieved
^ "PHP: rfc:void_return_type". php.net. 2015-11-09. Retrieved
^ "PHP: rfc:class_constant_visibility". php.net. 2015-10-27. Retrieved
^ "PHP: ElePHPant". 4 Oct 2014. Retrieved 4 Oct 2014.
^ "tags - Manual". php.net. Retrieved 2014-02-17.
^ a b "PHP: rfc:shortags". php.net. 2008-04-03. Retrieved
^ "PHP: Basic syntax". The
PHP Group. Retrieved 2008-02-22.
^ "Basic Coding Standard".
PHP Framework Interoperability Group.
^ "echo - Manual". php.net. Retrieved 2014-02-17.
^ "Description of core php.ini directives - Manual". php.net.
2002-03-17. Retrieved 2014-02-17.
^ "Your first PHP-enabled page". The
PHP Group. Retrieved
^ Bray, Tim; et al. (26 November 2008). "Processing Instructions".
Extensible Markup Language (XML) 1.0 (Fifth Edition). W3C. Retrieved
^ "Variables". The
PHP Group. Retrieved 2008-03-16.
^ "Instruction separation". The
PHP Group. Retrieved 2008-03-16.
^ "Comments". The
PHP Group. Retrieved 2008-03-16.
^ "Integers in PHP, running with scissors, and portability". MySQL
Performance Blog. March 27, 2007. Retrieved 2007-03-28.
^ a b c d e "Types". The
PHP Group. Retrieved 2008-03-16.
^ "Strings". The
PHP Group. Retrieved 2008-03-21.
^ "SPL – StandardPHPLibrary". PHP.net. March 16, 2009.
^ a b "User-defined functions (
PHP manual)". php.net. 2014-07-04.
^ a b "Variable functions (
PHP manual)". php.net. 2014-07-04.
^ "create_function() (
PHP manual)". php.net. 2014-07-04. Retrieved
Anonymous functions (
PHP manual)". php.net. 2014-07-04. Retrieved
^ Christian Seiler; Dmitry Stogov (2008-07-01). "Request for Comments:
Lambda functions and closures". php.net. Retrieved 2014-07-07.
^ a b "
PHP 5 Object References". mjtsai.com. Retrieved
^ "Classes and Objects (
PHP 5)". The
PHP Group. Retrieved
^ "Object cloning". The
PHP Group. Retrieved 2008-03-16.
^ "Visibility (
PHP Manual)". theserverpages.com. 2005-05-19. Retrieved
^ Gervasio, Alejandro. "More on Private Methods with
PHP 5 Member
Visibility". devshed.com. Retrieved 24 November 2010.
^ "Visibility in PHP: Public, Private and Protected".
aperiplus.sourceforge.net. Retrieved 2010-08-26.
^ "How do computer languages work?". Retrieved 2009-11-04.
^ (Gilmore 2006, p. 43)
^ "[VOTE] Integrating
Zend Optimizer+ into the
news.php.net. Retrieved 2013-03-08.
PHP Cache". PHP.net. Retrieved 2013-09-21.
^ "We are the 98.5% (and the 16%) « HipHop Virtual Machine".
hhvm.com. December 2013. Retrieved 2014-02-23.
^ "Announcement on
HPHPc support". Retrieved
PHP License, version 3.01". Retrieved 2010-05-20.
^ "GPL-Incompatible, Free Software Licenses". Various Licenses and
Comments about Them. Free Software Foundation. Retrieved
^ "PHP: Function and Method listing - Manual". The
^ "Introduction - Manual". php.net. 2013-06-07. Retrieved
^ Darryl Patterson (5 August 2004). "Simplify Business Logic with PHP
DataObjects - O'Reilly Media". ibm.com. Retrieved 16 December
^ "IBM - United States". IBM - United States. Retrieved 16 December
^ "Five common
PHP database problems". ibm.com. 2006-08-01. Retrieved
^ "IBM Redbooks - Developing
PHP Applications for IBM Data Servers".
redbooks.ibm.com. Retrieved 16 December 2014.
^ Krill, Paul (19 October 2005). "
PHP catching on at enterprises,
vying with Java". InfoWorld. Archived from the original on 13 July
^ "Cross Reference: /PHP_5_4/ext/standard/". php.net. Retrieved 16
December 2014. [permanent dead link]
^ "Developing Custom
PHP Extensions". devnewz.com. 2002-09-09.
Archived from the original on 2008-02-18. Retrieved 2008-02-25.
^ "Why Zephir?". zephir-lang.com. 2015-10-20. Retrieved
PHP Credits". php.net. Retrieved 2015-07-29.
^ archivedate=March 2018 http://www.eir.me/res_en/index.php
archivedate=March 2018 Check url= value (help). Missing or
empty title= (help)CS1 maint: Missing pipe (link)
^ a b "General Installation Considerations". php.net. Retrieved
^ "News Archive:
PHP 5.3.3 Released!". php.net. 2010-07-22.
FastCGI Process Manager (FPM)". php.net. Retrieved
^ "Command line usage: Introduction". php.net. Retrieved
^ "Command line usage: Differences to other SAPIs". php.net. Retrieved
^ a b "General Installation Considerations". php.net. Retrieved
^ "PHP: Apache 2.x on
Microsoft Windows". php.net. Archived from the
original on 2013-09-26. Retrieved 2013-09-22.
^ "Command line usage: Introduction". php.net. Retrieved
PHP-GTK 2". php.net. Retrieved 2013-09-22.
^ "AWS SDK for PHP". aws.amazon.com. Retrieved 2014-03-06.
Windows Azure SDK for
PHP - Interoperability Bridges and Labs
Center". interoperabilitybridges.com. Archived from the original on
2014-03-20. Retrieved 2014-03-06.
^ "Runtime configuration: Table of contents". php.net. Retrieved
^ "php.ini directives: List of php.ini directives". php.net. Retrieved
^ "Runtime configuration: The configuration file". PHP.net. Retrieved
^ "php.ini directives: List of php.ini sections". PHP.net. Retrieved
^ "Runtime configuration: Where a configuration setting may be set".
PHP.net. Retrieved 2013-09-22.
PHP Manual Image Processing and GD;". php.net. Retrieved
^ Archived 20080611231433 at the Wayback Machine.[not in citation
PHP and MySQL". University of Alabama. Archived from the original
on 2008-02-28. Retrieved 2008-02-25.
PHP Server-Side Scripting Language". Indiana University.
2007-04-04. Retrieved 2008-02-25.
JavaServer Pages Technology —
JavaServer Pages Comparing
Methods for Server-Side Dynamic Content White Paper". Sun
Microsystems. Retrieved 2008-02-25.
^ "Five simple ways to tune your LAMP application".
PHP Usage Stats". SecuritySpace. 2007-04-01. Retrieved
^ "Usage of server-side programming languages for websites". W3Techs.
2010-10-29. Retrieved 2010-10-29.
^ "Manual:Installation requirements#PHP". MediaWiki. 2010-01-25.
PHP is the programming language in which
MediaWiki is written [...]
^ Kempkens, Alex. "Joomla! - Content Management System to build
websites & apps".
^ "Server requirements of SilverStripe". Retrieved 13 October 2014.
^ "About WordPress". Retrieved 2010-02-26.
WordPress was [...] built
PHP and Drupal". Drupal.org. Retrieved 2010-06-13.
^ "About". Moodle.org. Retrieved 2009-12-20.
Facebook Facebook". Blog.facebook.com. Retrieved
PHP and Digg". O'Reilly. Retrieved 2010-06-13.
PHP 7 at Tumblr".
Tumblr Engineering. 4 November 2016.
PHP 7 deployment at Dailymotion".
Dailymotion engineering blog. 3
PHP Seriously". Slack Engineering Blog. 12 October
PHP at the core: Extension structure". PHP.net. Retrieved
PHP at the core: The "counter" Extension – A Continuing
Example". PHP.net. Retrieved 2013-09-22.
^ "Extension Writing Part I: Introduction to
PHP and Zend". Zend
Technologies. 2005-03-01. Retrieved 2013-09-22.
^ "Extension Writing Part II: Parameters, Arrays, and ZVALs". Zend
Technologies. 2005-06-06. Retrieved 2013-09-22.
^ "Extension Writing Part II: Parameters, Arrays, and ZVALs
Zend Technologies. 2005-06-06. Retrieved
^ "Extension Writing Part III: Resources".
2006-05-12. Retrieved 2013-09-22.
C++ Classes in a
2009-04-22. Retrieved 2013-09-22.
PHP with C++?". Stack Overflow. Retrieved
^ "How can I use
C++ code to interact with PHP?". Stack Overflow.
^ Golemon, Sara (2006). Extending and Embedding PHP.
^ "Bug Request #46919: Multi threading". PHP.net. Retrieved
^ "pthreads: Introduction (
PHP Manual)". PHP.net. Retrieved
^ "PECL :: Package :: pthreads". pecl.php.net. Retrieved
^ Ide, Andy (2013-01-31). "
PHP just grows & grows". Retrieved
^ "National Vulnerability
Database (NVD) Search Vulnerabilities".
Retrieved 2014-03-19. [permanent dead link]
^ "PHP-related vulnerabilities on the National Vulnerability
Database". 2012-07-05. Retrieved 2013-04-01.
PHP Taint Mode RFC".
^ "Developer Meeting Notes, Nov. 2005".
^ "Taint mode decision, November 2007". Archived from the original on
PHP Project". 2008-08-15.
^ "Security: Using Register Globals".
PHP Manual. PHP.net. Retrieved
^ "Magic Quotes".
PHP Manual. PHP.net. Retrieved 2014-01-17.
^ "'engine' configuration directive". PHP: Runtime Configuration.
PHP.net. Retrieved 2014-02-13.
PHP Security Exploit With GIF Images". 2007-06-22. Retrieved
PHP security exploit with GIF images".
PHP Classes blog.
2007-06-20. Retrieved 2013-09-22.
^ "Passing Malicious
PHP Through getimagesize()". 2007-06-04. Archived
from the original on 2013-09-21. Retrieved 2013-09-22.
^ "'enable_dl' configuration directive". PHP: Runtime Configuration.
PHP.net. Retrieved 2014-02-13.
PHP function reference: dl()". PHP.net. Retrieved 2013-09-22.
^ "My host won't fix their Trojan". WebHosting Talk. Retrieved
^ Raz0r. "
Simple Machines Forum
Simple Machines Forum <= 2.0.3 Admin Password
^ Nibble Security. "TYPO3-SA-2010-020, TYPO3-SA-2010-022
^ Ahack.ru. "Криптостойкость и
^ "Comparison operators". PHP.net.
^ Pawel Krawczyk (2013). "Most common attacks on web applications".
IPSec.pl. Retrieved 2015-04-15.
^ Pawel Krawczyk (2013). "So what are the "most critical" application
flaws? On new OWASP Top 10". IPSec.pl. Retrieved 2015-04-15.
Paul Ford (June 11, 2015). "What is Code?". Bloomberg Businessweek.
What’s the Absolute Minimum I Must Know About PHP?
Find more aboutPHPat's sister projects
Media from Wikimedia Commons
Textbooks from Wikibooks
Learning resources from Wikiversity
Documentation from MediaWiki
Listen to this article (info/dl)
This audio file was created from a revision of the article "PHP" dated
2011-11-23, and does not reflect subsequent edits to the article.
More spoken articles
PHP at Curlie (based on DMOZ)
PHP Reference Manual
PHP source code repository on GitHub
PHP and Symfony: Structure, Stability and Flexibility
PHP Unit Testing Framework
Web resource vs. Web service
Database (formerly W3C)
Ajax vs. DHTML
Dynamic web page
Open Web Platform
Visual Basic .NET
Visual Basic .NET (VB.NET)
Free and open-source software
Alternative terms for free software
Comparison of open-source and closed-source software
Comparison of source code hosting facilities
Free software project directories
Gratis versus libre
Open-source software development
Content management systems
Free software movement
Open-source software movement
Free Software Foundation
Python Software Foundation License
Comparison of free and open-source software licenses
Contributor License Agreement
Debian Free Software Guidelines
Definition of Free Cultural Works
The Free Software Definition
The Open Source Definition
Permissive software licence
Digital rights management
Mozilla software rebranding
The Cathedral and the Bazaar
Microsoft Open Specification Promise
BNF: cb135584386 (data)