PHP BASICS
Prepared By: Mary Grace G. Ventura
PHP Scripting Block
Always starts with <?php and ends with ?>
<html>
<head><title>Hello World Script</title>
</head>
<body>
<?php
echo “<p>Hello World!</p>”
?>
</body>
</html>
Using Simple Statements
Simple statements are an instruction to PHP to do
one simple action.
There are two basic statements to output text with
PHP: echo and print.
Note: The file must have a .php extension. If the file
has a .html extension, the PHP code will not be
executed.
echo command
The simplest use of echo is to print a string as
argument, for example:
echo “This will print in the
user’s browser window.”;
Or equivalently
echo(“This will print in the
user’s browser window.”);
Echo Statement
You can also give multiple arguments to the
unparenthesized version of echo, separated by
commas, as in:
echo “This will print in the “,
“user’s browser window.”;
PHP Simple Statements
Follow These Rules:
PHP statements end with a semicolon or the PHP
ending tag.
PHP doesn’t notice white space or the end of lines. It
continues reading a statement until it encounters a
semicolon or the PHP closing tag, no matter how many
lines the statement spans.
PHP statements may be written in either upper- or
lowercase.
In an echo statement, Echo, echo, ECHO, and eCHo are all
the same to PHP.
Comments in PHP
In PHP, we use // to make a single-line comment
or /* and */ to make a large comment block.
<?php
//This is a line comment
# or this one
/*
This is
a comment
block
*/
?>
Variables
Are used for storing values such as numbers and strings so
that it can be used several times in the script. “Symbolic
Representation of a value”.
Variables are identified and defined by prefixing their name
with a dollar sign
Example: $variable1, $variable2
Variable names must start with a letter or underscore
character (“_”)
Variable names may contain letters, numbers, underscores, or
dashes. There should be no spaces
Variable names are CaSE- SeNSiTiVE
$thisVar
$ThisvAr
Example of Variable Names
$item
$Item
$myVariable (camel case)
$this_variable
$this-variable
$product3
$_book
$__bookPage
Variables
PHP variables are not declared explicitly instead
they are declared automatically the first time they
are used.
It’s a loosely typed of language so we do not
specify the data type of the variable.
PHP automatically converts the variable to the
correct data type such as string, integer or floating
point numbers.
Illustration of a Variable Declaration
Example of Variable Variables
$varName=“ace”;
$$varName=1029;
//This is exactly equivalent to
$ace=1029;
Constants
Always stay the same once defined
Constants are defined with the define() function.
Example: define(“VARIABLE1”, “value”);
Constant names follow the same rules as variable
names
Constants are typically named all in UPPERCASE
but do not have to be.
Variables and Constants Ex:
Constants
One important difference between constants and
variables is that when you refer to a constant, it
does not have a dollar sign in front of it.
If you want to use the value of a constant, use its
name only.
define(‘OILPRICE’,10);
echo OILPRICE;
Sample Program for
Constant Declaration
<?php
define(“USER”,”Grace”);
echo “Welcome ” . USER;
?>
Output:
Welcome Grace
Integer
Integers can be assigned to variables,
or they can be used in expressions,
like so:
$int_var = 12345;
Floating Point
Floating point numbers may be specified
using either decimal or scientific
notation.
Ex: $temperature = 56.89;
Doubles
Doubles are floating-point numbers, such as:
$first_double = 123.456;
$second_double = 0.456
$even_double = 2.0;
Note that the fact that $even_double is a “round” number does not
make it an integer. And the result of:
$five = $even_double + 3;
is a double, not an integer, even if it prints as 5. In almost all
situations, however, you should feel free to mix doubles and integers
in mathematical expressions, and let PHP sort out the typing.
Boolean
The simplest variable type in PHP, a Boolean
variable simply specifies a true or false value.
TRUE=1, FALSE=0
Case-Insensitive
True, TRUE, true are all the same.
Printing out Boolean values.
echo true . “\n”; //prints true
echo false; //(none)
1
(none)
Boolean
The ff. are considered FALSE:
Integers and floats zero(0)
Empty String (“”)
The string “0”
Array with zero elements
NULL
Object with zero member variables
Every other value is considered TRUE.
NULL
Null is a special value that indicates no value.
Case-insensitive
NULL, null, Null
NULL converts to boolean FALSE and integer zero.
A variable is considered to be NULL if:
It has been assigned to the constant NULL
It has not been set to any value yet
It has been unset
<?php
$a= NULL;
echo $a; ?>
isset(), is_null()
isset()
Tests if a variable exists
Returns FALSE if:
Isset to NULL
Variable has been unset()
is_null()
Determines if the given variable is set to NULL.
Returns true if variable is NULL, FALSE otherwise.
empty()
Determines if a variable is empty.
The following values are considered empty:
Value Description
“” Empty String
0 Zero
“0” Zero as string
NULL Null value
FALSE Boolean
isset() vs empty() vs is_null()
Strings
A string is a sequence of characters, like
'hello' or 'abracadabra'. String values may
be enclosed in either double quotes ("")
or single quotes ('').
$name1 = “Ervin”;
$name2 = ‘Grace’;
Singly Quoted Strings
Except for a couple of specially interpreted character
sequences, singly quoted strings read in and store
their characters literally.
$literally = ‘My $variable will not print!\\n’;
print($literally);
produces the browser output:
My $variable will not print!\\n
Doubly Quoted Strings
Strings that are delimited by double quotes (as in
“this”) are preprocessed in both the following two
ways by PHP:
Certain character sequences beginning with backslash
(\) are replaced with special characters.
Variable names (starting with $) are replaced with
string representations of their values.
Escape Sequence Replacements Are:
\n is replaced by the new line character
\t is replaced by the tab character
\$ is replaced by the dollar sign itself ($)
\” is replaced by a single double-quote (“)
\\ is replaced by a single backslash (\
A Note on String Values
<?php
$identity = 'James Bond';
$car = 'BMW';
// this would contain the string
// "James Bond drives a BMW"
$sentence = "$identity drives a $car";
// this would contain the string
// "$identity drives a $car"
$sentence = '$identity drives a $car';
?>
A Note on String Values
<?php
// will cause an error due to
// mismatched quotes
$statement = 'It's hot outside';
// will be fine
$statement = 'It\'s hot outside';
?>
Data Conversion
In PHP, the type of the variable depends on the
value assigned to it.
<?php
$foo = “0”; //$foo is string
$foo += 2; // $foo is an integer
$foo = $foo + 1.3; // $foo is now a float
$foo = 5 + “10 Piggies”; //$foo is an
integer (15)
Typecasting
There are circumstances in which you will want to
control how and when individual variables are
converted from one type to another.
This is called typecasting
Typecasting forces a variable to be evaluated as
another type
The name of the desired type is written in
parentheses before the variable that is to be cast.
Typecasting-Integers
You can typecast any variable to an integer using the (int)
operator.
Floats are truncated so that only their integer portion is
maintained.
echo (int) 99.99; //99
Booleans are cast to either one or zero
(int) TRUE == 1
(int) FALSE == 0
Strings are converted to their integer equivalent
echo (int) “test 123” ; //0
echo (int) “123”; //123
echo (int) “123test”; //123
NULL always evaluates to zero.
Typecasting Booleans
Data is cast to Boolean using the (bool) operator
echo (bool) “1”;
Numeric values are always TRUE unless they
evaluate to zero
Strings are always TRUE unless they are empty
(bool) “FALSE” ==true
Null always evaluates to FALSE.
Typecasting- Strings
Data is typecast to a string using the (string)
operator:
echo (string) 123;
Numeric values are converted to their decimal
string equivalent:
(string) 123.1 == “123.1”;
Booleans evaluate to either “1” (TRUE) or an
empty string (FALSE)
NULL values evaluates to an empty string.
Gettype()
Gets the type of a variable
Returns “boolean”, “integer”, “double”, “string”,
“array”, “object”, “resource”, “NULL”.
<?php
$foo = 2.5; //$foo is a float
$bar =(int) $foo+1; // $bar is an int (3)
//outputs: $bar=3, type:integer
echo ‘$bar = ‘.$bar. “, type: “ .gettype($bar);
//outputs: $foo= 2.5, type: double
echo ‘$foo = ‘ . $foo . “, type: “.gettype($foo);
settype()
Sets the type of a variable
“boolean”, “integer”, “double”, “string”, “array”,
“object”, “resource”, “NULL”
<?php
$foo= 2.0; //$foo is a float
settype($foo, “integer”); //$foo is an int
$bar =$foo + 1; // $bar is an int (3)
//outputs: $bar =3, type: integer
echo ‘$bar = ‘ .$bar . “,type: “ . gettype($bar);
//Outputs: $foo=2, type: integer
echo ‘$foo = ‘ . $foo . “,type: “ . gettype($foo);
?>
