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