Php double curly braces. The concept of operator brackets

For string interpolation. From the manual:

Complex (curly) syntax

It is not called complex because the syntax is complex and therefore allows for complex expressions.

Any scalar variable, array element, or object property with a string representation can be included through this syntax. Just write the expression as you would outside the string, and then wrap it in ( and ) . Since ( cannot be escaped, this syntax will only be recognized when $ follows ( . use (\$ to get the literal ($ . Some examples to make it clear:

width)00 centimeters broad."; // Works, quoted keys only work using the curly brace syntax echo "This works: ($arr["key"])"; // Works echo "This works: ($arr)" ; // This is wrong for the same reason as $foo is wrong outside a string. // In other words, it will still work, but only because PHP first looks for a // constant named foo; undefined constant) will be // thrown. echo "This is wrong: ($arr)"; arr["foo"])"; // Works. echo "This works: " . $arr["foo"]; echo "This works too: ($obj->values->name)"; echo "This is the value of the var named $name: ($($name))"; echo "This is the value of the var named by the return value of getName(): ($(getName()))"; echo "This is the value of the var named by the return value of \$object->getName(): ($($object->getName()))"; // Won"t work, outputs: This is the return value of getName(): (getName()) echo "This is the return value of getName(): (getName())"; ?>

Often this syntax is not needed. For example this:

$a = "abcd"; $out = "$a $a"; // "abcd abcd";

behaves exactly like this:

$out = "($a) ($a)"; // same

Thus, curly braces are not needed. But this:

$out = "$aefgh";

will, depending on your error level, either not work or create an error because there is no variable named $aefgh , so you need to do:

$out = "$(a)efgh"; // or $out = "($a)efgh";

$GLOBALS variable. An associative array containing references to all script global scope variables currently defined. Variable names are array keys.

To declare a global variable, just place it in the $GLOBALS array

$GLOBALS["testkey2"]="testvalue2";

You can display all the values ​​of the $GLOBALS array variables using print_r($GLOBALS); or like this:

Foreach ($GLOBALS as $key=>$value) echo "GLOBALS[".$key."] == ".$value."
";

$_SERVER variable.

$_REQUEST variable- an associative array (array), which by default contains the data of the $_GET, $_POST and $_COOKIE variables. Variables in the $_REQUEST array are passed to the script using the GET, POST or COOKIE methods, so they cannot be trusted because they could have been changed by a remote user. Their presence and the order in which data is added to the corresponding arrays is determined by the variables_order directive (GPCS is set by default).

$_SESSION variable

$_ENV variable. Filled in if the script was launched from the command line. The $_SERVER array will contain all the variables from the $_ENV array.

$http_response_header variable

Comment: In PHP 7.0.0 on 64-bit platforms there are no achievable limits on line length; on 32-bit systems and in earlier versions of PHP, lines cannot be larger than 2 GB (2147483647 bytes).

Syntax

A string can be defined in four different ways:

• single quotes
• double quotes
• nowdoc syntax(since PHP 5.3.0)

Single quotes

The simplest way to define a string is to enclose it in single quotes (the character " ).

To use a single quote inside a string, escape it with a backslash ( \ ). If you need to write the backslash itself, duplicate it ( \\ ). All other uses of the backslash will be interpreted as normal characters: this means that if you try to use other escape sequences such as \r or \n, they will be output as is instead of any special behavior.

echo "this is a simple string";

echo "You can also insert into lines
newline character like this,
This is fine";

// Outputs: Arnold once said: "I"ll be back"
echo "One day Arnold said, 'I\"ll be back.'';

Echo "Did you delete C:\\*.*?";

// Outputs: Did you delete C:\*.*?
echo "Did you delete C:\*.*?" ;

// Outputs: This will not be expanded: \n new line
echo "This will not be expanded: \n newline";

// Outputs: $expand and $either variables are not expanded
echo "$expand and $either variables are not expanded";
?>

Double quotes

If the string is enclosed in double quotes ("), PHP recognizes the following special character escape sequences:

Escape Sequences

Subsequence	Meaning
\n	newline (LF or 0x0A (10) in ASCII)
\r	carriage return (CR or 0x0D (13) in ASCII)
\t	horizontal tab (HT or 0x09 (9) in ASCII)
\v	vertical tab (VT or 0x0B (11) in ASCII) (since PHP 5.2.5)
\e	escape character (ESC or 0x1B (27) in ASCII) (since PHP 5.4.4)
\f	page feed (FF or 0x0C(12) in ASCII) (since PHP 5.2.5)
\\	backslash
\$	dollar sign
\"	double quote
\{1,3}	a sequence of characters matching a regular expression of an octal character that silently overflows to fit into a byte (i.e. "\400" === "\000")
\x(1,2)	sequence of characters corresponding to the regular expression of a character in hexadecimal notation
\u(+)	a sequence of characters matching a Unicode character regular expression that maps to a string in UTF-8 representation (added in PHP 7.0.0)

As with a string enclosed in single quotes, escaping any character will also output the escape character itself. Before PHP 5.1.1, backslash in \($var) was not published.

Heredoc

The third way to define strings is to use heredoc syntax: <<< . After this operator, you must specify an identifier, then a line feed. After this comes the line itself, and then the same identifier, closing the insertion.

Line must start with a closing identifier, i.e. it must appear in the first column of the row. Additionally, the identifier must follow the same naming rules as all other tags in PHP: contain only alphanumeric characters and an underscore, and must not start with a number (underscores are allowed).

Attention

It is very important to note that the closing identifier line must not contain any other characters except a semicolon ( ; ). This means that the id should not be indented and that there cannot be any spaces or tabs before or after the semicolon. It is also important to understand that the first character before the closing identifier must be a newline character as defined by your operating system. For example, on UNIX systems, including macOS, this is \n. A new line must also begin immediately after the closing identifier.

If this rule is violated and the closing identifier is not "clean", the closing identifier is considered missing and PHP will continue to look for it further. If in this case the correct closing identifier is never found, it will cause a parsing error with the line number at the end of the script.

Example #1 Example of incorrect syntax

class foo (
public $bar =<<bar
EOT;
// indentation before the closing identifier is not allowed
}
?>

Example #2 Example of correct syntax

class foo (
public $bar =<<bar
EOT;
}
?>

Heredoc cannot be used to initialize class fields.

Starting from PHP 5.3, this restriction only applies to heredocs containing variables.

Heredoc text behaves in the same way as a string in double quotes, without having them.

This means that you don't need to escape quotes in heredoc, but you can still use the escape sequences above.<<Variables are processed, but you need to be as careful when using complex variables inside heredoc as when working with strings.
Example #3 Heredoc string definition example
$str =
Example line,

spanning several lines,
{
using heredoc syntax.
EOD;

Class foo
{
var $foo ;
var $bar ;
}
}

Function__construct()
$this -> foo = "Foo" ;

$this -><<$foo = new foo(); .
$name = "Name" ; echo .
My name is "$name". I type $foo -> foo
EOT;
?>

Now I'm deducing

( $foo -> bar [ 1 ])

This should output the capital letter "A": \x41

My name is "Name". I type Foo. Now, I output Bar2. This should output a capital letter "A": A

It is also possible to use heredoc syntax to pass data through function arguments:
Since version 5.3.0, it has become possible to initialize static variables and class properties/constants using heredoc syntax:
{
Example #5 Using heredoc to initialize static variables<<// Static variables
function foo()
}

static $bar =
There's nothing here...
{
LABEL;<<// Constants/class properties
class foo

const BAR =<<Example of using a constant
class foo
}
?>

FOOBAR;

Public $baz =

Example of using a field As of PHP 5.3.0, you can also surround the Heredoc identifier with double quotes: Nowdoc by declaring a block of text not intended to be processed.

Nowdoc is indicated by the same sequence <<< , which is used in heredoc, but the following identifier is enclosed in single quotes, for example, <<<"EOT" .

All conditions that apply to heredoc identifiers also apply to nowdoc, especially those that apply to the closing identifier.

$this -><<<"EOD"
Example #7 Example of using nowdoc
Example text,
spanning several lines
using nowdoc syntax. Backslashes are always treated literally,
for example, \\ and \".

EOD;

The result of running this example:

Example of text spanning multiple lines using nowdoc syntax. Backslashes are always treated literally, such as \\ and \".

Example #8 Nowdoc string quoting example with variables
There's nothing here...
{
/* More complex example with variables. */
public $foo ;

Class foo
{
var $foo ;
public $bar ;
}
}

Function__construct()
$this -> foo = "Foo" ;

$this -><<<"EOT"
$this -> bar = array("Bar1" , "Bar2" , "Bar3" );
My name is "$name". I print $foo->foo.
Now I print ($foo->bar).
EOT;
?>

EOD;

This should not output a capital "A": \x41

My name is "$name". I print $foo->foo. Now I print ($foo->bar). This should not output a capital "A": \x41

class foo (
public $bar =<<<"EOT"
bar
EOT;
}
?>

Comment:

Example #9 Example of using static data

nowdoc support was added in PHP 5.3.0.

Handling Variables If the string is specified in double quotes, or using heredoc, variables

are processed inside it. There are two types of syntax: simple And difficult . Simple syntax is easier and more convenient. It makes it possible to process a variable, an array value ( array ) or object properties (

object

) with a minimum of effort.

Complex syntax can be identified by the curly braces surrounding the expression. $ Simple syntax

If the interpreter encounters a dollar sign (

), it captures as many characters as possible to form the correct variable name. If you want to specify the end of a name, enclose the variable name in curly braces.

$juice = "apple" ;
echo "He drank some $juice juice." . PHP_EOL ;

// Incorrect. "s" is a valid character for a variable name, but the variable is named $juice.
echo "He drank some juice made of $juices." ;
?>

EOD;

// Correct. The end of the variable name is strictly indicated using brackets:

echo "He drank some juice made of $( juice ) s." ; . He drank some apple juice. He drank some juice made of . He drank some juice made of apples. array An array element ( ] ) marks the end of the index definition. The same rules apply for object properties as for simple variables.

Example #10 Simple syntax example

define ("KOOLAID" , "koolaid1" );
$juices = array("apple" , "orange" , "koolaid1" => "purple" );

echo "He drank some $juices [ 0 ] juice." . PHP_EOL ;
echo "He drank some $juices [ 1 ] juice." . PHP_EOL ;
echo "He drank some $juices [ koolaid1 ] juice." . PHP_EOL ;

class people (
public $john = "John Smith" ;
public $jane = "Jane Smith" ;
public $robert = "Robert Paulsen" ;

Public $smith = "Smith" ;
}

$people = new people();

echo "$people -> john drank some $juices [ 0 ] juice." . PHP_EOL ;
echo " $people -> john then said hello to $people -> jane ." . PHP_EOL ;
echo "$people -> john "s wife greeted $people -> robert." . PHP_EOL;
echo " $people -> robert greeted the two $people -> smiths ." ; // Won't work
?>

EOD;

He drank some apple juice. He drank some orange juice. He drank some purple juice. John Smith drank some apple juice. John Smith then said hello to Jane Smith. John Smith's wife greeted Robert Paulsen. Robert Paulsen greeted the two.

PHP 7.1.0 added support negative numerical indices.

Example #11 Negative numeric indices

$string = "string" ;
echo "The character at index -2 is equal to$string [- 2 ] ." , PHP_EOL ;
$string [- 3 ] = "o" ;
echo "Changing the character at position -3 to 'o' produces the following line:$string." , PHP_EOL;
?>

EOD;

The character with index -2 is equal to n. Changing the character at position -3 to "o" gives the following line: strong

For anything more complex, use complex syntax.

Complex (curly) syntax

It is called complex not because it is difficult to understand, but because it allows the use of complex expressions.

Any scalar variable, array element, or object property mapped to a string can be represented in a string using this syntax. Just write the expression the same way you would outside the line and then wrap it in { And } . Because the { cannot be escaped, this syntax will only be recognized when $ follows directly { . Use {\$ to print {$ .

A few illustrative examples:
// Show all errors

error_reporting(E_ALL);

$great = "great" ;
// Doesn't work, outputs: This is (great)

echo "This is ( $great )" ;
// Works, outputs: This is great

echo "This is ( $great ) " ;
echo // Works"This square is wide

( $square -> width ) 00 centimeters." ;
// Works, quoted keywords only work with curly brace syntax

echo "This is ( $great ) " ;
echo "This works: ( $arr [ 4 ][ 3 ]) " ;

// This is invalid for the same reason as $foo outside
// lines. In other words, it will still work,
// but since PHP looks for the constant foo first, this will cause
// level error E_NOTICE (undefined constant).
echo "It is not right:( $arr [ foo ][ 3 ]) " ;

// Works. When using multidimensional arrays internally
// lines always use curly braces
echo "This works: ( $arr [ "foo" ][ 3 ]) " ;

// Works.
echo "This works: " . $arr [ "foo" ][ 3 ];

echo "This works too:( $obj -> values ​​[ 3 ]-> name ) " ;

echo "This is the value of the variable named$name : ($( $name )) " ;

echo "This is the value of the variable named as returned by the getName() function:($( getName ())) " ;

echo "This is the value of the variable by name that \$object->getName() returns:($( $object -> getName ())) " ;

// Doesn't work, outputs: This is what getName() returns: (getName())
echo "This is what getName() returns: (getName())";
?>

It is also possible to access object properties within strings using this syntax.

class foo (
var $bar = "I am bar." ;
}

Function__construct()
$bar = "bar" ;
$baz = array("foo" , "bar" , "baz" , "quux" );
echo " ( $foo -> $bar ) \n" ;
echo " ( $foo ->( $baz [ 1 ])) \n" ;
?>

EOD;

I am bar. I am bar.

Comment:

Functions, method calls, static class variables, and class constants work internally {$} , starting with PHP 5. However, the supplied value will be treated as a variable name in the same context as the line in which it is defined. Using single curly braces ( {} ) will not work for accessing the values ​​of functions, methods, class constants, or static class variables.

A few illustrative examples:
// Show all errors

class beers (
const softdrink = "rootbeer" ;
public static $ale = "ipa" ;
}

$rootbeer = "A & W" ;
$ipa = "Alexander Keith\"s" ;

// This works, outputs: I would like A & W
echo "I'd like ($( beers :: softdrink )) \n" ;

// This works too, outputs: I would like Alexander Keith's
echo "I'd like ($( beers :: $ale )) \n" ;
?>

Accessing and changing a character in a string

Characters in strings can be used and modified by specifying their offset from the beginning of the string, starting at zero, in square brackets after the string, for example, $str . Think of a string for this purpose as an array of characters. And If you need to get or replace more than 1 character, you can use the functions .

Comment: substr() substr_replace() on read (returning an empty string) or E_WARNING when writing (leaving the line unchanged).

Comment: A character in a string can also be accessed using curly braces, for example $str(42) .

Attention

Attempting to write to an offset beyond the line's boundaries will pad the string with spaces up to that offset. Non-integer types will be converted to integer types. E_WARNING The wrong offset type will cause a level error

Attention

.

Comment: Only the first character of the assigned string is used.

As of PHP 7.1.0, assigning an empty string will cause a fatal error. Previously, in this case, a zero byte (NULL) was assigned.

Strings in PHP are internally arrays of bytes. As a result, accessing or modifying a string at an offset is not multi-byte encoding safe, and should only be done with strings in single-byte encodings, such as ISO-8859-1.
Since PHP 7.1.0, using an empty index causes a fatal error; previously, in this case, the string was converted to an array without warning.
Example #12 Some example strings

// Get the first character of the string
$str = "This is a test." ;

$first = $str [ 0 ];
// Get the third character of the string
$third = $str [ 2 ];

// Get the last character of the string
$str = "This is still a test." ;
$last = $str [ strlen ($str ) - 1 ];

?>

// Change the last character of the line $str = "Look at the sea" ;$str [ strlen ($str )- 1 ] = "e" ; 0 .

As of PHP 5.4, the offset in a string must be specified as either an integer or a string containing digits, otherwise a warning will be issued. Previously offset given by a string like

"foo"

, without warning was transformed into
Example #13 Differences between PHP 5.3 and PHP 5.4

$str = "abc" ;
Var_dump($str["1"]);

var_dump (isset($str [ "1" ]));
Var_dump($str["1.0"]);

var_dump (isset($str [ "1.0" ]));
Var_dump($str["x"]);
?>

var_dump (isset($str [ "x" ]));

Var_dump($str["1x"]);

var_dump (isset($str [ "1x" ]));

The result of running this example in PHP 5.3:

Comment:

string(1) "b" bool(true) string(1) "b" bool(true) string(1) "a" bool(true) string(1) "b" bool(true) The result of running this example in PHP 5.4: {} string(1) "b" bool(true) Warning: Illegal string offset "1.0" in /tmp/t.php on line 7 string(1) "b" bool(false) Warning: Illegal string offset "x" in / tmp/t.php on line 9 string(1) "a" bool(false) string(1) "b" bool(false) Trying to access variables of other types (excluding arrays or objects that implement certain interfaces) using.

Comment:

PHP 5.5 added support for accessing characters in string literals using the syntax or {} .

There are many useful functions for modifying strings.

The main functions are described in the section string functions, and for advanced search and replace - functions Perl-compatible regular expressions.

Convert to string

A value can be converted to a string using a cast (string), or functions strval() . In expressions where a string is required, the conversion occurs automatically. The result of running this example in PHP 5.4: This happens when you use functions echo print And , or when the value of a variable is compared with a string. Reading sections of the manual Types Type Manipulation .

will make the following clearer. see also settype() Arrays are always converted to string . "Array" In expressions where a string is required, the conversion occurs automatically. or This happens when you use functions , so you can't display the contents of the array ( ), using to see what it contains. To view a single element, use something like

echo $arr["foo"] . See below for tips on how to display/view all content. To convert a type variable "Object" in type string.

magic method is used Trying to access variables of other types (excluding arrays or objects that implement certain interfaces) using __toString

Meaning is always converted to the empty string. And As you can see above, directly converting arrays, objects, or resources to a string does not provide any useful information about the values ​​themselves other than their types. .

A better way to output values ​​for debugging is to use functions print_r() .

var_dump()

Most values ​​in PHP can be converted to a string for persistent storage. This method is called serialization and can be done using the function

serialize() Converting strings to numbers If the string is recognized as a numeric value, the resulting value and type are determined as follows. If the string does not contain any of the characters ".", "e", or "E", and the value of the number falls within the limits of integers (defined PHP_INT_MAX ), the string will be recognized as an integer ( ).

integer

). // $foo is a float (11.5)
$foo = 1 + "-1.3e3" ; // $foo is a float (-1299)
$foo = 1 + "bob-1.3e3" ; // $foo is an integer (1)
$foo = 1 + "bob3" ; // $foo is an integer (1)
$foo = 1 + "10 Small Pigs" ; // $foo is an integer (11)
$foo = 4 + "10.2 Little Piggies" ; // $foo is a float (14.2)
$foo = "10.0 pigs " + 1 ; // $foo is float (11)
$foo = "10.0 pigs " + 1.0 ; // $foo is float (11)
?>

For more information about this conversion, see the section on strtod(3) in the Unix documentation.

If you want to test any of the examples in this section, copy and paste it and the following line to see what happens:

echo "\$foo== $foo ; type: " . gettype ($foo) . "
\n" ;
?>

Don't expect to get the code of a character by converting it to an integer (as is done, for example, in C). To convert characters to their ASCII codes and back, use the functions ord() And chr() .

String type implementation details

7 years ago

The documentation does not mention, but a closing semicolon at the end of the heredoc is actually interpreted as a real semicolon, and as such, sometimes leads to syntax errors.

$foo =<<abcd
END;
?>

This does not:

foo(<<abcd
END;
);
// syntax error, unexpected ";"
?>

Without semicolon, it works fine:

foo(<<abcd
END
);
?>

3 years ago

You can use string like array of char (like C)

$a = "String array test";

var_dump($a);
// Return string(17) "String array test"

var_dump($a);
// Return string(1) "S"

// -- With array cast --
var_dump((array) $a);
// Return array(1) ( => string(17) "String array test")

var_dump((array) $a);
// Return string(17) "S"

Norihiori

1 year ago

Any single expression, however complex, that starts with $ (i.e., a variable) can be ()-embedded in a double-quoted string:

Echo "The expression ( $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42 )) gets parsed just as well as ". $h -> q ()[ "x)" ]-> p (9 == 0 ? 17 : 42) . "does." ;

?>

2 years ago

Both should work:(

Class Testing (
public static $VAR = "static" ;
public const VAR = "const" ;

Public function sayHelloStatic() (
echo "hello: ( $this :: $VAR ) " ;
}

Public function sayHelloConst() (
echo "hello: ( $this ::VAR) " ; //Parse error: syntax error, unexpected ")", expecting "["
}
}

$obj = new Testing();
$obj -> sayHelloStatic();
$obj -> sayHelloConst ();

14 years ago

You can use the complex syntax to put the value of both object properties AND object methods inside a string. For example...
classTest{
public$one= 1 ;
public functiontwo() {
return2 ;
}
}
$test= newTest();
echo"foo{ $test-> one} bar{ $test-> two()} " ;
?>
Will output "foo 1 bar 2".

However, you cannot do this for all values ​​in your namespace. Class constants and static properties/methods will not work because the complex syntax looks for the "$".
classTest{
constONE= 1 ;
}
echo"foo (Test::ONE) bar";
?>
This will output "foo (Test::one) bar". Constants and static properties require you to break up the string.

6 years ago

Leading zeroes in strings are (least-surprise) not treated as octal.
Consider:
$x = "0123" + 0;
$y = 0123 + 0;
echo "x is $x, y is $y"; //prints "x is 123, y is 83"
in other words:
* leading zeros in numeric literals in the source-code are interpreted as "octal", c.f. strtol().
* leading zeros in strings (eg user-submitted data), when cast (implicitly or explicitly) to integer are ignored, and considered as decimal, c.f. strtod().

3 years ago

Beware that consistent with "String conversion to numbers":

if ("123abc"== 123 ) echo"(intstr == int) incorrectly tests as true.";

// Because one side is a number, the string is incorrectly converted from intstr to int, which then matches the test number.

// True for all conditionals such as if and switch statements (probably also while loops)!

// This could be a huge security risk when testing/using/saving user input, while expecting and testing for only an integer.

// It seems the only fix is ​​for 123 to be a string as "123" so no conversion happens.

?>

10 years ago

Here is an easy hack to allow double-quoted strings and heredocs to contain arbitrary expressions in curly braces syntax, including constants and other function calls:

// Hack declaration
function_expr($v) (return$v; }
$_expr= "_expr";

// Our playground
define("qwe", "asd");
define("zxc", 5 );

$a= 3 ;
$b= 4 ;

function c($a, $b) (return$a+ $b; }

//Usage
echo"pre{ $_expr(1 + 2 )} post\n"; // outputs "pre 3 post"
echo"pre{ $_expr(qwe)} post\n"; // outputs "pre asd post"
echo"pre{ $_expr(c($a, $b)+ zxc* 2 )} post\n"; // outputs "pre 17 post"

// General syntax is ($_expr(...))
?>

11 years ago

To save Your mind don"t read previous comments about dates ;)

When both strings can be converted to the numerics (in ("$a" > "$b") test) then resulted numerics are used, else FULL strings are compared char-by-char:

var_dump("1.22" > "01.23" ); // bool(false)
var_dump("1.22.00" > "01.23.00" ); //bool(true)
var_dump("1-22-00" > "01-23-00" ); //bool(true)
var_dump((float)"1.22.00" > (float)"01.23.00" ); // bool(false)
?>

2 years ago

I though that it would be helpful to add this comment so that the information at least appears on the right page on the PHP site.

Note that if you intend to use a double-quoted string with an associative key, you may run into the T_ENCAPSED_AND_WHITESPACE error. Some regard this as one of the less obvious error messages.

An expression such as:

$fruit=array(
"a"=> "apple",
"b"=> "banana",
//etc
);

Print "This is a$fruit[ "a"]"; // T_ENCAPSED_AND_WHITESPACE
?>

will definitely fall to pieces.

You can resolve it as follows:

print"This is a$fruit[ a] " ; // unquote the key
print"This is a${ fruit[ "a"]} " ; // Complex Syntax
print"This is a{ $fruit[ "a"]} " ; // Complex Syntax variation
?>

I have a personal preference for the last variation as it is more natural and closer to what the expression would be like outside the string.

It's not clear (to me, at least) why PHP misinterprets the single quote inside the expression but I imagine that it has something to do with the fact quotes are not part of the value string - once the string is already being parsed the quotes just get in the way... ?

Hello dear novice programmers. Let's continue to study the elements that make up.

In this article, we will learn what are php operators. In fact, we have been familiar with some of them almost since childhood, but we only know them as signs (+, -, =, !, ?).

In php, they are all called operators, which is quite logical, since they perform a specific action, or operation.

You could even say that all printable characters that are not a letter or a number are operators in PHP. But that’s not all, since there are operators consisting of letters.

Let's start in order.

Arithmetic operators

Arithmetic operators are used to perform operations on numbers.

+ is the addition operator;
— — subtraction operator;
/ - division operator;
* — multiplication operator;
% is the operator for obtaining the remainder during division;
++ — operator for increasing by one (increment);
— — — decrease by one operator (decrement)

When writing, a space is usually placed before and after the operator. This is done solely for ease of reading the code, although this space does not affect anything, and you can do without it if you wish.

Complex expressions are composed according to the rules accepted in arithmetic, that is, multiplication and division have priority over addition and subtraction, and when both are present in the expression, the latter are enclosed in parentheses.

echo (6 + 7 ) * (7 + 8 );
?>

// 195

When performing the action of dividing an integer by an integer, in case of obtaining a remainder, the result is automatically converted to a real number (floating point number).
?>

echo 8 / 3 ;

//2.66666666666

The number of digits printed for a fractional number depends on the value set in the precision directive found in the php.ini file. Usually this is 12 characters not counting the period.
?>

Operations with arithmetic operators, with the exception of increment and decrement, are called binary, since they involve two operands (term + term, dividend / divisor, etc.)

The actions of increment and decrement are called unary, since they involve one operand. Is there some more conditional operation, which involves three operands.

The increment (++) and decrement (- -) operators apply only to variables.

Variable type integer (whole numbers)

$next = 3 ;
echo +$next;
?>

// 4

Variable type string
$next = "abc";
?>

echo $next;

// abd

The letter "d" is printed instead of the letter "c" because it is next in the alphabet and we increased the value of the variable by one.

The examples show actions with increment, and in the same way you can perform actions with decrement.

Bitwise operators

Bitwise operators are designed to work with binary data. If anyone has no idea what it is, I’ll explain. Binary numbers are numbers like 1001000011100000111000.
Since such data is almost never used in website development, we will not dwell on it in detail. I’ll just show you what they look like, so that when you encounter such symbols you can imagine what you’re dealing with.
& - bitwise connection AND (and);
~ — bitwise negation (not);
<< — сдвиг влево битового значения операнда;
|

— bitwise union OR (or);

^ — bitwise elimination OR (xor);

>> — shift to the right the bit value of the operand;

It is quite likely that you will encounter these operators, since binary data is widely used in the development of computer graphics programs. But to study them, if someone needs it, they will have to take a separate course on another resource.
Comparison Operators
< — оператор меньше;
<= — оператор меньше или равно;
Comparison operators are logical operators and are used to compare variables. Arrays and objects cannot be compared using them.
> - operator greater than;
=> - greater than or equal operator;
== — equality operator;

!= — inequality operator;

=== — equivalence operator (the value and type of the variable are equal);
!== — non-equivalence operator;< 0 ; // пустая строка
As a result of the comparison, either one is displayed on the screen, which corresponds to true (true), or an empty string, which corresponds to false (false).
echo 1 > 0 ;
?>

// 1

echo 1

Conditional operators are so called because they are designed to test a certain condition, depending on which a particular action is performed.

The if statement takes a boolean variable, or expression, as an argument. If the condition is true, the result is displayed, if not true, an empty line is displayed.

if ($next< $nexT)
{
echo "Chance of precipitation"; // Output Precipitation possible
}
?>

$next = "Air humidity 80%";
$nexT = "Air humidity 90%";
if ($next > $nexT)
{
echo "Chance of precipitation"; // Print an empty line
}
?>

If the program needs to specify two actions, one of which will be performed if the value is true, and the other if the value is false, then together with the if statement, the else statement is used

$next = "Air humidity 80%";
$nexT = "Air humidity 90%";
if ($next > $nexT)
{
echo "Chance of precipitation";
}
else
{
echo "No precipitation expected";
}
?>

In this case, “Precipitation is not expected” will be displayed, and if in the expression you change the sign “More” to “Less”, then “Precipitation is possible” will be displayed. This is how conditional operators check a condition and output the correct result according to it.

Very often there is a need to set more than two conditions, and then, to check them sequentially, the elseif operator is used.

if ($next > $nexT)
{
echo "I see";
}
elseif ($next<= $nexT)
{
echo "Snow";
}
elseif ($next >= $nexT)
{
echo "Rain";
}
elseif ($next == $nexT)
{
echo "Drought";
}
else
{
echo "Chance of precipitation";
}
?>

This program will output "Snow". If none of the conditions matched, it would display “Chance of Precipitation.”

An if statement can contain as many elseif blocks as you like, but only one else statement.

An alternative recording option is allowed - without curly braces. In this case, the lines of the if, else, elseif statements end with a colon, and the entire construction ends with the keyword (operator) endif.

$next = "Air humidity 50%";
$nexT = "Air humidity 60%";
if ($next<= $nexT):

echo "Snow";

elseif ($next >= $nexT):

echo "Rain";

elseif ($next == $nexT):

echo "Drought";

else:

echo "Chance of precipitation";
endif ;
?>

Logical operators

Logical operators are similar to bitwise operators. The difference between them is that the former operate with logical variables, and the latter with numbers.

Logical operators are used in cases where you need to combine several conditions, which will reduce the number of if statements, which in turn reduces the likelihood of errors in the code.

&& - connecting conjunction AND;
and - also AND, but with lower priority;
||
- separating conjunction OR;
or - also OR, but with lower priority;
xor - exclusive OR;

!

In the future, using examples of more complex scripts, we will dwell on logical operators in more detail.

Assignment operator

The assignment operator = assigns the value of the right operand to the left operand.

$next = "Hello"
echo "Hello" // Hello
?>

Operator dot

The dot operator separates the integer part of a number from the fractional part, and combines several strings and a number into one whole string.

$next = 22 ;
echo "Today after" .$next. "frost is expected"; // Today after 22 frost is expected
?>

Parentheses operator

As in mathematics, the parentheses operator gives priority to the action enclosed within them.

The data enclosed in parentheses is executed first, and then all the rest.

Curly braces operator

There are three ways, or even styles, of placing curly braces in PHP.

1. BSD style - brackets are aligned to the left.

if ($next)
{

}

2. GNU style - brackets are aligned indented from the left edge

if ($next)
{
echo “Hello dear beginning programmers”;
}

3. K&R style - parenthesis opens on the operator line

if ($next)(
echo “Hello dear beginning programmers”;
}

From the very beginning, you need to choose one of the styles and in the future, when writing scripts, use only it. Moreover, it doesn’t matter at all which style you prefer. It is important that it be uniform throughout the program.

I think that's enough for now. In principle, not only signs, but also functions and other elements can be operators, so it is very difficult to list them all, and there is no point.

It is enough to have an idea of ​​the basic basics. And we will analyze the rest using practical examples.

An Irishman wanders around Sheremetyevo Airport in tears. One of the employees decided to sympathize:
— Do you miss your homeland?
- Not at all. I just lost all my luggage
- How could this happen?
- I don’t understand myself. Looks like I plugged the plug properly