Unit-3 Arrays in PHP: Introduction- What is Array?

Creating Arrays, Accessing

Array elements, Types of Arrays: Indexed v/s Associative arrays,
Multidimensional arrays - Creating Array, Accessing Array, Manipulating
Arrays, Displaying array, Using Array Functions, Including and Requiring
Files- use of Include() and Require(),Implicit and Explicit Casting in PHP.
Strings in PHP: What is String? Creating and Declaring String, String
Functions, Application program on sending Email.
Form Handling: Creating HTML Form, Handling HTML Form data in PHP.

An array is a data structure that stores one or more data values having some relation among them, in a
single variable. For example, if you want to store the marks of 10 students in a class, then instead of
defining 10 different variables, it’s easy to define an array of 10 length.

Arrays in PHP behave a little differently than the arrays in C, as PHP is a dynamically typed language as
against C which is a statically type language.

​ An array in PHP is an ordered map that associates values to keys.

​ A PHP array can be used to implement different data structures such as a stack, queue, list
(vector), hash table, dictionary, etc.
​ The value part of an array element can be other arrays. This fact can be used to implement tree
data structure and multidimensional arrays.

There are two ways to declare an array in PHP. One is to use the built-in array() function, and the other is
to use a shorter syntax where the array elements are put inside square brackets.

The array() Function

The built-in array() function uses the parameters given to it and returns an object of array type. One or
more comma-separated parameters are the elements in the array.

array(mixed …$values): array

Each value in the parenthesis may be either a singular value (it may be a number, string, any object or
even another array), or a key-value pair. The association between the key and its value is denoted by the
"=>" symbol.

Examples
$arr1 = array (10, ”asd”, 1.55, true);
$arr2 = array (“one”=>1, “two”=>2, “three”=>3);
$arr3 = array (
array(10, 20, 30),
array(“ten”, “twenty”, “thirty”),
array(“physics”=>70, “chemistry”=>80, “maths”=>60)
);

Using Square Brackets [ ]

Instead of the array() function, the comma-separated array elements may also be put inside the square
brackets to declare an array object. In this case too, the elements may be singular values or a string or
another array.

$arr1 = [10, "asd", 1.55, true];

$arr2 = ["one"=>1, "two"=>2, "three"=>3];

$arr3 = [ [10, 20, 30],

["Ten", "Twenty", "Thirty"],

["physics"=>70, "chemistry"=>80, "maths"=>90] ];

Types of Arrays in PHP

There are three different kind of arrays and each array value is accessed using an ID which is called the
array index.

​ Indexed Array − An array which is a collection of values only is called an indexed array. Each
value is identified by a positional index staring from "0". Values are stored and accessed in linear
fashion.
​ Associative Array − If the array is a collection of key-value pairs, it is called as an associative
array. The key component of the pair can be a number or a string, whereas the value part can be
of any type. Associative arrays store the element values in association with key values rather than
in a strict linear index order.
​ Multi Dimensional Array − If each value in either an indexed array or an associative array is an
array itself, it is called a multi dimensional array. Values are accessed using multiple indices

NOTE − Built-in array functions is given in function reference PHP Array Functions

It may be noted that PHP internally considers any of the above types as an associative array itself. In case
of an indexed array, where each value has index, the index itself is its key. The var_dump() function
reveals this fact.

Example
In this example, arr1 is an indexed array. However, var_dump()which displays the structured information
of any object, shows that each value is having its index as its key.

<?php
$arr1 = [10, "asd", 1.55, true];
 var_dump($arr1);
?>

It will produce the following output −

array(4) {
[0]=>
int(10)
[1]=>
string(3) "asd"
[2]=>
float(1.55)
[3]=>
bool(true)
}

Example
The same principle applies to a multi-dimensional index array, where each value in an array is another
array.

<?php
$arr1 = [
[10, 20, 30],
["Ten", "Twenty", "Thirty"],
[1.1, 2.2, 3.3]
];

var_dump($arr1);
?>

It will produce the following output −

array(3) {
[0]=>
array(3) {
[0]=>
int(10)
[1]=>
int(20)
[2]=>
int(30)
}
[1]=>
array(3) {
[0]=>
 string(3) "Ten"
[1]=>
string(6) "Twenty"
[2]=>
string(6) "Thirty"
}
[2]=>
array(3) {
[0]=>
float(1.1)
[1]=>
float(2.2)
[2]=>
float(3.3)
}
}

Accessing the Array Elements

To access any element from a given array, you can use the array[key] syntax.

Example
For an indexed array, put the index inside the square bracket, as the index itself is anyway the key.

<?php
$arr1 = [10, 20, 30];
$arr2 = array("one"=>1, "two"=>2, "three"=>3);

var_dump($arr1[1]);
var_dump($arr2["two"]);
?>

It will produce the following output −

int(20)
int(2)
Numerically Indexed Arrays
Let’s assume that you’ve been tasked with creating a simple website for a local officesupply company and
you’re currently working on the section devoted to paper. One way to manage the various items of stock
in this category would be to place them in a numeric array. You can see the simplest way of doing so in
Example 6-1.

output
Associative Arrays
Keeping track of array elements by index works just fine, but can require extra work in terms of
remembering which number refers to which product. It can also make code hard for other programmers to
follow.
This is where associative arrays come into their own. Using them, you can reference the items in an array
by name rather than by number. Example 6-4 expands on the previous code by giving each element in the
array an identifying name and a longer, more explanatory string value.

In place of a number (which doesn’t convey any useful information, aside from the position of the item in
the array), each item now has a unique name that you can use to reference it elsewhere, as with the echo
statement—which simply prints out Laser Printer. The names (copier, inkjet, and so on) are called indexes
or keys, and the items assigned to them (such as Laser Printer) are called values.

This very powerful feature of PHP is often used when you are extracting information from XML and
HTML. For example, an HTML parser such as those used by a search engine could place all the elements
of a web page into an associative array whose names reflect the page’s structure:
$html['title'] = "My web page";
$html['body'] = "... body of web page ...";
The program would also probably break down all the links found within a page into another array, and all
the headings and subheadings into another. When you use associative rather than numeric arrays, the code
to refer to all of these items is easy to write and debug.

Assignment Using the array Keyword

So far, you’ve seen how to assign values to arrays by just adding new items one at a time. Whether you
specify keys, specify numeric identifiers, or let PHP assign numeric identifiers implicitly, this is a
long-winded approach. A more compact and faster assignment method uses the array keyword. Example
6-5 shows both a numeric and an associative array assigned using this method.

The first half of this snippet assigns the old, shortened product descriptions to the array $p1. There are
four items, so they will occupy slots 0 through 3. Therefore, the echo statement prints out the following:
p1 element: Laser
The second half assigns associative identifiers and accompanying longer product descriptions to the array
$p2 using the format index => value. The use of => is similar to the regular = assignment operator, except
that you are assigning a value to an index and not to a variable. The index is then inextricably linked with
that value, unless it is assigned a new value. The echo command therefore prints out this:
p2 element: Inkjet Printer
You can verify that $p1 and $p2 are different types of array, because both of the fol‐ lowing commands,
when appended to the code, will cause an Undefined index or Undefined offset error, as the array
identifier for each is incorrect:
echo $p1['inkjet']; // Undefined index
echo $p2[3]; // Undefined offset

The foreach...as Loop

The creators of PHP have gone to great lengths to make the language easy to use. So, not content with the
loop structures already provided, they added another one espe‐cially for arrays: the foreach...as loop.
Using it, you can step through all the items in an array, one at a time, and do something with them.
The process starts with the first item and ends with the last one, so you don’t even have to know how
many items there are in an array. Example 6-6 shows how fore ach...as can be used to rewrite Example
6-3.
When PHP encounters a foreach statement, it takes the first item of the array and places it in the variable
following the as keyword; and each time control flow returns to the foreach, the next array element is
placed in the as keyword. In this case, the variable $item is set to each of the four values in turn in the
array $paper. Once all values have been used, execution of the loop ends. The output from this code is
exactly the same as Example 6-3.
Now let’s see how foreach works with an associative array by taking a look at Example 6-7, which is a
rewrite of the second half of Example 6-5.

Remember that associative arrays do not require numeric indexes, so the variable $j is not used in this
example. Instead, each item of the array $paper is fed into the key/ value pair of variables $item and
$description, from which they are printed out. The displayed result of this code is as follows:
copier: Copier & Multipurpose
inkjet: Inkjet Printer
laser: Laser Printer
photo: Photographic Paper

Multidimensional Arrays
A simple design feature in PHP’s array syntax makes it possible to create arrays of more than one
dimension. In fact, they can be as many dimensions as you like (although it’s a rare application that goes
further than three).
That feature is the ability to include an entire array as a part of another one, and to be able to keep doing
so, just like the old rhyme: “Big fleas have little fleas upon their backs to bite ’em. Little fleas have lesser
fleas, add flea, ad infinitum.”
Let’s look at how this works by taking the associative array in the previous example and extending it; see
Example 6-10.
Output

Using Array Functions

You’ve already seen the list and each functions, but PHP comes with numerous other functions for
handling arrays. The full list is at http://tinyurl.com/arraysinphp. However, some of these functions are so
fundamental that it’s worth taking the time to look at them here.

is_array
Arrays and variables share the same namespace. This means that you cannot have a string variable called
$fred and an array also called $fred. If you’re in doubt and your code needs to check whether a variable is
an array, you can use the is_array function, like this:
echo (is_array($fred)) ? "Is an array" : "Is not an array";
Note that if $fred has not yet been assigned a value, an Undefined variable message will be generated.

count

Although the each function and foreach...as loop structure are excellent ways to walk through an array’s
contents, sometimes you need to know exactly how many ele‐ ments there are in your array, particularly
if you will be referencing them directly. To count all the elements in the top level of an array, use a
command such as this:

echo count($fred);

Should you wish to know how many elements there are altogether in a multidimen‐sional array, you can
use a statement such as the following:

echo count($fred, 1);

The second parameter is optional and sets the mode to use. It should be either a 0 to limit counting to only
the top level, or 1 to force recursive counting of all subarray elements too

sort
Sorting is so common that PHP provides a built-in function. In its simplest form, you would use it like
this:

sort($fred);

Unlike some other functions, sort will act directly on the supplied array rather than returning a new array
of sorted elements. Instead, it returns TRUE on success and FALSE on error and also supports a few
flags, but the main two that you might wish to use force sorting to be made either numerically or as
strings, like this:

sort($fred, SORT_NUMERIC);
sort($fred, SORT_STRING);

You can also sort an array in reverse order using the rsort function, like this:

rsort($fred, SORT_NUMERIC);
rsort($fred, SORT_STRING);

shuffle
There may be times when you need the elements of an array to be put in random order, such as when
you’re creating a game of playing cards:

shuffle($cards);

Like sort, shuffle acts directly on the supplied array and returns TRUE on success or FALSE on error.

explode
This is a very useful function with which you can take a string containing several items separated by a
single character (or string of characters) and then place each of these items into an array. One handy
example is to split up a sentence into an array containing all its words, as in Example 6-12.

This example prints out the following (on a single line when viewed in a browser):
Array ( [0] => This
[1] => is
[2] => a
[3] => sentence
[4] => with
[5] => seven
[6] => words )

The first parameter, the delimiter, need not be a space or even a single character. Example 6-13 shows a
slight variation.

reset

When the foreach...as construct or the each function walks through an array, it keeps an internal PHP
pointer that makes a note of which element of the array it should return next. If your code ever needs to
return to the start of an array, you can issue reset, which also returns the value of that element. Examples
of how to use this function are as follows:

reset($fred); // Throw away return value

$item = reset($fred); // Keep first element of the array in $item

end

As with reset, you can move PHP’s internal array pointer to the final element in an array using the end
function, which also returns the value of the element, and can be used as in these examples:
end($fred);
$item = end($fred);
This chapter concludes your basic introduction to PHP, and you should now be able to write quite
complex programs using the skills you have learned. In the next chap‐ ter, we’ll look at using PHP for
common, practical tasks.

Compact
At times you may want to use compact, the inverse of extract, to create an array from variables and their
values. Example 6-14 shows how you might use this func‐tion.

Extract
Sometimes it can be convenient to turn the key/value pairs from an array into PHP variables. One such
time might be when you are processing the $_GET or $_POST vari‐ ables as sent to a PHP script by a
form.
When a form is submitted over the Web, the web server unpacks the variables into a global array for the
PHP script. If the variables were sent using the Get method, they will be placed in an associative array
called $_GET; if they were sent using Post, they will be placed in an associative array called $_POST.

You could, of course, walk through such associative arrays in the manner shown in the examples so far.
However, sometimes you just want to store the values sent into variables for later use. In this case, you
can have PHP do the job automatically:

extract($_GET);

So, if the query string parameter q is sent to a PHP script along with the associated value Hi there, a new
variable called $q will be created and assigned that value.

Be careful with this approach, though, because if any extracted variables conflict with ones that you have
already defined, your existing values will be overwritten. To avoid this possibility, you can use one of the
many additional parameters available to this function, like this:

extract($_GET, EXTR_PREFIX_ALL, 'fromget');

In this case, all the new variables will begin with the given prefix string followed by an underscore, so $q
will become $fromget_q. I strongly recommend that you use this version of the function when handling
the $_GET and $_POST arrays, or any other array whose keys could be controlled by the user, because
malicious users could sub‐ mit keys chosen deliberately to overwrite commonly used variable names and
com‐promise your website.

Including and Requiring Files- use of Include() and Require()

PHP Include helps to include files in various programs and saves the effort of writing code
multiple times. If we want to change a code, rather than editing it in all of the files, we can
simply edit the source file, and all of the codes will be updated automatically. There are two
features that assist us in incorporating files in PHP.

1. include
2. require

Include Statement

The ‘include’ or ‘require’ statement can be used to insert the content of one PHP file into another
PHP file (before the server executes it). Except in the case of failure, the ‘include’ and ‘require
statements’ are identical:

● Include in PHP will only generate an alert (E_WARNING), and the script will
proceed.
● Require will produce a fatal error (E_COMPILE_ERROR) and interrupt the script.

If the include statement appears, execution should continue and show users the output even if the
include file is missing. Otherwise, always use the required declaration to include the main file in
the flow of execution while coding Framework, CMS, or a complex PHP program. This will help
prevent the application's protection and reputation from being jeopardized if one key file is
corrupted.

The include() function copies all of the text from a given file into the file that uses the include
function. It produces an alert if there is a problem loading a file; however, the script will still run.

Advantages of Include() in PHP

 ● Code Reusability: We may reuse HTML code or PHP scripts in several PHP scripts
with the aid of the ‘include’ and ‘require’ build.
● Easy to Edit: If you want to alter anything on a website, you can modify the source
file used with all of the web pages rather than editing each file individually.

PHP Include

Include is a keyword to include one PHP file into another PHP file. While including the content
of the included file will be displayed in the main file. The below example code will demonstrate
the concept of PHP include.

Syntax:

include 'file_name';

or

require 'file_name';

Code:

Page1.php

<?php

echo "<p>welcome to my webpage</p>";

?>

Main.php

<html>

<body>

<h1>Welcome to my home page!</h1>

<p>Some text.</p>

<p>Some more text.</p>

<?php include 'Page1.php';?>

</body>

</html>

Explanation:

In the above code, there are two files, that is, Page1.php and Main.php. In the Main.php file, the
Page1.php has been included with the help of line <?php include ‘Page1.php’;?>

Output:

PHP Require

The PHP require function is similar to the include function, which is used to include files. The
only difference is that if the file is not found, it prevents the script from running, while include
does not.

The require() function copies all of the text from a given file into the file that uses the include
function. The require() function produces a fatal error and stops the script's execution if there is a
problem loading a file. So, apart from how they treat error conditions, require() and include() are
identical. Since scripts do not execute if files are missing or misnamed, the require() function is
recommended over include().

Syntax:

require 'file_name';

Or

require ('file_name');

Code:

Menu1.html:

<html>

<body>

<ahref="http://www.google.com">Google</a> |

<ahref="http://www.yahoo.com">Yahoo</a> |

<ahref="http://www.maps.com">Maps</a> |

<ahref="http://www.tutorial.com">Tutorial</a>

</body>

</html>

Main.html:

<html>

<body>
<h1>welcome</h1>

<?php require("menu1.html"); ?>

</body>

</html>

Output:

include() Vs require()

In most cases, the require() statement works in the same way as the include() statement. The only
difference is that the include() statement generates a PHP alert but allows script execution to
proceed if the file to be included cannot be found. At the same time, the require() statement
generates a fatal error and terminates the script.

Implicit and Explicit Casting in PHP

he term "Type Casting" refers to conversion of one type of data to another. Since PHP is a
weakly typed language, the parser coerces certain data types into others while performing certain
operations. For example, a string having digits is converted to integer if it is one of the operands
involved in the addition operation.

Implicit Type Casting

Here is an example of coercive or implicit type casting −

<?php
$a = 10;
$b = '20';
$c = $a+$b;
 echo "c = " . $c;
?>

In this case, $b is a string variable, cast into an integer to enable addition. It will produce the
following output −

c = 30

Let's take another example. Here, an integer variable $a is converted to a string so that it is
concatenated with a string variable.

<?php
$a = 10;
$b = '20';
$c = $a.$b;
echo "c = " . $c;
?>

It will produce the following output −

c = 1020

In addition to such coercive type conversion, there are other ways to explicitly cast one type of
data to other. You can use PHP’s type casting operators or type casting functions for this purpose.

Type Casting Operators

To convert an expression of one type to another, you need to put the data type of the latter in
parenthesis before the expression.

$var = (type)expr;

Some of the type casting operators in PHP are −

​ (int) or (integer) casts to an integer

​ (bool) or (boolean) casts to a boolean
​ (float) or (double) or (real) casts to a float
​ (string) casts to a string
​ (array) casts to an array
 ​ (object) casts to an object

Casting to Integer
You can easily convert a float value to an integer. Take a look at the following example −

<?php
$a = 9.99;
$b = (int)$a;
var_dump($b);
?>

It will produce the following output −

int(9)

Note that the float value is not rounded to the nearest integer; instead it just returns the integer
part.

String to Integer Conversion

The (int) operator also coverts a string to integer. The conversion is straightforward if the string
consists of just digits.

<?php
$a = "99";
$b = (int)$a;
var_dump($b);
?>

Here, you will get the following output −

int(99)

Application program on sending Email

The provision of sending emails is one the commonly required features of a typical PHP powered web
application. You would like to send emails containing notifications, updates and other communications to
your registered users, through your PHP application itself, instead of a different mail service. You can add
this capability to your PHP application by adopting the techniques described in this chapter.

PHP has a built-in mail() function to send an email. However, you need configure properly the "php.ini"
settings to be able to do so. First, you must know the SMTP domain of the web hosting platform that you
are using. For example, if your website is being hosted on GoDaddy hosting service, the SMTP domain is
"smtp.secureserver.net", which you should use in the configuration.

If you use Windows based hosting of GoDaddy, you should ensure that two directives are enabled in
php.ini file. The first is called SMTP that defines your email server address. The second is called
sendmail_from which defines your own email address.

The configuration for Windows should look something like this −

[mail function]
; For Win32 only.
SMTP = smtp.secureserver.net

; For win32 only

sendmail_from = webmaster@tutorialspoint.com

Linux users simply need to let PHP know the location of their sendmail application. The path and any
desired switches should be specified to the sendmail_path directive.

The configuration for Linux should look something like this −

[mail function]
; For Win32 only.
SMTP =

; For win32 only

sendmail_from =

; For Unix only

sendmail_path = /usr/sbin/sendmail -t -i

mail() function in PHP requires three mandatory arguments that specify the recipient's email address,
the subject of the message and the actual message additionally there are other two optional parameters.

Syntax:

mail( to, subject, message, headers, parameters );

Parameters
​ to − Required. Specifies the receiver / receivers of the email
​ subject − Required. Specifies the subject of the email. This parameter cannot contain any newline
characters
​ message − Required. Defines the message to be sent. Each line should be separated with a LF
(\n). Lines should not exceed 70 characters
​ headers − Optional. Specifies additional headers, like From, Cc, and Bcc. The additional headers
 should be separated with a CRLF (\r\n)
​ parameters − Optional. Specifies an additional parameter to the send mail program

Multiple recipients can be specified as the first argument to the mail() function in a comma separated
list.

Sending HTML Email

When you send a text message using PHP then all the content will be treated as simple text. Even if you
will include HTML tags in a text message, it will be displayed as simple text and HTML tags will not be
formatted according to HTML syntax. But PHP provides option to send an HTML message as actual
HTML message.

While sending an email message you can specify a Mime version, content type and character set to send
an HTML email.

Example
The following example shows how to send an HTML email message to "xyz@somedomain.com" copying
it to "afgh@somedomain.com". You can code this program in such a way that it should receive all content
from the user and then it should send an email.

It should receive all content from the user and then it should send an email.

<?php
$to = "xyz@somedomain.com";
$subject = "This is subject";

$message = "<b>This is HTML message.</b>";

$message .= "<h1>This is headline.</h1>";

$header = "From:abc@somedomain.com \r\n";

$header .= "Cc:afgh@somedomain.com \r\n";
$header .= "MIME-Version: 1.0\r\n";
$header .= "Content-type: text/html\r\n";

$retval = mail ($to,$subject,$message,$header);

if( $retval == true ) {

echo "Message sent successfully...";
}else {
echo "Message could not be sent...";
}
?>

Form Handling: Creating HTML Form, Handling HTML Form data in

 PHP.
PHP Global Variables - Superglobals
Some predefined variables in PHP are "superglobals", which means that they are always accessible,
regardless of scope - and you can access them from any function, class or file without having to do
anything special.

The PHP superglobal variables are:

● $GLOBALS
● $_SERVER
● $_REQUEST
● $_POST
● $_GET
● $_FILES
● $_ENV
● $_COOKIE
● $_SESSION

The PHP superglobals $_GET and $_POST are used to collect form-data.
<html>
<body>

<form action="welcome.php" method="POST">

Name: <input type="text" name="name"><br>
E-mail: <input type="text" name="email"><br>
<input type="submit">
</form>

</body>

</html>

When the user fills out the form above and clicks the submit button, the form data is sent for
processing to a PHP file named "welcome.php". The form data is sent with the HTTP POST method.

To display the submitted data you could simply echo all the variables.

The "welcome.php" looks like this:

<html>
<body>

Welcome <?php echo $_POST["name"]; ?><br>

Your email address is: <?php echo $_POST["email"]; ?>

</body>

</html>

The output could be something like this:

Welcome John
Your email address is john.doe@example.com

The same result could also be achieved using the HTTP GET method:

Same example, but the method is set to GET instead of POST:

<html>
<body>

<form action="welcome_get.php" method="GET">

Name: <input type="text" name="name"><br>
E-mail: <input type="text" name="email"><br>
<input type="submit">
</form>

</body>

</html>

and "welcome_get.php" looks like this:

<html>
<body>

Welcome <?php echo $_GET["name"]; ?><br>

Your email address is: <?php echo $_GET["email"]; ?>

</body>
</html>

The code above is quite simple, and it does not include any validation.

You need to validate form data to protect your script from malicious code.

GET vs. POST

Both GET and POST create an array (e.g. array( key1 => value1, key2 => value2, key3 => value3,
...)). This array holds key/value pairs, where keys are the names of the form controls and values are
the input data from the user.

Both GET and POST are treated as $_GET and $_POST. These are superglobals, which means that
they are always accessible, regardless of scope - and you can access them from any function, class or
file without having to do anything special.

$_GET is an array of variables passed to the current script via the URL parameters.

$_POST is an array of variables passed to the current script via the HTTP POST method.

When to use GET?

Information sent from a form with the GET method is visible to everyone (all variable names and
values are displayed in the URL). GET also has limits on the amount of information to send. The
limitation is about 2000 characters. However, because the variables are displayed in the URL, it is
possible to bookmark the page. This can be useful in some cases.

GET may be used for sending non-sensitive data.

Note: GET should NEVER be used for sending passwords or other sensitive information!

When to use POST?

Information sent from a form with the POST method is invisible to others (all names/values are
embedded within the body of the HTTP request) and has no limits on the amount of information to
send.

Moreover POST supports advanced functionality such as support for multi-part binary input while
uploading files to server.
 However, because the variables are not displayed in the URL, it is not possible to bookmark the page.

NOTE:Developers prefer POST for sending form data.