Languages PHP Learning PHP: Storing Basic Information

Learning PHP: Storing Basic Information

Now that you have a working
PHP development environment
, it’s time to start learning some of the
actual language.

In the next few articles, we will be taking a look at the fundamentals
of the PHP language in preparation for creating your first script: a full-fledged
form processor. This time, we will be focusing on the basic structure
of PHP and taking a look at how it handles variables and data types.

Basic Syntax

Starting and Ending PHP Code Blocks
Take a look at the following simple PHP script:

<html>
<head>
<title>Testing PHP</title></head>
<body>
<?php print “hello there!”; ?>
</body>
</html>

In this example, PHP is embedded directly into an HTML document. Because
PHP and HTML can be mixed like this, every block of PHP code must be surrounded
by Start and End elements. These elements allow PHP to see which sections
of the page need to be parsed, and which can be ignored.

PHP recognizes four different versions of these sets:

1. <?php print “hello there!”;?>

2. <script language="php"> print “hello there!”;</script>

3. <? print “hello there!”; ?>

4. <% print “hello there!”; %>

The first two versions are supported by PHP by default; however, you
will rarely see the second used in any scripts. Shorter and easier to
remember, the first is the preferred usage. The third method is also frequently
used, but requires the “short_tags” option to be enabled in the PHP configuration
file. Although many web hosts do enable this option, keep in mind that
any scripts written using them may not work in certain situations. The
final method will look familiar to ASP developers. Known as ASP Style
tags, this is the least-used method and requires the “asp_style” option
to be enabled.

You have also probably already noticed that most lines of PHP code end
with a semi-colon. The semi-colon tells PHP when one statement is finished,
so it can go on to evaluating the next. A closing PHP tag right after
a statement has the same effect as a semi-colon:

<?php print “hello
there!” ?>

Comments
Just like in HTML, PHP allows you to comment out lines of text. There
are three ways to do this:

1. // This comments out a single line.

2. print “Hi there”; #this is also a single line comment.

3. /* This is used to comment
   out multiple lines */

Commenting your script can become vital, especially when working on larger
projects and its a habit that you should develop now. Including information
about which blocks of code perform which functions can be a life saver
if you return to a project after you have forgotten the details. If you
are working on a collaborative project, having a well-documented script
also makes it easy for other people to understand script logic and your
thought process.

PHP Building Blocks – Variables

If you have ever sat through a basic algebra class, you are probably already
more familiar than you realize with what variables do and how to work
with them.

Just as in math, variables in PHP are containers for bits and pieces of
data. They are denoted by a dollar sign, and can be named anything beginning
with a letter or underscore. Variable names can only contain letters,
numbers, or underscores and are always case sensitive.

As a quick sample, try running the following script on your server:

<html>
<body>

<?php
$var = “Hello there!”;
print $var;
?>

</body>
</html>

When you run it, you will see that it prints “Hello there!”
in your browser. Looking at the script, this makes sense: We begin by
creating a variable called $var and assign a string value of “Hello
there!” to it using the assignment operator (=). In the next line
of the script, we use a print command to output the value of $var.

If you are making the leap to PHP after working with another programming
language such as C, keep in mind that you do not need to declare your
variables before using them. A variable in PHP is created automatically
as soon as a value is assigned to it.

Now, take a look at the following script:

<html>
<body>

<?php
$var1 = 1;
$var2 = 4;
$sum = $var1 + $var2;

print “The result of $var1 + $var2 is $sum”;
?>

</body>
</html>

Run this script and take a look at the output. Just like in the previous
script, we created a variable. This time, we assigned a number to it instead
of some words, and created a second variable as well. In the 3rd
line, we added them together and assigned the sum to a variable called
$sum. Because $var1 and $var2 are numbers, any mathematical operation
can be applied to them, not just addition.

If you compare the two scripts, you will notice some slight differences
in how the variables were assigned and in the way data was outputted to
the browser. In the first script, the sentence assigned to the variable
was surrounded by quotation marks, and the variable outputted to the browser
was not. In the second, the exact reverse was the case.

Wondering why? Part of the answer lies with how PHP handles different
types of data.

PHP Building Blocks – Data Types

In PHP, every piece of data assigned to a variable is of one type or another.
The types that PHP currently support are: Strings, Arrays, Integers, Floating
Point Numbers, and Objects. For now, we’ll just take a look at Strings
and Integers, since both were used in the last two test scripts.

Strings
In PHP, a String is simply defined as a series of characters. They
can contain letters, ASCII characters, numbers, and even other variables.

When you assign a string to a variable or print it out to the browser,
you must demark where that string begins and ends. Two of the most common
ways of doing this are:

1. Single Quotes:
$var = ‘Hi there’;
print ‘Hi there’;

2. Double Quotes:
$var = “Hi there”;
print “Hi there”;

Though the two methods resemble each other closely, there are slight differences
in how they work. Try the following script:

<?php

$var = “This is a”;
print “$var test<br>”;
print ‘$var test’;

?>

Based on what you know of PHP, you might expect that both lines would
return “This is a test”. But take a look at the output:

This is a test
$var test

The major difference between double and single quotes is that contents
within single quotes are taken literally. If you have any variables within
them, they will not be translated into their values. This, however, will
work:

print $var . ‘ test’;

Since only strings need to be surrounded by quotes to be printed out,
this is perfectly valid. Called the concatenation operator, the period
works to append the right argument to the left, "gluing" them
together and printing them both out.

In many instances, you may wish to print or assign a string which contains
quotation marks. When you do, if the quotation mark is the same as the
ones you are using to demark the string, it must be escaped by using a
backslash. Escaping a character lets PHP know that you wanted it to be
interpreted literally. For example:

$var = “I’m a string”; — this is acceptable
because you are using a single quotation mark within double ones.
No escape character is needed here.

$var = ‘I’m
a string’; — This would give an error because PHP sees the second
single quotation mark as the end of the string, and the rest of
the text following it as garbage that it can’t understand.

$var = “I’m a string”; — This is the
correct way to escape a quotation mark.

Integers
Just as in math, whole numbers, negative or positive, and zero are considered
Integers. When you assign an integer to a variable, you do not
use quotation marks:

$var = 1; — this is an integer

$var = 0; — this is an integer

$var = “1”; — this is a string.


Type Juggling
One of things that make PHP so easy to use is its flexibility in how
it handles types.

When you create a new variable, PHP automatically determines what type
that variable is based on the data that you assigned to it. So, if you
assign a string to a variable, the variable becomes a string. Likewise,
assigning a function or an integer to a variable would cause the variable
to become the associated type.

After creation, a variable can also change types on the fly based on
what context it is used in:

$var = “1”; — $var is a string.
$var= $var + 1; — $var is increased by one, and becomes an integer.

In the above example, $var was converted from a string to an integer because
a numerical operation was performed on it. This is known as String
Conversion
.

If a string begins with numbers and also includes text, PHP will use
the beginning set of numbers and completely ignore the rest of the text.
If the string had not begun with a number, then PHP would have assumed
$var was equal to 0 for the purposes of performing the operation. The
end value of $var would have been one, instead of two.

If you want to see how this works in action, try running following script:

<?php
$var = “1”;
$var=$var + 1;
print “$var<br>”;

$var = “123 Texttexttext”;
$var = $var +1;

print "$var<br>";

$var = “Hi there!”;
$var = $var +1;
print $var;
?>

In the above script, the string variables were changed to integer variables
because an integer value was added, but that is not always the way it
works:

$var = "33";
$newvariable = $var + 1;

$newvariable is an integer, but $var remains a string because the result
of the operation was assigned to a new variable. Even though the original
variable remains the same type, this is still considered String Conversion.

In a process known as Type Casting, you can force PHP to treat
a variable as one type or another when you create it:

$var = (int) "4"; — $var is a int even though
its surrounded by quotes, because you have defined it as such.

You can also specifically change the type of it is after having created
it by using the settype() function:

$var = (int) "4";
$var = settype($var, float); — $var becomes a float.

Keep in mind that while there are some occasions where you may need to
manually set or change the type of a variable, PHP is very accurate in
dealing with them in the proper context and typically you should let it
do the work.

If you are feeling a little confused, don’t worry. Generally, much of
this takes place behind the scenes. As you work more with PHP, you will
gain a better feel for how types come into play and how to work with them.

By now, you should have a good feel for the basic syntax of PHP, and an
understanding of how to work with variables. In this article, you have run
into a few instances where various operators have been used: the assignment
operator to give a variable a value, the addition operator to add two values
together, and the concatenation operator. Next time, we will be taking an
in-depth look at more of the operators commonly used in PHP. Stay Tuned!


Things to Remember:

  • Every PHP code block needs to begin with an opening PHP element
    and end with one.

  • Statements in PHP must end with a semi-colon. This defines the
    end of an instruction.

  • A variable is created by assigning a value to it. Variables
    are denoted with $, must begin with a letter or an underscore,
    and can contain any combination of letters, numbers or underscores.

  • PHP has 5 different Types: Strings, Arrays, Integers, Floating
    Point Numbers, and Objects.
  • Strings begin and end with either double or single quotes. Only
    strings need to be surrounded by quotes to assign them to variables
    or print them out.
  • When using quotes to define a string, quotes of the same type
    within the string must be escaped with .

  • PHP plays fast and loose with types. You do not need to define
    what type a variable is when you create it and the type of a variable
    can also change after the variable has been created depending
    on the context it is used in.


Liz Fulghum currently lives in Annapolis, MD where she works as a web designer for a custom shirt retailer. Liz was convinced to try PHP as an alternative to Perl; she has been a fan ever since and frequently works as a freelance developer.

# # #

Latest Posts

Related Stories