Expressions and Operators.pptx

Expressions
 An expression is a bit of PHP that can be
evaluated to produce a value. The simplest
expressions are literal values and variables.
 A literal value evaluates to itself, while a variable
evaluates to the value stored in the variable.
 More complex expressions can be formed using
simple expressions and operators.

Operators
 An operator takes some values (the operands)
and does something (for instance, adds them
together).
 Operators are written as punctuation symbols—
for instance, the + and - familiar to us from math.
 Some operators modify their operands, while
most do not.

Number of operands
 Most operators in PHP are binary operators(they
combine two operands (or expressions)into a
single ,more complex
expression.
 PHP also supports a number of unary operator
which
convert a single expression into a more complex
expression.
 PHP supports a single ternary operator that
combines three
expressions into a single expression.

Operator Precedence
 The order in which operators in an expression are
evaluated depends on their relative precedence. For
example, you might write:
 2 + 4 * 3
 As you can see in, the addition and multiplication
operators have different precedence, with
multiplication higher than addition. So the
multiplication happens before the addition,
giving 2 + 12, or 14, as the answer.
 One way many programmers deal with the
complex precedence rules in programming languages
is to reduce precedence down to two rules:
 Multiplication and division have higher precedence
than addition and subtraction.
 Use parentheses for anything else

Operator Associativity
 Associativity defines the order in which operators with
the same order of precedence are evaluated. For
example, look at:
 2 / 2 * 2
 The division and multiplication operators have the
same precedence, but the result of the expression
depends on which operation we do first:
 2/(2*2) // 0.5
 (2/2)*2 // 2
 The division and multiplication operators are left-
associative; this means that in cases of ambiguity, the
operators are evaluated from left to right. In this
example, the correct result is 2.

Addition
<html>
<body>
<?php
$x=10;
$y=9;
$z=$x + $y;
echo $z;
?>
</body>
</html>

Subtraction
<html>
<body>
<?php
$x = 10;
$y = 6;
echo $x - $y;
?>
</body>
</html>

Multiplication
<html>
<body>
<?php
$x=10;
$y=9;
$z=$x - $y;
echo $z;
?>
</body>
</html>

Modulus
<html>
<body>
<?php
$x=10;
$y=9;
$z=$x % $y;
echo $z;
?>
</body>
</html>

PHP Incrementing/Decrementing
Operators

Pre-increment
<html>
<body>
<?php
$x=10;
++$x;
echo $x;
?>
</body>
</html>

Post-increment
<html>
<body>
<?php
$x=10;
$x++;
echo $x;
?>
</body>
</html>

Pre-decrement
<html>
<body>
<?php
$x=10;
--$x;
echo $x;
?>
</body>
</html>

Post-decrement
<html>
<body>
<?php
$x=10;
$x--;
echo $x;
?>
</body>
</html>

The left operand gets set to the value
of the expression on the right
<html>
<body>
<?php
$x = 10;
echo $x;
?>
</body>
</html>

Addition(x += y)
<?php
$x = 20;
$x += 100;
echo $x;
?>
</body>
</html>

Subtraction(x -= y)
<html>
<body>
<?php
$x = 50;
$x -= 30;
echo $x;
?>
</body>
</html>

Multiplication(x *= y)
<html>
<body>
<?php
$x = 10;
$y = 6;
echo $x *= $y;
?>
</body>
</html>

Division(x /= y)
<html>
<body>
<?php
$x = 10;
$x /= 5;
echo $x;
?>
</body>
</html>

Modulus(x %= y)
<html>
<body>
<?php
$x = 15;
$x %= 4;
echo $x;
?>
</body>
</html>

Equal(==)
<html>
<body>
<?php
$x = 100;
$y = "100";
var_dump($x == $y); // returns true because values
are equal
?>
</body>
</html>

Identical(===)
<html>
<body>
<?php
$x = 100;
$y = "100";
var_dump($x === $y); // returns false because types are
not equal
?>
</body>
</html>

Not equal(!=)
<html>
<body>
<?php
$x = 100;
$y = "100";
var_dump($x != $y); // returns false because values
are equal
?>
</body>
</html>

Not equal(<>)
<html>
<body>
<?php
$x = 100;
$y = "100";
var_dump($x <> $y); // returns false because
values are equal
?>
</body>
</html>

Not identical(!==)
<html>
<body>
<?php
$x = 100;
$y = "100";
var_dump($x !== $y); // returns true because types are
not equal
?>
</body>
</html>

Greater than(>)
<html>
<body>
<?php
$x = 100;
$y = 50;
var_dump($x > $y); // returns true because $x is greater
than $y
?>
</body>
</html>

Greater than or equal to(>=)
<html>
<body>
<?php
$x = 50;
$y = 50;
var_dump($x >= $y); // returns true because $x is
greater than or equal to $y
?>
</body>
</html>

Less than or equal to(<=)
<html>
<body>
<?php
$x = 50;
$y = 50;
var_dump($x <= $y); // returns true because $x is less
than or equal to $y
?>
</body>
</html>

and $x and $y)
<html>
<body>
<?php
$x = 100;
$y = 50;
if ($x == 100 and $y == 50) {
echo "Hello world!";
}
?>
</body>
</html>

&& ($x && $y)
<html>
<body>
<?php
$x = 100;
$y = 50;
if ($x == 100 && $y == 50) {
}
?>
</body>
</html>

Or($x or $y)
<html>
<body>
<?php
$x = 100;
$y = 50;
if ($x == 100 or $y == 80) {
}
?>
</body>
</html>

II ($x || $y)
<html>
<body>
<?php
$x = 100;
$y = 50;
if ($x == 100 || $y == 80) {
}
?>
</body>
</html>

Xor ($x xor $y)
<html>
<body>
<?php
$x = 100;
$y = 50;
if ($x == 100 xor $y == 80)
{
}
?>
</body>
</html>

! (!$x)
<html>
<body>
<?php
$x = 100;
if ($x !== 90) {
}
?>
</body>
</html>

Bitwise Operators
 PHP ’ s bitwise operators let you work on the
individual bits within integer variables. A bit with a
value of 1 is said to be set , whereas a bit with a
value of 0 is unset (or not set).

Example
<?php
$x=2;
$y=4;
echo $x & $y;
echo $x | $y;
echo $x ^ $y;
echo $x << 2;
echo $y >> 2;
?>
 Output: 0, 6, 6, 8, 1
2= 0010
4= 0100

var_dump()
 The var_dump function is used to display
structured information (type and value) about one
or more variable.
 Syntax
 Var_dump(var1,var2,…varn);
<?php
$x=10;
$y=“10”;
Var_dump($x===$y);
?>

String Operators
 There ’ s really only one string operator, and that ’
s the concatenation operator , . (dot). This
operator simply
takes two string values, and joins the right - hand
string onto the left - hand one to make a longer
string.
 For example:
<?php
echo “Amit, “ . “is good boy ”; // “ Amit, is good boy”
?>

Concatenation (.)
<html>
<body>
<?php
$txt1 = "Hello";
$txt2 = " world!";
echo $txt1 . $txt2;
?>
</body>
</html>

Example
<html>
<head>
<title>Some More Practice</title>
</head>
<body>
<?php
$first_number = 10;
$direct_text = 'My variable contains the value of ';
print($direct_text . $first_number);
?>
</body>
</html>

Casting Operators
 The casting operators, (int), (float), (string), (bool),
(array), and (object), allow you to force a value
into a particular type.
 To use a casting operator, put the operator to the
left of the operand.

Type Casting
 PHP is a loosely typed language and assigns
types to variables depending what is assigned to
it.
 Example: if a string value is assigned to variable
$var, $var
becomes a string. If an integer value is then
assigned to $var,
it becomes an integer.
 In PHP there are various ways for Type Casting
1. Automatic or implicit type casting( by using
addition operator '+‘)
2. settype() function(To force a variable to be
evaluated as a certain type, or To change the type
of a variable

Implicit Casting or type juggle
 The conversion of a value from one type to
another is called casting.
 This kind of implicit casting is called type
juggling in PHP.
 PHP is a loosely typed language that allows you
to declare a variable and its type simply by using
it. It also automatically converts values from one
type to another whenever required. This is
called implicit casting or type juggle.

Automatic or implicit type
casting
 Example:
<?php
$a = "2";
echo $a." ";
$a+= 2;
echo $a." ";
$a = $a + 1.3;
echo $a." ";
$a = 5 + "10 Little ";
echo $a." ";
$a = 5 + "10 Small ";
echo $a." "
?>
Output

Implicit casting rules for binary
arithmetic operations
Type of first operand Type of second operand Conversion performed
Integer Floating point The integer is converted
to a floating-point number
Integer String The string is converted to
a number
Floating point String The string is converted to
a floating-point number

settype() function
 Example:
<?php
$a = "5bar"; // string
$b = true; // Boolean
settype($a, "integer"); // $a is now 5 (integer)
settype($b, "string"); // $b is now "1" (string)
?>

Explicit Casting or Casting
Operator
 The casting operators are allow us to force a
value into
a particular type
 In explicit casting the casting operator put the
operator to the left of the operand.

Example
 Casting affects the way other operators interpret
a value, rather than changing the value in a
variable. For example, the code:
 $a = "5";
 $b = (int)$a;
 assigns $b the integer value of $a; $a remains
the string "5". To cast the value of the variable
itself, you must assign the result of a cast back
into the variable:
 $a = "5"
 $a = (int)$a; // now $a holds an integer

Miscellaneous Operators
 Error suppression (@) Some operators or functions can generate
error messages.
If you don't want a warning thrown when using functions like fopen(),
you can suppress the error but use exceptions:
 Example:
try
{
if (($fp = @fopen($filename, "r")) == false)
{ throw new Exception; }
else
{ do_file_stuff(); }
}
catch (Exception $e)
{ handle_exception(); }
 Conditional (?:) The conditional operator is, depending on the code
we look at, either the most overused or most underused operator. It is
the only ternary (three-operand) operator and is therefore sometimes
just called the ternary operator.

Expressions and Operators.pptx

Recommended

Recommended

More Related Content

Similar to Expressions and Operators.pptx

Similar to Expressions and Operators.pptx (20)

Recently uploaded

Recently uploaded (20)

Expressions and Operators.pptx