PHP operators

PHP has a wide variety of operators

These operators can be distinguished into two groups: binaries, which act on two operands and unaries, which only require one operand

Thus, its general syntax is:

operand1 operator_Binary operand2

operand1 operator_unary

operator_unary operand1

Arithmetic operators

PHP supplies basic operations with the only additions of operators that return the rest of the division between the left and right operators; and the exponentiation, which allows to raise the left operator to the power of the right operator

Note In other languages the + operator applied to strings concatenates both strings into a single

However, in PHP to perform this operation the operator is used.

$a = 5;
$b = 3;

$suma = $a + $b; #addition example
echo $suma; #will return us 8

$resta $a - $b #subtraction example
echo $resta; #will return us 2

$mult = $a * $b; #multiplication example
echo $mult; #will return us 15

$div = $a / $b; #division example
echo $div; #will return us 1.6667
#we must bear in mind that there is no data typing and will return a decimal value by default

$rest = $a % $b; #example of the rest of the division
echo $rest; #will return us 2

$pot = $a ** $b; #exponentiation example
echo $pot; #will return us 125

Operators of increase (++) and decrease (- -)

These operators are unary operators and they autoincremento and the autodecremento to the variable that applies to them

In addition to modifying the variable, they return the value of the variable

The operator increment or decrement can go before p behind the variable having a different meaning

If the operator is ++, it is placed after the variable is called post-increment, by first taking the value and then increasing the variable by one unit

$n = 0;
$k = 2;

$n = $k++; #The value of $k is assigned to $n, and then $k is increased
echo $n . ' ' . $k; #will return us that the value of $n was 2 and that of $k was 3

If the ++ operator is placed before the variable, it is called pre-increment and makes that first to increase in a unit variable and then take the value

$n = 0;
$k = 2;

$n = ++$k; #The value of $k is increased, and then it is assigned to $n
echo $n . ' ' . $k; #will return us that the value of $n was 3 and that of $k was 3

If the operator is - - it is placed after the variable, it is called post-decrement, making it take the value first and then the variable is decremented by one unit

$n = 0;
$k = 2;

$n = $k--; #The value of $k is assigned to $ n, and then $k is decremented
echo $n . ' ' . $k; #will return us that the value of $n was 2 and that of $k was 1

If the operator - - is placed before the variable, it is called pre-decrement and makes that first decremente in a unit variable and then take the value

$n = 0;
$k = 2;

$n = --$k; #The value of $k is decremented, and then assigned to $n
echo $n . ' ' . $k; #will return to us that the value of $n was 1 and that of $k was 1

Relational operators

Are used typically in the conditional expression

The relational operators return boolean values

The operands can be numerical or strings

$a = 20;
$b = 30;
$c = '20';

if ( $a > $ b) {
   echo '$a is greater than $b'; #example of major, types not taken into account
} #in this case it will not show the message because it is false
if ( $a > $ c) {
   echo '$a is greater than $c'; #example of major, types not taken into account
} #in this case it will not show the message because it is false
if ( $a < $ b) {
   echo '$a is less than $b'; #example of minor, types not taken into account
} #in this case it will show the message for being true
if ( $a < $ c) {
   echo '$a is less than $c'; #example of minor, types not taken into account
} #in this case it will show the message for being true
if ( $a >= $ b) {
   echo '$a is greater than or equal to $b'; #example of greater or equal, the types are not taken into account
} #in this case it will not show the message because it is false
if ( $a >= $ c) {
   echo '$a is greater than or equal to $c'; #example of greater or equal, the types are not taken into account
} #in this case it will not show the message because it is false
if ( $a <= $ b) {
   echo '$a is less than or equal to $b'; #example of less than or equal, types are not taken into account
} #in this case it will not show the message because it is false
if ( $a <= $ c) {
   echo '$a is less than or equal to $c'; #example of less than or equal, types are not taken into account
} #in this case it will not show the message because it is false
if ( $a != $ b) {
   echo '$a is different than $b'; #example of different, types are not taken into account
} #in this case it will show the message for being true
if ( $a != $ c) {
   echo '$ a is different than $ c'; #example of different, types are not taken into account
} #in this case it will show the message for being true
if ( $a <> $ b) {
   cho '$a is different than $b'; #example of different, types are not taken into account
} #in this case it will show the message for being true
if ( $a <> $ c) {
   echo '$a is different than $c'; #example of different, types are not taken into account
} #in this case it will show the message for being true
if ( $a ! = = $ b) {
   echo '$a is different than $b'; #example of different, types are taken into account
} #in this case it will show the message for being true and of the same type
if ( $a ! = = $ c) {
   echo '$a is different than $c'; #example of different, types are taken into account
} #in this case it will not show the message because it is true and of different types
if ( $a == $ b) {
   echo '$a is the same as $b'; #example example, the types are not taken into account
} #in this case it will not show the message because it is false
if ( $a == $ c) {
   echo '$a is the same as $c'; #example example, the types are not taken into account
} #in this case it will not show the message because it is false
if ( $a = = = $ b) {
   echo '$a is the same as $b'; #example example, types are taken into account
} #in this case it will not display the message because it is false and of the same type
if ( $a = = = $ c) {
   echo '$a is the same as $c'; #example example, types are taken into account
} #in this case it will not display the message because it is false and of different types
switch ($a <=> $b) { #Order comparison example, types are taken into account
    case -1:
        echo '$a is less than or equal to $b';
        break;
    case 0:
        echo '$a is equal to $b';
        break;
    case 1:
        echo '$a is greater than $b';
        break;
} # in this case the message of -1 will be displayed as a less than b and of the same type
#in case of being of different type it will return a value other than 0

#We want to get the value of the variable $_GET ['user'] and we will return 'nobody' if it does not exist
$username = $_GET['user'] ?? 'no one';
#Thanks to the operator ?? We have the operation equivalent to:
$username = isset( $_ GET ['user'] ) ? $_GET['user'] : 'nobody';
#which allows us to save code

#We can also use it in a chain, which will return the first value defined in $_GET['user'], $_POST['user'] and 'nobody'
$username = $_GET['user'] ?? $_POST['user'] ?? 'no one';

Logical operators

The logical operands is related to the relational as they are normally the operands used are the result of expressions in relational

The resulting values are boolean

$a = true;
$b = false;

if ($a AND $b) {
    echo '$a and $b are both true';
} else {
    echo '$a or $b are false, or both are false';
}
if ($a && $b) {
    echo '$a and $b are both true';
} else {
    echo '$a or $b are false, or both are false';
}
if ($a OR $b) {
    echo '$a or $b are true, or both are true';
} else {
    echo 'Both are false';
}
if ($a || $b) {
   echo '$a or $b are true, or both are true';
} else {
    echo 'Both are false';
}
if ($a XOR $b) {
    echo '$a or $b are true, but both are not true';
} else {
    echo 'Both are false or both are true';
}
if (!$a) {
    echo 'It was false';
} else {
    echo 'It was true'; # will show this value, because before applying the operator was true
}

Bitwise operators

The way of working of these operators is to convert to the binary operands and then operate with them bitwise

Note Propagation operators take two operands: the first is the variable to propagate and the second is the number of positions to propagate

$a = 0100;
$b = 0101;

$c = $a & b; #AND example
echo $c; #will return the value 0100

$c = $a | b; #OR example
echo $c; #will return the value 0101

$c = $a ^ b; #XOR example
echo $c; #will return the value 0001

$a = 4;
$b = 1;

$c = $a << b; #left propagation example
echo $c; #will return the value 8 which in binary is 00000000000000000000000000001000

$c = $a >> b; #right propagation example
echo $c; #will return the value 2 which in binary is 00000000000000000000000000000010

$a = -4;
$b = 1;

$c = $a << b; #example of propagation to the left of a negative number
echo $c; #will return the value -8 which in binary is 11111111111111111111111111111000

$c = $a >> b; #example of propagation to the right of a negative number
echo $c; #will return the value -2‬ which in binary is 11111111111111111111111111111100

Assignment operators

The assignment is also an operator that returns the variable modified

The assignment operator in PHP is =

The assignment operators shown below are but abbreviations that make expressions more comfortable and simple, even if they are sometimes more unreadable

Other operators

Selection operator

This operator is used to execute an operation or another depending on the condition

The format is as follows:

Condition ? Exp1 : Exp2

If the condition is met it evaluates and returns the expression Exp1 if not the Exp2

We can put a just value

Example:

$x = 5;
$y = 1;
$k = 0;

$i = ($x != $y) ? 6 : $k++;
echo $ i; #in this example $i will return the value 6

New operator

This operator is used to create an instance of a type of objects previously defined

The syntax to follow is as follows:

variableObject = new ObjectType(parameter1, parameter2, ...);

These parameters are passed to the constructor of that object in question

Operador clone

This operator will be used to create a copy of a previously defined object (which invokes, if possible, the method __clone() object)

The syntax to follow is as follows:

variableObject = clone ObjectType;

When cloning an object, PHP will make a shallow copy of the object's properties

Properties that are references to other variables will keep the references

Once cloning is complete, the method will be called __clone() of the new object (if the method __clone() defined), to allow you to make the necessary changes to your properties

gettype operator

This operator applied to a variable returns the type of object to which belongs the data contained by that variable

Its syntax is:

gettype(variable);

The values you can return are:

• boolean

• integer

• double

  For historical reasons it is returned double also when it's kind of float

• string

• array

• object

• resource

• NULL

• unknown type

Preference

The operator precedence will determine the order in which they are running in a given expression

Using parentheses will check that the operations are carried out according to us we want to

In PHP the preference of the operators from highest to lowest is as follows:

Php data types

Types in PHP are a representation of data because it does not require variables to declare their type, because all types are converted automatically

Type boolean

The Boolean type simply distinguishes between two states, a success or enabled state, true value, true, and a failure or deactivated state, false value, false

Both states are not case sensitive

$foo = True; #assign the value TRUE to the variable $foo

Typically, the result of operators that return a Boolean value are passed to a control structure

#equality check example using the == operator that returns a boolean
if ($action == "show_version") {
    echo "The version is 7.3";
}

#this is not necessary...
if ($show_separators == TRUE) {
    echo "<hr>\n";
}

#...because we can save code by writing:
if ($show_separators) {
    echo "<hr>\n";
}

Numeric types

The numeric types can be divided into real and integer

Type integer numeric

• Integer

  integer base 10

  Both positive and negative

• Hexadecimal

  integer base 16

  Placed before the base number 16 0x or 0X

• Octal

  integer base 8

  We place a zero before the number in octal

• Binary

  integer base 2

  Placed before the base number 2 0b or 0B

Formally, the structure of integer literals is:

decimal : [1-9][0-9]* | 0

hexadecimal : 0[xX][0-9a-fA-F]+

octal : 0[0-7]+

binary : 0b[01]+

integer : [+-]?decimal | [+-]?hexadecimal | [+-]?octal | [+-]?binary

Numeric type real

The actual is made up of a whole part and the other fractional separated by a point of the previous

The fractional part can be composed by an indicator of exponent E or E followed by an integer that indicates the value of the exponent

Formally, the structure of the actual type literals is:

LNUM : [0-9]+
DNUM : ([0-9]*[\.]{LNUM}) | ({LNUM}[\.][0-9]*)
EXPONENT_DNUM : [+-]?(({LNUM} | {DNUM}) [eE][+-]? {LNUM})

• Float

  is a floating-point numerical value

  Both positive and negative

  Its size depends on the platform, although its value can be a maximum of approximately 1.8e308, with an accuracy close to 14 decimal digits (IEEE 64 bit format)

  Additionally, rational numbers whose base 10 representation is equal to that used as a floating-point number, such as 0.1 or 0.7, do not have an exact representation as base 2 floating-point numbers, which is the internally employed basis, regardless of the mantissa size

  Therefore, they cannot be converted to binary without a small loss of precision

  Being able to result in precision errors such as floor( (0.1 + 0.7) * 10); normally it would return 8, however, it would return 7, since in its internal representation it will be 7.9999999999999991118...

  Therefore, it is not recommended to trust results with floating-point numbers and not to use the comparison of floating point numbers directly

  If you need more precision, use the mathematical functions of arbitrary precision and the functions of gmp

• Double

  is equivalent to Float and does not provide substantial differences

  In other languages it has double precision, but in PHP it has been maintained for historical reasons and it is advisable to better use the functions that work with Float

• NaN

  Some numerical operations may result in a value represented by the NAN constant

  This result represents an undefined or unrepresentable value using floating point calculations

  Any comparison, whether strict or not, of this value with any other value, including itself, except for TRUE, will result in FALSE

  Since it represents any number of different values, it should not be compared with other values, including itself; instead it should be checked using the function is_nan()

$var1 = 20; #decimal
$var2 = 0x14; #hexadecimal (equals 20 decimal)
$var3 = 024; #octal (equals 20 decimal)
$var4 = 0b‭00010100‬; #binario (equals 20 decimal)

#real
$var5 = 25.478;
$var6 = 2.3E45;
$var7 = 5.6E-2;
$var8 = -3.789;

Type string

A string is a string of characters delimited by quotation marks

Where each character is a byte

This means that PHP only supports a set of 256 characters, hence it does not offer native support for Unicode

A string can only contain up to 2 GB in size (2147483647 bytes maximum)

A string literal can be specified in four different ways:

• single quote

  are specified between the characters ‘ opening and ‘ closing

  To specify a single literal quote, you must escape with a backslash (\). To specify a literal backslash, duplicate (\\)

  All other instances of backslashes will be treated as a literal backslash: this means that other escape sequences that could be used, such as \r or \n, will be displayed literally as specified, instead of having any other special meaning

  Keep in mind that variables and escape statements for special characters will not be expanded when they are included in a string in single quotes

  echo 'This is a simple string';
  
  echo 'You can also include new lines in
  a string in this way, since it is
  correct to do so';
  
  #Result: Arnold once said: "I'll be back"
  echo 'Arnold once said: \"I'll be back\"';
  
  #Result: You have deleted C:\ *. *?
  echo 'You have deleted C:\\ *. *?';
  
  #Result: You have deleted C: *. *?
  echo 'You have deleted C:\*. *?';
  
  #Result: This will not expand: \n a new line
  echo 'This will not expand: \n a new line';
  
  #Result: Variables $var variables  will not expand either
  echo 'Variables $var will not expand';

• double quotes

  are specified between the characters " opening and " closing

  The most important feature of double string quotation marks is the fact that variable names are expanded

  PHP will interpret the following escape sequences as special characters:

  Code	Description
  \n	line feed (LF or 0x0A (10) in ASCII)
  \r	carriage return (CR or 0x0D (13) in ASCII)
  \t	horizontal tab (HT or 0x09 (9) in ASCII)
  \v	vertical tabulator (VT or 0x0B (11) in ASCII) (since PHP 5.2.5)
  \e	escape (ESC or 0x1B (27) in ASCII) (since PHP 5.4.4)
  \f	page feed (FF or 0x0C (12) in ASCII) (since PHP 5.2.5)
  \\	backslash
  \$	dollar sign
  \"	double quotes
  \[0-7]{1,3}	the sequence of characters that matches the regular expression is a character in octal notation, which silently overflows to fit into a byte ("\400" === "\000")
  \x[0-9A-Fa-f]{1,2}	the sequence of characters that matches the regular expression is a character in hexadecimal notation
  \u{[0-9A-Fa-f]+}	the character sequence that matches the regular expression is a Unicode code point, which will be printed to the string as that UTF-8 representation of the code point (added in PHP 7)

  As in the simple quotation mark of a string, escaping any other character can result in the backslash also being displayed

  Prior to PHP 5.1.1, the backslash of the \{$var}

  echo "This is a simple string";
  
  echo "You can also include new lines in
  a string in this way, since it is
  correct to do so";
  
  #Result: Arnold once said: "I'll be back"
  echo "Arnold once said: \"I'll be back\"";
  
  #Result: You have deleted C:\ *. *?
  echo "You have deleted C:\\ *. *?";
  
  #Result: You have deleted C: *. *?
  echo "You have deleted C:\*. *?";
  
  #Result: This will not expand: \n a new line
  echo "This will not expand: \n a new line";
  
  #Result: Variables $var will expand too
  echo "Variables $var will expand";

• heredoc syntax

  are specified by the characters <<< followed by the operator EOT and ends with the EOT operator followed by the ; closing

  The closing identifier must start in the first column of the new line

  Also, the identifier must follow the same naming rules as tags in PHP: it must contain only alphanumeric characters and underscores, and must start with an alphabetic character or underscore

  It is very important to note that the line with the closing identifier must not contain any other characters except the semicolon

  The identifier must not be indented, and there should be no space or tab before or after the semicolon

  The first character before the closing identifier must be a line break defined by the local operating system

  \n UNIX systems, including Mac OS X

  In addition, the closing delimiter must also be followed by the newline

  If this rule is broken and the closing identifier is not clean, will not be considered as a closing identifier, so PHP will continue to look for one

  If no appropriate closing identifier is found before the end of the file, a parsing error will occur on the last line

  You cannot use Heredoc to initialize the properties of a class

  Since PHP 5.3, this limitation is valid only for an heredoc that contains variables, as it is possible to initialize static variables and class properties/constants

  In that version we also introduced the possibility of quoting the opening identifier in Heredoc

  #heredoc in invalid class initialization
  class foo {
      public $bar = <<<EOT
  bar
      EOT;
  }
  
  $str = <<<EOD
  Example of a string
  expanded in several lines
  using the heredoc syntax
  EOD;
  
  #heredoc using variables and fields of a class
  class foo {
      var $foo;
      var $bar;
  
      function foo() {
          $this->foo = 'Foo';
          $this->bar = array('Bar1', 'Bar2', 'Bar3');
      }
  }
  
  $foo = new foo();
  $name = 'MyName';
  
  echo <<<EOT
  My name is "$name". I'm writing a little bit of $foo->foo.
  Now, I'm writing a little bit of {$foo->bar[1]}.
  This should show a capital 'A': \x41
  EOT;
  
  /* That would result in:
  
  My name is "MyName". I'm writing a little bit of Foo.
  Now, I'm writing some Bar2.
  This should show a capital 'A': A
  */
  
  #example using arguments
  var_dump(array(<<<EOD
  foobar!
  EOD
  ));
  
  #Static variables
  function foo() {
      static $bar = <<<LABEL
  Nothing here...
  LABEL;
  }
  
  #Properties / class constants
  class foo {
      const BAR = <<<FOOBAR
  Constant example
  FOOBAR;
  
      public $baz = <<<FOOBAR
  Property Example
  FOOBAR;
  }
  
  #Example use of double quotes
  echo <<<"FOOBAR"
  Hello World!
  FOOBAR;

• nowdoc syntax (since PHP 5.3)

  is to strings with single quotes the same as Heredoc is to strings with double quotes

  A nowdoc is specified similarly to a heredoc, but no analysis is performed within the nowdoc

  The construction is ideal for embedding PHP code or large pieces of text without having to escape them

  Share some common features with construction SGML, where a block of text is declared that is not parsed

  A nowdoc is identified by the same sequence used for heredoc, <<<, but the identifier that follows it is delimited with single quotation marks

  All rules for heredoc identifiers also apply to nowdoc identifiers, especially those that refer to the use of the closing identifier

  $str = <<<'EOD'
  Example of a string
  expanded in several lines
  using the heredoc syntax
  EOD;
  
  #heredoc using variables and fields of a class
  class foo {
      var $foo;
      var $bar;
  
      function foo() {
          $this->foo = 'Foo';
          $this->bar = array('Bar1', 'Bar2', 'Bar3');
      }
  }
  
  $foo = new foo();
  $name = 'MyName';
  
  echo <<<'EOT'
  My name is "$name". I'm writing a little bit of $foo->foo.
  Now, I'm writing a little bit of {$foo->bar[1]}.
  This should show a capital 'A': \x41
  EOT;
  
  /* That would result in:
  
  My name is "$name". I'm writing a little bit of $foo->foo.
  Now, I'm writing a little bit of {$foo->bar[1]}.
  This should show a capital 'A': \x41
  */
  
  #Static variables
  class foo {
      public $bar = <<<'EOT'
  bar
  EOT;
  }

Variable analysis

When a string is specified by double quotation marks or by heredoc, variables within that string will be parsed

There are two types of syntax:

• simple

  is the most employed and practical

  Provides a way to embed a variable, an array value, or a property of an object within a string with minimal effort

• complex

  can be recognized by the keys that delimit the expression

Simple syntax

If a dollar sign ($) is found, the analyzer will take the largest number of symbols to form a valid variable name

Delimiting the variable name with braces allows you to explicitly specify the end of the name

$juice = "apple";

#Initial phrase we want to modify to add the plural
echo "He drank some juice from $juice";
#Invalid. "s" is a valid character for a variable name, but the variable is $juice.
echo "He drank some juice made of $juices";
#Valid. Explicitly specifies the end of the variable name by enclosing it in braces:
echo "He drank some juice made of ${juice}s"

/* Giving us as a result

He drank some juice from apple
He drank some juice made of
He drank some juice made from apples
*/

Similarly, you can analyze the index of an array or the property of an object

With array indices, the closing bracket (]) marks the end of the index

The same rule can be applied to object properties and simple variables

$ juices = array ("apple", "orange", "koolaid1" => "purple");

echo "He drank some juice from $juices[0]";
echo "He drank some juice from $juices[1]";
echo "He drank some juice $juices[koolaid1]";

class person {
    public $john = "John Smith";
    public $jane = "Jane Smith";
    public $robert = "Robert Paulsen";
    public $smith = "Smith";
}

$ person = new person ();

echo "$person->john took some juice from $juices[0]";
echo "$person->john then said hello to $person->jane";
echo "The wife of $person->john greeted $person->robert";
echo "$person->robert greeted the two $person->smiths"; // It will not work

/* Giving us as a result

He drank some juice from apple
He took some juice from orange
He drank some juice form purple
John Smith took some juice from apple
John Smith then said hello to Jane Smith
John The wife of Smith greeted Robert Paulsen
Robert Paulsen greeted the two
*/

Complex syntax

Allows the use of complex expressions

Any scalar variable, array element, or object property with a representation of type string can be included through this syntax

You simply type the expression the same way it would appear outside the string, delimiting it with { and }

Given that { cannot be escaped, this syntax will be recognized only when the $ immediately follow the {

Use {\$ to get a {$ literal

Some examples to make it clearer:

#Show all errors
error_reporting (E_ALL);

$great = 'fantastic';

#Not work, shows: This is { fantastic}
echo "This is { $great}";

#Works, shows: This is fantastic
echo "This is {$great}";

class square {
    public $width = 20;
    public $length = 20;
}

#Works, shows: This is fantastic has 20.0 centimeters of side.
echo "This square has {$square->width}.00 centimeters of side.";

#Works, keys in quotes only work using key syntax
echo "This works: {$arr['key']}";

#Works
echo "This works: {$arr[4][3]}";

/*
This does not work for the same reason that $foo[bar] is incorrect outside a string
In other words, it would still work, but only because PHP first looks for a
constant called foo; an error of level E_NOTICE will be issued
(constant not defined)
*/
echo "This is wrong: {$arr[foo][3]}";

/*
Works. When using multidimensional arrays, always use keys that delimit
to arrays when in a string
*/
echo "This works: {$arr['foo'][3]}";

#Works
echo "This works:". $arr['foo'][3];

echo "This also works: {$obj->values[3]->name}";

echo "This is the value of the variable called $name: {${$name}}";

echo "This is the value of the variable called by the value returned by getName(): {${getName()}}";

echo "This is the value of the variable called by the value returned by \$object->getName(): {${$object->getName ()}}";

#Not work, shows: This is the value returned by getName (): {getName ()}
echo "This is the value returned by getName (): {getName ()}";

With this syntax, it is also possible to access the properties of a class by using variables within a string

class foo {
     var $ bar = 'I am bar';
}

$foo = new foo();

$ bar = 'bar';
$ baz = array('foo', 'bar', 'baz', 'quux');
echo "{$foo->$bar} \n";
echo "{$foo->{$baz[1]}} \n";

/* Giving us as a result

I'm a bar
I'm a bar
*/

Functions, method calls, static class variables, and class constants within {$} work from PHP 5

However, the accessed value can be interpreted as the variable name in the scope in which the string is defined

The use of simple keys ({}) will not be used to access the value returned by functions or methods, or the values of static class constants or class variables

#Show all errors.
error_reporting (E_ALL);

class beers {
     const soda = 'zarzaparrilla';
     public static $ale = 'ipa';
}

$zarzaparrilla = 'A & W';
$ipa = 'Alexander Keith\'s';

#Works; Sample: I like an A & W
echo "I like a {${beers::soda}}\n";

#Also works; Sample: I like an Alexander Keith's
echo "I like a {${beers::$ale}}\n";

Arrays

An array in PHP is actually an ordered map

A map is a type of data that associates values with keys

This type is optimized for several different uses; it can be used as an array, list (vector), associative table (hash table – an implementation of a map), dictionary, collection, stack, queue, etc

Since the values of an array can be other arrays, multidimensional trees and arrays are also possible

The following syntax is used to create an array:

$array = array (
     key => value,
     key2 => value2,
     key3 => value3,
     ...
);

Where we have the function array() which serves as a constructandr and takes as parameters key/value pairs separated by commas and joined with the symbols =>

The comma after the last element of the array is optional, and can be omitted

Since with PHP 5.4 you can also use the short array syntax, which replaces the function array() with []

$array = [
     key => value,
     key2 => value2,
     key3 => value3,
     ...
];

The key can be an integer or a string

In addition, the keys must comply with:

• A strings containing a valid integer will be mourned to the integer type

  The key "8" will actually be stored as 8

  "08" not be converted as it's not a valid decimal integer number

• A float will be forced to integer, which means that the decimal part be removed

  The key 8.7 actually be stored as 8

• A Boolean be forced to integer also, namely, the true key will actually be stored as 1 and false as the key 0
• Un null será forzado a string vacío, es decir, la clave null en realidad será almacenada como ""
• Arrays and objects can not be used as key

  If we do, we will place a warning: Illegal offset type

• If several elements in the declaration of the array using the same key, only the latter will be used, the others being overwritten

The key is optional and if not specified, PHP will use the increase in the key rate previously used integer greater

$array = array("foo", "bar", "hello", "world");
var_dump($array);

/* Will return

array(4) {
  [0]=>
  string(3) "foo"
  [1]=>
  string(3) "bar"
  [2]=>
  string(5) "hello"
  [3]=>
  string(5) "world"
}
*/

You can specify the key only to some elements and exclude others:

$array = array(
         "a",
         "b",
    6 => "c",
         "d",
);
var_dump($array);

/* Will return

array(4) {
  [0]=>
  string(1) "a"
  [1]=>
  string(1) "b"
  [6]=>
  string(1) "c"
  [7]=>
  string(1) "d"
}
*/

Array elements can be accessed using the syntax array[key]

$array = array(
    "foo" => "bar",
    42    => 24,
    "multi" => array(
         "dimensional" => array(
             "array" => "foo"
         )
    )
);

var_dump($array["foo"]);
var_dump($array[42]);
var_dump($array["multi"]["dimensional"]["array"]);

/* Will return

string(3) "bar"
int(24)
string(3) "foo"
*/

Note Both brackets as the keys can be used interchangeably to access array elements ($array[42] and $array{42} will have the same result in the previous example)

Since PHP 5.4 is possible to refer to the array of the result of a call to a function or method directly

In previous versions it was only possible using a temporary variable

Since PHP 5.5 it is possible to directly reference an element of an array literal

function getArray() {
    return array(1, 2, 3);
}

#In PHP 5.4
$secondElement = getArray()[1];

#before that version
$tmp = getArray();
$secondElement = $tmp[1];

#as a literal array
list(, $secondElement) = getArray();

Note Trying to access a key part of an array that is not defined is the same as accessing any other undefined variable: an error message will be issued level E_NOTICE, and the result will be NULL

An existing array can be modified by explicitly setting values ​​in it

This is done by assigning values ​​to the array, specifying the key in brackets

This can also be omitted, resulting in an empty pair of brackets ([])

/*
key can be an integer or a string
value can be any value of any kind
*/

$ arr[key] = value;
$ arr[] = value;

If $arr does not yet exist, it is created, this being also an alternative way to create an array

However, this practice is discouraged because if $arr already contains a value (a string of a request variable), this will be in place and [] can really mean the access operator strings

It is always better to initialize variables through direct allocation

To change a certain value must be assigned a new value to that element using its key

To remove a key/value pair, call the function unset()

Iterables

A Iterable is a pseudotype introduced in PHP 7.1

Accepts any array or object that implements the interface Traversable

These two types are crossed with foreach and can be used to yield from within a generator

Iterable may be used to indicate that a function requires a set of values, but no matter the form of the whole and it will be used with foreach

If a value is not an array or an instance of Traversable, it will launch a TypeError

function foo(iterable $iterable) {
    foreach ($iterable as $value) {
        //rest of the code
    } 
}

Parameters declared as iterable be used NULL or an array as the default

Objects

Objects consist of a set of values, properties, and a set of methods applied to those values

It is these methods that allow us to modify the state of that object, that is, the value of its properties

Let's create a academic sample object where you have the properties: Name, Surname, Age and Identity card

The instance of the object we'll create using the new operator as follows:

class Univers {
    public $nom;
    public $apell;
    public $age;
    public $dni;
}

$student = new Univers(); #The object instance

You can initialize all variables to have the kind we want, we will use the class constructor passing the arguments we need

From PHP 7 we can also specify the type of the argument

By keyword $this we can reference to the current object

class Univers {
    public $nom;
    public $apell;
    public $age;
    public $dni;

    public function __construct( string $nom, string $apell, int $age, int $dni ) {
        $this->nom = $nom;
        $this->apell = $apell;
        $this->age = $age;
        $this->dni = $dni;
    }
}

$student = new Univers("Juan", "Delgado", 12, 44565789); #The object instance

The properties of an object can be described by other objects

class M_Note {
    public $course1;
    public $course2;
    public $course3;
    public $final;

    public function __construct( float $course1, float $course2, float $course3, float $final) {
        $this->course1 = $course1;
        $this->course2 = $course2;
        $this->course3 = $course3;
        $this->final = $final;
    }
}

class Univers {
    public $nom;
    public $apell;
    public $age;
    public $dni;
    public $expedient;

    public function __construct( string $nom, string $apell, int $age, int $dni, M_Note $expedient) {
        $this->nom = $nom;
        $this->apell = $apell;
        $this->age= $age;
        $this->dni = $dni;
        $this->expedient = $expedient;
    }
}

$mean_note = new M_Note(6.5, 7.95, 8.12, 7.23); #The object instance
$student = new Univers("Juan", "Delgado", 12, 44565789, $mean_note); #The object instance

The definition of methods associated with an object can be specified in the object definition

For example, for the university object we define a function that shows the student's first name, age, last name, id, and middle grades

To access the properties or methods will use the operator ->

class M_Note {
    public $course1;
    public $course2;
    public $course3;
    public $final;

    public function __construct( float $course1, float $course2, float $course3, float $final) {
        $this->course1 = $course1;
        $this->course2 = $course2;
        $this->course1 = $course3;
        $this->final = $final;
    }
}

class Univers {
    public $nom;
    public $apell;
    public $age;
    public $dni;
    public $expedient;

    public function __construct( string $nom, string $apell, int $age, int $dni, M_Note $expedient) {
        $this->nom = $nom;
        $this->apell = $apell;
        $this->age= $age;
        $this->dni = $dni;
        $this->expedient = $expedient;
    }

    public function Data() : string {
        public $output = '';

        $output .= 'Name: ' . $this->nom;
        $output .= ' Last name: ' . $this->apell;
        $output .= ' Age: ' . $this->age;
        $output .= ' Identification document: ' . $this->dni;
        $output .= ' Course1: ' . $this->expedient->course1;
        $output .= ' Course2: ' . $this->expedient->course2;
        $output .= ' Course3: ' . $this->expedient->course3;
        $output .= ' Final: ' . $this->expedient->final;

        return $output;
    }
}

$mean_note = new M_Note(6.5, 7.95, 8.12, 7.23); #The object instance
$student = new Univers("Juan", "Delgado", 12, 44565789, $mean_note); #The object instance

echo $student->Data();

Resources

A resource type is a special value variable, which contains a reference to an external resource

Resources are created and used by special functions

You can be obtained by the resource type function get_resource_type()

Thanks to the reference-counting system introduced with PHP 4's Zend Engine, a resource that is no longer referenced is automatically detected and is released by the garbage collector

For this reason, rarely you need to free the memory manually

Note Persistent links to databases are an exception to this rule

They are not destroyed by the garbage collector to being persistent connections

Null value

PHP variables can be assigned a value indicating the empty value, this value is the value NULL

A variable is considered NULL if:

• has been assigned the constant NULL
• has not yet been assigned a value
• has been destroyed function unset()

The constant NULL is insensitive to case sensitive

$var = NULL;

The conversion of data types

First of all, remember that PHP does not need type declaration

The contents of the variable will be converted automatically in the course of the programme according to its use

The type conversion scheme is based on the following principle: the associated type corresponds to that of the left operand

This is because the evaluation is done from left to right

$a_string = "7";
$a_number = 42;

$x = $a_string + $a_number;
$y = $a_number + $a_string;
echo $x . '' . $y;

The first expression will convert the variable $a_number in a string of characters because the operand on the left $a_string is a string of characters

This expression concatenates the two character strings and the result of x is: "742"

In contrast, the second expression converts the string $a_string in a numerical value because the operand on the left $a_number, is a number

This second expression sums the two numbers and the result of and is: 49

Type conversion cannot be done in all possible cases: certain character strings cannot be converted to number

Such conversions fail with an error

$a_string = "Pepe";
$a_number = 578;
$y = $a_number + $a_string; #ERROR: "Pepe" cannot become a number

The behavior of automatic array conversion is currently undefined

Because PHP supports string indexing using offsets using the same syntax used in array indexing, the following examples are valid for all PHP versions:

$a = 'car'; #$a is a string
$a[0] = 'b'; #$a still a string
echo $a; #returns 'bar' instead of 'car', since we have modified the value of the 0 position of the array

Casting

Casting in PHP works the same way as in C, where the name of the desired type is enclosed in parentheses before the variable you want to force

Tabs and spaces are allowed within parentheses, so the following examples are functionally equivalent:

$foo = (int) $bar;
$foo = ( int ) $bar;

Example of literal snapping of strings and variables to binary strings

$binary = (binary) $string;
$binary = b"binary string";

Double quotation marks allow you to avoid forcing a variable to string, because the result is equivalent

$foo = 10; #$foo is an integer
$str = "$foo"; #$str is a string
$fst = (string) $foo; #$fst is also a string

#This equality shows us that "They are the same"
if ($fst === $str) {
    echo "They are the same";
}

Converting to boolean

To explicitly convert a value to the boolean type, use casting (bool) or (boolean)

However, in most cases it is unnecessary, because a value will be converted automatically if an operator, function, or control structure requires an argument of type boolean

A value can also be converted to the boolean type using the function boolval()

When converting to boolean, the following values are considered FALSE:

• the boolean FALSE
• the integer 0 (zero)
• the float 0.0 (zero)
• the string value empty, and the string "0"
• an array with zero elements
• an Object with zero member variables (PHP 4 only)
• special type NULL (including variables not set)
• SimpleXML objects created from empty tags

Any other value is considered TRUE (including a resource variable)

Note: -1 is considered TRUE, like any other non zero (whether positive or negative)

var_dump( (bool) "" ); #bool(false)
var_dump( (bool) 1 ); #bool(true)
var_dump( (bool) -2 ); #bool(true)
var_dump( (bool) "foo" ); #bool(true)
var_dump( (bool) 2.3e5 ); #bool(true)
var_dump( (bool) array(12) ); #bool(true)
var_dump( (bool) array() ); #bool(false)
var_dump( (bool) "false" ); #bool(true)

Converting to integer

To explicitly convert a value to the integer type, use casting (int) or (integer)

However, in most cases it is unnecessary, since a value will be automatically converted if an operator, function or control structure requires an argument of type integer

A value can also be converted to the integer type by function intval()

If a resource is converted to integer, the result will be the number one resource assigned to the resource by PHP at runtime

From Booleans

FALSE will produce 0 (zero), and TRUE will produce 1 (one)

From floating point numbers

When a float is converted to an integer, the number be rounded towards zero

If the value of type float is below the limit of an integer (usually +/- 2.15e+9 = 2^31 on 32 bit platforms and +/- 9.22e+18 = 2^63 64 bit platforms other than Windows), the result is undefined, because float does not have sufficient precision to deliver the result as an exact integer

No warning is displayed, not even a warning when this happens

Note From PHP 7, instead of being indefinite and platform dependent, NaN and Infinity always be zero forcing type to integer

Note You should never turn an unknown fraction to integer, as sometimes can lead to unexpected results

echo (int) ( (0.1 + 0.7) * 10 ); #The result shows 7 when it should be 8!

From strings

If the string does not contain any of the '.', 'E', or 'E', and the numerical value is within the bounds of the integer type (as defined by PHP_INT_MAX), the string is evaluated as an integer

In all other cases it will be evaluated as a float

The value is given by the initial portion of the string

If the string starts with valid numeric data, this will be the value used

Otherwise, the value is 0 (zero)

A valid numeric data is an optional sign, followed by one or more digits

$foo = 1 + "bob-1.3e3"; #$foo is integer (1)
$foo = 1 + "bob3"; #$foo is integer (1)
$foo = 1 + "10 small pigs"; #$foo is integer (11)

Do not wait for the code of one character by converting it to integer, as in C

Use functions ord() and chr() to convert characters to their ASCII code

From other types

The behavior of converting to integer is undefined other

Do not rely on any observed behavior, as it can change without notice

Converting to floating point number

To explicitly convert a value to the float type, use the casting (float) or (double) or (real)

However, in most cases it is unnecessary, because a value will be converted automatically if an operator, function, or control structure requires an argument of type float

A value can also be converted to the type float by function floatval()

From strings

If the string does not contain any of the '.', 'E', or 'E', and the numerical value is within the bounds of the integer type (as defined by PHP_INT_MAX), the string is evaluated as an integer

In all other cases it will be evaluated as a float

The value is given by the initial portion of the string

If the string starts with valid numeric data, this will be the value used

Otherwise, the value is 0 (zero)

Valid numeric data is an optional sign followed by one or more digits (optionally may contain a decimal point), followed by an optional exponent

The exponent is an 'e' or 'E' followed by one or more digits

$foo = 1 + "10.5"; #$foo is float (11.5)
$foo = 1 + "-1.3e3"; #$foo is float (-1299)
$foo = 4 + "10.2 small pigs"; #$foo is float (14.2)
$foo = "10.0 pigs" + 1; #$foo is float (11)
$foo = "10.0 pigs" + 1.0; #$foo is float (11)

From other types

The conversion is the same as if the value had been converted first to integer and then to float

Starting with PHP 5, a warning is generated if you try to convert an object to float

Converting to String

To explicitly convert a value to the string type, use the casting (string)

However, in most cases it is unnecessary, since a value will be automatically converted if an operator, function or control structure requires an argument of type string

A value can also be converted to the string type by function strval()

There is also an automatic conversion when used display functions echo or print

From Booleans

The value TRUE of the type boolean is converted to the string "1"
The value FALSE of the type boolean is converted to the string "" (the empty string)

This allows the conversion in both directions between the values ​​boolean and string types

From numbers

An integer or float is converted to a string that represents the number textually (including the exponent part for float)

Floating point numbers can be converted using exponential notation (for example 4.1E+6)

Note The character for the decimal point is defined in the script locale variable (category LC_NUMERIC). See the function setlocale()

From arrays

Arrays are always converted to the string " Array"

For this reason, echo and print can't by themselves display the contents of an array

To view a single item individually, use a construct such as echo $arr[‘foo’]

You can use the function print_r to perform the conversion and visualize the contents of the entire array

From object

Objects from PHP 4 are always converted to string "Object"

To get the class name of an object, use the function get_class()

Since PHP 5, you can use the method __toString when relevant

You can use the functions print_r or var_dump() to see more effective means of inspecting the content of these types

From resource

A resource is always converted to string with the structure "Resource id #1", where 1 is the resource number assigned to the resource by PHP during execution

Although it should not be dependent on the exact structure, because it is subject to changes during execution, it will always be unique for a given resource within the lifetime of that running script (that is, a web request or CLI process), so it won't be reused

To get the type of a resource, use the function get_resource_type()

You can use the functions print_r or var_dump() to see more effective means of inspecting the content of these types

From NULL

NULL is always converted to an empty string ""

From other types

Most PHP values can be converted to a string for permanent storage

This method is called serialization, and is performed by the function serialize()

Because the PHP engine was built with support for WDDX, PHP values can also be serialized as well formed XML text

Converting to array

From object

If you convert an object to an array, the result is an array whose elements are the properties of the object

Keys are the names of member variables, with some notable exceptions: private variables have the class name at the beginning of the variable name; protected variables have a '*' character at the beginning of the variable name

These values added at startup have null bytes on the sides

This can result in some unexpected behaviors:

class A {
    private $A; #This field will become '\0A\0A'
}

class B extends A {
    private $A; #This field will become '\0B\0A'
    public $AA; #This field will become 'AA'
}

var_dump( (array) new B() ); #there should be two keys called 'AA', but one of them is called '\0A\0A'

From NULL

If you convert a value NULL to array, you get an empty array

From other types

For any of the types: integer, float, string, boolean, and resource, converting a value to an array results in an array with a single element, with index 0, and the scalar value that was converted

In other words, (array) $scalarValue is exactly the same as array($scalarValue)

Converting to object

If an object becomes an object, it is not modified

From other types

If a value of any other type becomes an object, a new instance of the built-in stdClass class is created

If the value is NULL, the new instance will be empty

An array becomes an object with the properties named as keys and the corresponding values, with the exception of the numeric keys, which will be inaccessible unless they are traversed

$obj = (object) array('1' => 'foo');
var_dump( isset($obj->{'1'}) ); #return 'bool(false)'
var_dump( key($obj) ); #return 'int(1)'

$obj = (object) 'ciao'; #For any other value, a member variable called scalar will contain the value
echo $obj->scalar; #return 'ciao'

Converting to resource

Since the resource variables contain special managers to open files, connections to databases, graphic areas for images and the like, the conversion to resource type is meaningless

Conversting to NULL

Note This feature has been declared deprecated as of PHP 7.2 and its use is totally discouraged

Converting a variable to null using (unset) $var will not delete the variable or destroy its value

It will only return one value NULL

Control structures in PHP

For control structures, PHP has the control sentences typical of high level languages

Variable statement

Variables in PHP are not assigned a predefined type

In PHP the type of variables depends on the value they contain at all times

Therefore it performs an automatic conversion of types

PHP recognizes the following types of values:

• Numbers

  integers and real

• Boolean values

  true and false

• Strings
• Arrays

  data type that associates values with keys (such as an ordered map)

• Iterables

  pseudotype introduced in PHP 7.1

  Accepts any array or object that implements the interface Traversable

• Resources

  reference to an external resource

• The value null
• Objects

  Created by the programmer or pre-defined by the language

Since there are no types of a priori variables, we do not have to specify the type of variable when declaring it

The variable declaration is made by prepending the reserved word $ to the variable name

It is possible to assign the value when we declare

$my_variable = 124;

The if sentence

The if sentence has the form:

if (Condition) {
	Instruction 1 or block of instructions;
}
[else {
	Instruction 2 or block of instructions;
}]

The parentheses associated that define the condition are not optional

If the condition is true, instruction 1 will be executed; otherwise it is executed if there is instructution 2

The use of the sentence else is optional, so brackets have been used in the definition

If omitted, the instruction block will only be considered when the condition is true

A block of instructions is a set of instructions bounded by curly brackets

if (Condition) {
	Instruction 1;
	Instruction 2;
	...
	Instruction N;
}

Keys after sentencing if are not required

If omitted and the condition was true, the following instruction will be executed

Otherwise, the subsequent instruction will be executed, independent of the condition state

Thus, the omission of keys after the sentence if it will allow us to write everything on a single line finished in ;

if (Condition) if Instruction;
Subsequent Instruction;

The elseif sentence

We can also use sentences if anities by sentencing elseif

Sentences elseif work just like a sentence if

But they will only be executed in case the condition of the sentence if was false

if (Condition) {
    Block of Instructions if;
}
[elseif (Condition) {
    Block of Instructions del elseif;
}]

The switch sentence

Makes is select a group of sentence among several possible

It is an alternative to the use of sentences elseif anities

Its syntax is:

switch (Expression) {
	case Value 1:
		Instruction or block of instructions;
		[break;]
	case Value 2:
		Instruction or block of instructions;
		[break;]
	case Value 3:
		Instruction or block of instructions;
		[break;]
	...
	case Value N:
		Instruction or block of instructions;
		[break;]
	[default:]
		Instruction or block of instructions;
}

The expression in parentheses of the switch must be integer or string

Your result will be compared with the different values of the case

If it matches one of them, the following sentence will be moved to the case with that value and consecutive instructions will continue to be executed until a sentence is found break or reach the switch lock keys

In case the result of the expression does not match any value, execution will be passed to the next statement sentence on the label default, if there were, and it will continue as a case

The values in the case can be a constant expression

There can be two case with the same value

$a = [1, 2, 3];

foreach ($a as $b) {
    switch($b) {
        case 1:
            echo 'a';
            continue 2;
        case 2:
            echo 'b';
            continue 2;
        default:
            echo 'c';
            continue 2;
    }
    echo '0';
}
# It will show abc0

Unlike other languages, the sentence continue applies to switch and acts in a similar way to break

If you have a switch within a loop and want to continue to the next iteration of the outer cycle, it will be used continue 2

switch ($beer) {
    case 'Tuborg';
    case 'Carlsberg';
    case 'Heineken';
    case 'San Miguel';
        echo 'Good choice';
        break;
    default;
        echo 'Please choose another beer...';
    break;
}

You can use a semicolon instead of a colon after a case

Consecutive instructions will continue to be executed normally until a sentence is found break or reach the switch lock keys

The match statement

It was added in PHP 8.0 version

Makes is select a group of sentence among several possible

It is an alternative to the use of sentences elseif nested and is similar to the statement switch

Similar to a sentence switch, a match expression has a subject expression that is compared against multiple alternatives

Unlike switch, will be evaluated at a value very similar to that of ternary expressions

But using an identity check (===) instead of a weak equality check (==)

Return a value

Subsequent values ​​are no longer processed, as is done in statements switch

It is not possible to execute blocks of code in each condition, as is done in statements switch

The expression used in the match must be complete, if it is not handled by any case the exception will be thrown UnhandledMatchError

Within the same case it can contain several expressions separated by a comma, it is similar to a OR logical

A special case is the pattern default, which allows matching anything that has not been previously matched

If several default patterns are used, the exception will be thrown E_FATAL_ERROR

Its syntax is:

$return_value = match (expression) {
    single_conditional => return_expression,
    conditional_expression1, conditional_expression2, ... conditional_expressionN => return_expression,
    [default => return_expression,]
};

Let's see how the example about beers that we saw with would look switch, now with match:

$string_beer = match ($beer) {
    'Tuborg', 'Carlsberg', 'Heineken', 'San Miguel' => 'Good choice',
    default => 'Please choose another beer...',
};

echo $string_beer;

The while sentence

The while sentence has the form

while (Condition){
	Instruction or block of instructions;
}

The parentheses are not optional

If the condition is met, the sentence or instruction block is executed and the process is repeated until the condition is no longer met

The do sentence

The do sentence has the form

do {
    Instruction or block of instructions;
while (Condition);

It's very similar to the sentence while, except that the condition goes after the instruction or block of instructions

So they are executed at least once even if the condition is false

The for sentence

In the case of such a sentece, in PHP we can distinguish two variants:

• The loop for "classic"
• The foreach loop

The loop for "classic"

This loop has a syntax very similar to that of C / C+

for ([Initialization]; [Condition]; [Expression]) {
	Instruction or block of instructions;
}

In this syntax:

Initialization creates the counter variable and gives it an initial value

Condition must be fulfilled for the loop to run

Depends on the variable index

Expression updates the value of the variable index

The equivalent of this while expression is:

Initialization;

while (Condition) {
	Instruction 1;
	Instruction 2;
	...
	Instruction N;
	Expression;
}

The foreach loop

This loop has a syntax very similar to the for-each Java

Itera una variable $var sobre todas las propiedades de un objeto $obj que se le pasa

Así para cada valor de $var se ejecutaran las sentencias del bucle

Therefore, the loop will have as many iterations as the object's properties, and in each iteration the variable will have the value of the corresponding object's property with that iteration

Its syntax is:

for (var as obj) {
	Instruction or block of instructions;
}

The break sentence

The break sentence can be placed within a loop or anities loops

When you execute the break sentence exits the loop more internal

To all effects, the break sentence acts as a jump to the sentence following the loop in which it runs

The continue sentence

The continue sentence does not leave the loop but causes the next iteration to run

In the loop while the execution of the continue causes the program flow to jump to the condition

In the for loop the continue execution causes the increment expression to run, and then continue normally with the condition

That is, running the continue prevents the rest of the loop body from running

If you have a switch within a loop and you want to continue to the next iteration of the outer cycle, it will be used continue 2

Functions in PHP

To define functions we have the instruction function

After this reserved word is placed the name of the function followed by a list of arguments delimited by parentheses and separated by commas

function name( param1, param2,..., paramn ) {
    instructions in PHP;
}

Arguments

The argument step is optional and in some cases there may be functions that lack them

For example, the function phpinfo has no arguments

This function shows us information regarding the PHP module we are using and always returns the integer value 1

Type of arguments

Starting with PHP 7 you can optionally declare the type of arguments passed to the function

Supports types string, int, float, array, callable and clases

function sum( int $a, int $b ) {
    echo($a + $b); #will show us the result of the sum
}

sum(5, 'a'); #the second argument had to be of type int, an error message will be displayed

If the function user misinculated them or uses another type of data, PHP will return an error message indicating it

Default value arguments

Sometimes we need an argument to have a value, to avoid an error, even if the function user does not enter it

Note that default arguments become optional and that all arguments to the left of the first default value are required

#the second argument has the value 1 by default, to avoid dividing by 0
function divide( int $a, int $b = 1 ) {
    echo($a / $b); #will show us the result of the division
}

divide(10, 2); #function has been used in the normal way
divide(5); #second argument has been dropped, $b will have the value 1, which was its default value

Arguments by value or by reference

When we pass a value to a function, even if we modify it, when we exit the function it will retain its original value

This is the default situation and is called a argument by value

Since an in memory copy of the variable is used and when the function is exited, that copy of the variable is destroyed

In the event that we want changes made to the value of the variable to be preserved after exiting the function, we must use the symbol & in front of the variable name

This situation is called a argument by reference

Since a reference to the variable is used in memory, working directly on the variable and when the function is exited, all changes remain

#argument $a is passed by value
function increase( int $a = 0 ) {
    $a++;
}

#argument $a is passed by reference
function increase( int &$a = 0 ) {
    $a++;
}

$a = 5;
increase($a);
echo($a); #will show value 5, since $a was passed by value, has not changed
increase($a);
echo($a); #will show the value 6, since $a was passed by reference, yes it has changed

Until PHP 5.0.5 it was possible to indicate that a function was by reference using the symbol & in front of the function name

However, as of PHP 5.3.0 it would go on to indicate with a message call-time pass-by-reference that its use was obsolete

As of PHP 5.4.0 it was completely removed and currently produces a fatal error

function foo( &$var) {
    $var++;
}

# & has not been used
function bar() {
    $a = 5;

    return $a;
}

#Will produce a fatal error as of PHP 5.0.5, a warning as of PHP 5.1.1, and a warning as of PHP 7.0.0
foo( bar() );

foo( $a = 5 ); #is an expression, not a variable, it is allowed
foo(5); #Produces a fatal error, it was a constant

class Foobar {}

foo( new Foobar() ); #As of PHP 7.0.7 produces a warning, only variables should be passed by reference

That is, only the symbol can be used & when passing arguments, never in the function name

We can only pass by reference:

• Variables
• References returned from functions

The return statement

The statement return it is the one that allows you to return the result of a function

Starting with PHP 7, you can optionally declare the type returned by the function

Supports types string, int, float, array, callable and clases

To declare the type, the symbol will be written : after the parentheses that follow the arguments and before the start key {

function sum( int $a, int $b ) : int {
    return $a + $b; #will return the result of the sum
}

echo sum(5, 6); #will show 11

Functions are predefined by the language

Display functions

Echo

The function echo is used to send the output of its arguments to the browser

We have continuously used it in previous examples

It has the format:

echo( string $arg1 [, string $... ] ) : void;

It has the following characteristics:

• We can do without the parentheses in their use, since they are optional

• Converts all information to string before sending it to the browser

• If we use several echo in a row, we will find that the result concatenates it in the same line

  To solve it we will have to use the HTML tag <br/>
  to jump the line

• If we use several in a row, we will find that the result does not add a space at the end and therefore the content could show incomprehensible texts, lacking that space

  To solve it we will have to add a space at the end of the first echo or at the beginning of the next echo

echo("This is the example of echo"); #with parentheses
echo "test"; #without parentheses
echo 1;
#will show in the browser 'This is the example of echotest1'

#the result was not well understood, we tried to solve it
echo "This is the example of echo<br/>"; #has been added <br/> at the end, to jump line
echo "test"; #a space has been added at the end, to make it easier to read
echo 1;
/* will show in the browser
'This is the example of echo
test 1'
*/

printf

The function printf serves to send the output of your arguments to the browser in a format

It has the format:

printf( string $format [, mixed $args [, mixed $... ]] ) : int;

To format a text you have to enter the following formatting characters preceded by the symbol %:

int $n =  43951789;
int $u = -43951789;
string $c = 65; // ASCII 65 is 'A'

printf("80%% of the runners"); # % for literals, will show '80% of the runners'
printf("%b", $n); # b for binary number, will show '10100111101010011010101101'
printf("%c", $c); # c for ASCII value of the number, will show 'A'
printf("%d", $n); # d for an integer, will show '43951789'
printf("%+d", $n); # +d for positive signed integer, will show '+43951789'
printf("%+d", $u); # +d for negative signed integer, will show '-43951789'
printf("%e", $n); # e for scientific notation of the integer, will show '4.39518e+7'
printf("%E", $n); # E for scientific notation of the integer, will show '4.39518E+7'
printf("%f", $n); # f for decimal number (considering regional settings), will show '43951789.000000'
printf("%F", $n); # F for decimal number (regardless of locale), will show '43951789.000000'
printf("%g", $n); # g same as e and f
printf("%G", $n); # G same as E and f
printf("%o", $n); # o for octal number, will show '247523255'
printf("%s", $n); # s like a string, will show '43951789'
printf("%E", $n); # E for scientific notation of the integer, will show '4.39518E+7'
printf("%u", $n); # u for unsigned positive integer, will show '43951789'
printf("%u", $n); # u for negative unsigned integer, will show '4251015507'
printf("%x", $u); # x for hexadecimal number, will show '29ea6ad'
printf("%X", $n); # X for uppercase hexadecimal number, will show '29EA6AD'

sprintf

The function sprintf serves to assign to its arguments, in a formatted way, the return variable

It has the same format as printf and supports the same formats

print_r

The function print_r serves to send the output of their arguments to the browser, displaying understandable information by people about the arguments

It's useful to be able to debug our code

It has the following format:

print_r ( mixed $expression [, bool $return = FALSE ] ) : mixed;

We can use it to see the full contents of an array

$a = array(
              'a' => 'apple',
              'b' => 'banana',
              'c' => array('x', 'y', 'z')
);
print_r($a);

/* Will show

Array
(
    [a] => apple
    [b] => banana
    [c] => Array
        (
            [0] => x
            [1] => y
            [2] => z
        )
)
*/

Functions for strings

Let's look at some of the most everyday functions for strings

If you need more, the full list can be found in the PHP manual

Uppercase and lowercase

The function strtoupper returns a copy of the string in uppercase

The function strtolower returns a lowercase copy of the string

$str = "I like to program in PHP";
echo strtoupper($str); #will show 'I LIKE TO PROGRAM IN PHP'
echo strtolower($str); #will show 'I like to program in php'

Extract String

The function substr serves to extract a substring from the string we pass it as an argument

It has the following format:

substr( string $string, int $start [, int $length ] ) : string;

Where $start is the starting position of the substring and $length the length that the substring will have

It can be useful when we need to extract a word from a text and we know in advance its position and length

$str = "En un lugar de la Mancha de cuyo nombre no quiero acordarme";
echo substr( $str, 18, 6); #will show 'Mancha'

Keep in mind that the position $start should start at 0

String length

The function strlen is used to count the length of the string

It has the following format:

strlen( string $string ) : int;

Resuming the string from the example above

$str = "En un lugar de la Mancha de cuyo nombre no quiero acordarme";
echo strlen($str); #will show 58

Position of a character in the String

The function strpos serves to find the position of a particular character in the string

It has the following format:

strpos( string $haystack, mixed $needle [, int $offset = 0 ] ) : mixed;

Where we find the needle ($needle, is the character to look for) in the haystack ($haystack, is the string we're looking for) and $offset, which is optional, is the starting number you start looking for

$mail = "pedro@proveedor.net";
echo strpos($mail, '@'); #will show 5

Keep in mind that the starting position starts at zero

Unless we specify the value of $offset

Find a text

The function strstr serves to find the first occurrence of a string

It has the following format:

strstr( string $haystack, mixed $needle [, bool $before_needle = FALSE ] ) : string;

It is very similar to substr, but it saves us having to use strpos intermediate

$mail = "pedro@proveedor.net";
echo substr( $mail, strpos($mail, '@') ); #will show 'proveedor.net'
echo strstr( $mail, '@' ); #will show 'proveedor.net', so they are equivalent, saves us some code

Array functions

Let's see some of the functions for arrays of daily use

If you need more, the full list can be found in the PHP manual

Count the number of items

The function count serves to count the total number of elements

It has the following format:

count( mixed $array_or_countable [, int $mode = COUNT_NORMAL ] ) : int;

Optionally we can use the argument $mode which by default uses the value COUNT_NORMAL (counts elements sequentially) and for multidimensional arrays COUNT_RECURSIVE (count the elements recursively, that is, it goes through all the multidimensional arrays and adds the total number of elements)

$a = array(
              'a' => 'apple',
              'b' => 'banana',
              'c' => array('x', 'y', 'z')
);

echo count($a); #will show 3 as it uses COUNT_NORMAL by default
echo count($a, COUNT_RECURSIVE); #will show 8, since it uses COUNT_RECURSIVE to count recursively
echo count($a, 1); #will show 8, since 1 is a value equivalent to COUNT_RECURSIVE

Find a value in the array

Check if a value exists

The function in_array is used to check if a value exists inside an array

It has the following format:

in_array( mixed $needle , array $haystack [, bool $strict = FALSE ] ) : bool;

Where we find the needle ($needle, is the character to look for) in the haystack ($haystack, is the string we're looking for) and $strict, which is optional, if is TRUE will check the types of $needle in $haystack

If $needle is a string, the comparison is made considering the case

$os = array("Mac", "NT", "Irix", "Linux");

#will show this option
if (in_array("Irix", $os) ) { 
    echo "There is Irix\n";
}
#but it will not show this option because it is case sensitive
if (in_array("mac", $os) ) { 
    echo "There is mac\n";
}

$a = array('1.10', 12.4, 1.13);

#will show this option for having strict checking active
if (in_array(1.13, $a, true) ) {
    echo "It was found 1.13\n";
}
#it will not show this option because having the strict check activated checks the types
if (in_array('12.4', $a, true) ) { 
    echo "It was found '12.4'\n";
}

$a = array(array('p', 'h'), array('p', 'r'), 'o');

#will show this option because it allows to search an array inside another array, which it considers as a string
if (in_array(array('p', 'h'), $a) ) {
    echo "It was found 'ph'\n";
}
#will not show this option because the array could not be found
if (in_array(array('f', 'i'), $a) ) {
    echo "It was found 'fi'\n";
}
#will show this option because the character could be found
if (in_array('o', $a) ) {
    echo "It was found 'o'\n";
}

Finding the first value

The function array_search serves to find the first value, if exists, within an array

It has the following format:

array_search( mixed $needle , array $haystack [, bool $strict = false ] ) : mixed;

Where we find the needle ($needle, is the character to look for) in the haystack ($haystack, is the string we're looking for) and $strict, which is optional, if is TRUE will check the types of $needle in $haystack

If $needle is a string, the comparison is made considering the case

You have to be careful with the values returned by this function because it can return the Boolean value FALSE, but you can also return a non Boolean value that evaluates to FALSE

In versions prior to PHP 4.2.0 returned NULL in the event of a failure, rather than FALSE

Starting with PHP 5.3.0 returns NULL if you pass invalid parameters

$array = array(0 => 'blue', 1 => 'red', 2 => 'green', 3 => 'yellow');

$key = array_search('green', $array);
echo($key); #will show 2
$key = array_search('red', $array);
echo($key); #will show 1

Date formats

PHP doesn't have a date type

To work with dates use strings formatted with UNIX style timestamps

These timestamps are an integer value measured in seconds that begin to count from January 1, 1970

Timestamps

To get the current timestamp we can use the function time which has the following format:

time( void ) : int;

The obtained value is easy to manipulate, as we can add multiples to it:

• 3600 to add hours
• 86400 to add days
• 604800 to add weeks

Formatted string

We can also use a format string to work with dates using the function date which has the following format:

date( string $format [, int $timestamp = time() ] ) : string;

Where $format is the string with the format we want to use, $timestamp, which is optional and by default takes the function time, is a UNIX timestamp

To format a date you have to enter the following formatting characters:

$date = date("m-d-Y"); #date in england format
echo $date; #will show today's date in England format 'mm-dd-YYYY'

Get a date from a string

Using a delimiter

From a string we can pick up a date using the function explode which has the following format:

explode( string $delimiter , string $string [, int $limit = PHP_INT_MAX ] ) : array;

Where $delimiter is the character used to delimit the values, $string the string that contains the date we want to manipulate and $limit an optional value whose default value is 1, which indicates the maximum number of return values

If $limit negative will return all values by removing the value of $limit from the end

And if it's 0 it's going to be treated like 1

And then we'll use the function mktime to create the UNIX type timestamp, which has the following format:

mktime([ int $hour = date("H") [, int $minute = date("i") [, int $second = date("s") [, int $month = date("n") [, int $day = date("j") [, int $year = date("Y") [, int $is_dst = -1 ]]]]]]] ) : int;

Where $hour is the hour, $minute is the minutes, $second, the seconds, $month is the month, $day is the day $year is the year and $is_dst is summer time or not (-1 if is not)

All parameters are optional, in case you don't enter any, the result of the function will be taken time

Starting with 5.1, when the call is made without arguments, it issues a warning of type E_STRICT: use function time() in its place

$date = "05-03-1978"; #date in england format

$parts = explode('-', $date); #extract the parts of the date using the separator '-'
$month = $parts[0]; #we save the month of the date
$day = $parts[1]; #we save the day of the date
$year = $parts[2]; #we save the year of the date

$timestamp = mktime(12, 0, 0, $month, $day, $year); #save the date in UNIX format

Converting a string to date format

From a string we can pick up a date using the function strtotime which has the following format:

strtotime( string $time [, int $now = time() ] ) : int;

Where $time is the string from which we want to get the date, $now, which is optional and by default takes the function time, is a UNIX timestamp

Starting with PHP 5.0.0, microseconds started to be allowed, but were ignored

In PHP 5 up to 5.0.2, now and other relative moments are wrongly computed like today's midnight

This differs between versions where it is computed as the current moment

As of PHP 5.1.0 it shows the error E_STRICT and E_NOTICE when errors occur with time zones

And returns FALSE if fails, instead of -1

In PHP 5 through 5.2.7, requests for an occurrence of a given day of the week in a month where that day of the week was the first day of the month, incorrectly added a week to the returned timestamp

This was fixed in 5.2.7 and is maintained in later versions

Before PHP 5.3.0, 24:00 was not a valid format and returned FALSE

The relative time formats that were supplied to the parameter $time such as this week, previous week, last week, and next week were interpreted as a period of 7 days relative to the current date and time, rather than a period of the week from Monday to Sunday

$date = "05-03-1978"; #date in england format

$timestamp = strtotime($date); #save the date in UNIX format