Fadak - Programming - PHP Training Reference
: 2018-07-12Visitor Count : 271

PHP Training Reference


  1. PHP-Quick-Scripting-Reference
    1. Chapter 1: Using PHP
      1. Installing a web server
      2. Embedding PHP
      3. Outputting text
      4. Comments
    2. Chapter 2: Variables
      1. Defining variables
      2. Data types
      3. Integer type
      4. Floating-point type
      5. Bool type
      6. Null type
      7. Default values
    3. Chapter 3: Operators
      1. Arithmetic operators
      2. Assignment operators
      3. Combined assignment operators
      4. Increment and decrement operators
      5. Comparison operators
      6. Logical operators
      7. Bitwise operators
      8. Operator precedence
      9. Additional logical operators
    4. Chapter 4: String
      1. String concatenation
      2. Delimiting strings
      3. Heredoc strings
  2.  
  3. Working with strings in PHP
  4. Introduction
  5. Print Array
    1. print_r
    2. var_dump
    3. var_export

PHP-Quick-Scripting-Reference

Chapter 1: Using PHP

Installing a web server

To view PHP code in a browser the code first has to run a distribution of the popular Apache web server called XAMPP or usbwebserver which comes pre-installed with PHP, Perl and MySQL.

Embedding PHP

PHP code can be embedded anywhere in a web document in one of four different ways. The standard notation is to delimit the code by “”. This is called a PHP
code block, or just a PHP block.

<? = php

?>

Outputting text

Keep in mind that text output will only be visible on the web page if it is located within the HTML body element.

<? = php
echo "Hello World";
print "Hello World"
?>

Comments

Comments are used to insert notes into the code and will have no effect on the parsing of the script. PHP has the two standard C++ notations for single-line (//) and multi-line
(/* */) comments. The Perl comment notation (#) may also be used to make single-line comments.

<? = php

// single-line comment
# single-line comment
/* multi-line
comment */
?>

Chapter 2: Variables

Defining variables

A variable starts with a dollar sign ($) followed by an identifier, which is the name of the variable.

$myVar;

A value can be assigned to a variable by using the equals sign, or assignment operator (=). The variable then becomes defined or initialized.

$myVar = 10;

Data types

PHP is a variable’s data type will change automatically to be able to hold the value it is assigned.

$myVar = 1; // int type
$myVar = 1.5; // float type

Data Type  = Category = Description
int = Scalar = Integer
float = Scalar = Floating-point number
bool = Scalar = Boolean value
string = Scalar = Series of characters
array = Composite = Collection of values
object = Composite = User-defined data type
resource = Special = External resource
callable = Special = Function or method
null = Special = No value

Integer type

An integer is a whole number. They can be specified in decimal (base 10), hexadecimal $myInt = 1234; // decimal number

$myInt = 0b10; // binary number (2 decimal)
$myInt = 0123; // octal number (83 decimal)
$myInt = 0x1A; // hexadecimal number (26 decimal)(base 16), octal (base 8) or binary (base 2) notation.

Floating-point type

The float or floating-point type can store real numbers. These can be assigned using either decimal or exponential notation.

$myFloat = 1.234;
$myFloat = 3e2; // 3*10^2 = 300

Commonly can hold approximately 14 decimal digits and a maximum decimal value of 1.8x10 308 .

Bool type

The bool type can store a Boolean value, which is a value that can only be either true or false. These values are specified with the true and false keywords.

$myBool = true;

Null type

The case-insensitive constant null is used to represent a variable with no value. Such a variable is considered to be of the special null data type.

$myNull = null; // variable is set to null

If evaluated as a bool it becomes false, as a number it becomes zero (0), and as a string it becomes an empty string ("").

$myInt = $myNull + 0; // numeric context (0)
$myBool = $myNull == true; // bool context (false)
echo $myNull; // string context ("")

Default values

In PHP it is possible to use variables that have not been assigned a value. Such undefined variables will then automatically be created with the value null.

echo $myUndefined; // variable is set to null

Chapter 3: Operators

Operators are used to operate on values. They can be grouped into five types: arithmetic, assignment, comparison, logical and bitwise operators.

Arithmetic operators

The arithmetic operators include the four basic arithmetic operations, as well as the modulus operator (%) which is used to obtain the division remainder.

$x = 4 + 2; // 6 // addition
$x = 4 - 2; // 2 // subtraction
$x = 4 * 2; // 8 // multiplication
$x = 4 / 2; // 2 // division
$x = 4 % 2; // 0 // modulus (division remainder)

Assignment operators

The second group is the assignment operators. Most importantly, the assignment operator (=) itself, which assigns a value to a variable.

Combined assignment operators

A common use of the assignment and arithmetic operators is to operate on a variable and then to save the result back into that same variable. These operations can be shortened
with the combined assignment operators.

$x = 0;
$x += 5; // $x = $x+5;
$x -= 5; // $x = $x-5;
$x *= 5; // $x = $x*5;
$x /= 5; // $x = $x/5;
$x %= 5; // $x = $x%5;

Increment and decrement operators

Another common operation is to increment or decrement a variable by one. This can be
simplified with the increment (++) and decrement (−−) operators.

$x++; // $x += 1;
$x−−; // $x -= 1;

Both of these operators can be used either before or after a variable.

$x++; // post-increment
$x−−; // post-decrement
++$x; // pre-increment
−−$x; // pre-decrement

The result on the variable is the same whichever is used. The difference is that
the post-operator returns the original value before it changes the variable, while the
pre-operator changes the variable first and then returns the value.

$x = 5; $y = $x++; // $x=6, $y=5
$x = 5; $y = ++$x; // $x=6, $y=6

Comparison operators

The comparison operators compare two values and return either true or false. They are
mainly used to specify conditions, which are expressions that evaluate to either true
or false.

$x = (2 == 3); // false // equal to
$x = (2 != 3); // true // not equal to
$x = (2 <> 3); // true // not equal to (alternative)
$x = (2 === 3); // false // identical
$x = (2 !== 3); // true // not identical
$x = (2 > 3); // false // greater than
$x = (2 < 3); // true // less than
$x = (2 >= 3); // false // greater than or equal to
$x = (2 <= 3); // true // less than or equal to

The identical operator (===) is used for comparing both the value and data type of
the operands. It returns true if both operands have the same value and are of the same
type. Likewise, the not identical operator (!==) returns true if the operands do not have
the same value or are not of the same type. Put another way, the equality operators will
perform type conversions, whereas the identical operators will not.
$x = (1 == "1"); // true (same value)
$x = (1 === "1"); // false (different types)

Logical operators

The logical operators are often used together with the comparison operators. Logical and
(&&) evaluates to true if both the left and right side are true, and logical or (||) evaluates to
true if either the left or right side is true. The logical not (!) operator is used for inverting
a Boolean result. Note that for both “logical and” and “logical or” the right side of the
operator will not be evaluated if the result is already determined by the left side.

$x = (true && false); // false // logical and
$x = (true || false); // true // logical or
$x = !(true); // false // logical not

Bitwise operators

The bitwise operators can manipulate binary digits of numbers. For example, the xor
operator (^) turn on the bits that are set on one side of the operator, but not on both sides.

$x = 5 & 4; // 101 & 100 = 100 (4) // and
$x = 5 | 4; // 101 | 100 = 101 (5) // or
$x = 5 ^ 4; // 101 ^ 100 = 001 (1) // xor (exclusive or)
$x = 4 << 1; // 100 << 1 =1000 (8) // left shift
$x = 4 >> 1; // 100 >> 1 = 10 (2) // right shift
$x = ~4; // ~00000100 = 11111011 (-5) // invert

These bitwise operators have shorthand assignment operators, just like the
arithmetic operators.

$x=5; $x &= 4; // 101 & 100 = 100 (4) // and
$x=5; $x |= 4; // 101 | 100 = 101 (5) // or
$x=5; $x ^= 4; // 101 ^ 100 = 001 (1) // xor
$x=5; $x <<= 1; // 101 << 1 =1010 (10)// left shift
$x=5; $x >>= 1; // 101 >> 1 = 10 (2) // right shift

Operator precedence

In PHP, expressions are normally evaluated from left to right. However, when an
expression contains multiple operators, the precedence of those operators decides the
order in which they are evaluated.
Pre Operator
1 ++ −−
2 ~ − (unary)
3 !
4 * / %
5 + − (binary)
6 << >>
7 < <= > >= <>
8 == != === !==
9 &10 ^
11 |
12 &&
13 ||
14 = op=
15 and
16 xor
17 or

For example, logical and (&&) binds weaker than relational operators, which in turn
bind weaker than arithmetic operators.

$x = 2+3 > 1*4 && 5/5 == 1; // true

To make things clearer, parentheses can be used to specify which part of the
expression will be evaluated first. Parentheses have the highest precedence of all
operators.

$x = ((2+3) > (1*4)) && ((5/5) == 1); // true

Additional logical operators

In the precedence table make special note of the last three operators: and, or and xor.
The and and or operators work in the same way as the logical && and || operators. The
only difference is their lower level of precedence.

// Same as: $a = (true && false);
$a = true && false; // $a is false
// Same as: ($a = true) and false;
$a = true and false; // $a is true

The xor operator is a Boolean version of the bitwise ^ operator. It evaluates to true
if only one of the operands are true.

$a = (true xor true); // false

Chapter 4: String

A string is a series of characters that can be stored in a variable. In PHP, strings are
typically delimited by single quotes.
$a = 'Hello';

String concatenation

PHP has two string operators. The dot symbol is known as the concatenation operator
(.) and combines two strings into one. It also has an accompanying assignment operator
(.=), which appends the right-hand string to the left-hand string variable.
$b = $a . ' World'; // Hello World
$a .= ' World'; // Hello World

Delimiting strings

PHP strings can be delimited in four different ways. There are two single-line notations:
double-quote (" ") and single-quote (' '). The difference between them is that variables
are not parsed in single-quoted strings whereas they are parsed in double-quoted strings.
$c = 'World';
echo "Hello $c"; // "Hello World"
echo 'Hello $c'; // "Hello $c"
Single-quoted strings tend to be preferred unless parsing is desired, mainly because
string parsing has a very small performance overhead. However, double-quoted strings
are considered easier to read, which makes the choice more a matter of preference.
In addition to single-quoted and double-quoted strings, there are two multi-line
notations: heredoc and nowdoc. These notations are mainly used to include larger
blocks of text.

Heredoc strings

The heredoc syntax consists of the <<< operator followed by an identifier and a new line.
The string is then included followed by a new line containing the identifier in order to
close the string. Variables are parsed inside of a heredoc string, just as with double-quoted
strings.
$s = <<<LABEL
Heredoc (with parsing)
LABEL;
Nowdoc strings
The syntax for the nowdoc string is the same as for the heredoc string, except that the
initial identifier is enclosed in single-quotes. Variables will not be parsed inside
a nowdoc string.
$s = <<<'LABEL'
Nowdoc (without parsing)
LABEL;
Escape characters
Escape characters are used to write special characters, such as backslashes or
double-quotes. A table of the escape characters available in PHP can be seen below.

Character Meaning
\n    newline
\t     horizontal tab
\r    carriage return
\f     form feed
\$    dollar sign
\v    vertical tab
\'     single quote
\e    escape
\"    double quote
\\    backslash

For example, line breaks are represented with the escape character “\n” in text.
$s = "Hello\nWorld";
Note that this character is different from the
HTML tag, which creates line
breaks on web pages.
echo "Hello
World";

When using the single-quote or nowdoc delimiter the only escape characters that
work are the backslash (\\) and single-quote (\') characters.
$s = 'It\'s'; // "It's"
Escaping the backslash is only necessary before a single-quote or at the end of
the string.
Character reference
Characters within strings can be referenced by specifying the index of the desired
character in square brackets after the string variable, starting with zero. This can be used
both for accessing and modifying single characters.
$s = 'Hello';
$s[0] = 'J';
echo $s; // "Jello"
The strlen function retrieves the length of the string argument. This can for example
be used to change the last character of a string.
$s[strlen($s)-1] = 'y';
echo $s; // "Jelly"
String compare
The way to compare two strings is simply by using the equal to operator. This will not
compare the memory addresses, as in some other languages.
$a = 'test';
$b = 'test';
$c = ($a == $b); // true

Chapter 5: Arrays ■ 17
Chapter 6: Conditionals ■ 21
Chapter 7: Loops ■ 25
Chapter 8: Functions ■ 29
Chapter 9: Class ■ 35
Chapter 10: Inheritance ■ 39
Chapter 11: Access Levels ■ 43
Chapter 12: Static ■ 47
Chapter 13: Constants ■ 51
Chapter 14: Interface ■ 55
Chapter 15: Abstract ■ 59
Chapter 16: Traits ■ 61
Chapter 17: Importing Files ■ 63
Chapter 18: Type Hinting ■ 67
Chapter 19: Type Conversions ■ 69
Chapter 20: Variable Testing ■ 73
Chapter 21: Overloading ■ 77
Chapter 22: Magic Methods ■ 81
Chapter 23: User Input ■ 87
Chapter 24: Cookies ■ 93
Chapter 25: Sessions ■ 95
Chapter 26: Namespaces ■ 97
Chapter 27: References ■ 103
Chapter 28: Advanced Variables ■ 107
Chapter 29: Error Handling ■ 111
Chapter 30: Exception Handling ■ 117

 

Working with strings in PHP

Introduction

error_reporting(0);
set_time_limit (0);

Print Array

print_r

$a = array ('a' => 'apple''b' => 'banana''c' => array ('x''y''z'));
print_r ($a);

print_r Prints human-readable information about a variable

var_dump

$a = array(12, array("a""b""c"));
var_dump($a);
 

 var_dumpDumps information about a variable

var_export

$a = array (12, array ("a""b""c"));
var_export($a);

var_exportOutputs or returns a parsable string representation of a variable

$text= strip_tags($text, '');

کار با تگ‎ها در HTML

$dom = new DomDocument;
$dom->loadHTML($text);
$dom->preserveWhiteSpace = false;
$divs = $dom->getElementsByTagName('dd');
foreach ($divs as $div) {
echo $ii += 1;
    echo $div->nodeValue . "\n";
}

 

 

 

http://stackoverflow.com/questions/1592438/create-array-from-the-contents-of-div-tags-in-php

 

 

PHP Arithmetic Operations :: pow() Cheatsheet for PHP 7.2.0

HTML Cheat Sheet | OverAPI.com

BlueShoes: PHP Cheat Sheet

20 Must Have PHP Cheat Sheet for Every Developers


   

2000-2016 CMS Fadak. ||| Version : 4.2-b1 ||| This page was produced in : 0.003 Seconds