The following ‘Hi, what’s up?’ program is in black and white
in PHP code set in an HTML document: <!DOCTYPE
html><html> <head><title>PHP</title></head>
<body> <?php echo “<p> Hi, what’s up?</p>”; ?> </body></html> However, as no condition exists for
PHP code to be implanted in HTML, the simplest version of Hello, World! may be printed
like this, with the closing tag absent as favorite in files
/*
*/ script block and inline comments; // as well as # are used for one-line
comments. The echo account is one of numerous facilities PHP provides to output
text, e.g., to a web browser. In terms of keywords and words syntax, PHP
is similar to the C style syntax. if conditions, for and while loops, and
function returns are alike in syntax to languages such as C, C++, C#, Java and
Perl. The following is an example of PHP for loop:<?php
for ($x = 0; $x
<= 100; $x++) {echo "The number is: $x <br>";} ?>
Data types PHP stores integers in a
platform-dependent variety, either a 64-bit or 32-bit signed integer equal to
the C-language long type. Unsigned integers are changed to signed values in
certain situations; this manner is diverse from that of other encoding
languages. Integer variables can be assigned using decimal (positive and
negative), octal, 
NULL is
the only allowed value for this data type. Variables of the "resource"
type signify references to resources from outside sources. These are typically fashioned
by functions from a meticulous addition, and can only be processed by functions
from the same extension; examples include file, image, and database wealth. Arrays
can contain elements of any type that PHP can handle, including income,
objects, and other arrays. Order is conserved in lists of values and in hashes
with both keys and values, and the two can be intermingled. PHP also chains strings,
which can be used with single quotes, double quotes, nowdoc or heredoc syntax. The
Standard PHP Library (SPL) attempts to solve standard problems and implements competent
data access interfaces and classes.
Functions
PHP defines a great array of functions in the core language
and many also exist 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 allied inconsistencies, as described under history
above. Custom functions may be defined by the developer, e.g.:
function myAge($birthYear) { // defines a function, this one is named "myAge"
$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
// with the return value of myAge()
// As the result of this syntax, myAge() is
called. In 2017, the output of the above sample program is 'I am
currently 36 years old.' 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 formed at any time without being prototyped.
Functions may be distinct 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 previously
been defined. Function calls must use parentheses, with the exception of
zero-argument class constructor functions called with the PHP operator new, in
which case parentheses are optional. Until 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 ordinary
PHP functions to be created throughout program execution. PHP 5.3 added syntax
to define an anonymous function or "closure" which can capture
variables from the surrounding scope:
function getAdder($x) {
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 conceded 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. However, PHP 7 has a
"strict typing" mode which, when used, disallows such conversions for
function calls and returns within a file. Object-oriented
programming Basic object-oriented programming
