...

...

@@ -1,2808 +1,49 @@

1

1

<?xml version="1.0" encoding="utf-8"?>

2

2

<!-- $Revision$ -->

3

-

<chapter xml:id="language.operators" xmlns="http://docbook.org/ns/docbook">

4

-

<title>Operators</title>

5

-

<simpara>

6

-

An operator is something that takes one or more values (or

7

-

expressions, in programming jargon) and yields another value (so that the

8

-

construction itself becomes an expression).

9

-

</simpara>

10

-

<para>

11

-

Operators can be grouped according to the number of values they take. Unary

12

-

operators take only one value, for example <literal>!</literal> (the

13

-

<link linkend="language.operators.logical">logical not operator</link>) or

14

-

<literal>++</literal> (the

15

-

<link linkend="language.operators.increment">increment operator</link>).

16

-

Binary operators take two values, such as the familiar

17

-

<link linkend="language.operators.arithmetic">arithmetical operators</link>

18

-

<literal>+</literal> (plus) and <literal>-</literal> (minus), and the

19

-

majority of PHP operators fall into this category. Finally, there is a

20

-

single <link linkend="language.operators.comparison.ternary">ternary

21

-

operator</link>, <literal>? :</literal>, which takes three values; this is

22

-

usually referred to simply as "the ternary operator" (although it could

23

-

perhaps more properly be called the conditional operator).

24

-

</para>

25

-

<para>

26

-

A full list of PHP operators follows in the section

27

-

<link linkend="language.operators.precedence">Operator Precedence</link>.

28

-

The section also explains operator precedence and associativity, which govern

29

-

exactly how expressions containing several different operators are

30

-

evaluated.

31

-

</para>

32

-

33

-

<sect1 xml:id="language.operators.precedence">

34

-

<title>Operator Precedence</title>

35

-

<para>

36

-

The precedence of an operator specifies how "tightly" it binds two

37

-

expressions together. For example, in the expression <literal>1 +

38

-

5 * 3</literal>, the answer is <literal>16</literal> and not

39

-

<literal>18</literal> because the multiplication ("*") operator

40

-

has a higher precedence than the addition ("+") operator.

41

-

Parentheses may be used to force precedence, if necessary. For

42

-

instance: <literal>(1 + 5) * 3</literal> evaluates to

43

-

<literal>18</literal>.

44

-

</para>

45

-

<para>

46

-

When operators have equal precedence their associativity decides

47

-

how the operators are grouped. For example "-" is left-associative, so

48

-

<literal>1 - 2 - 3</literal> is grouped as <literal>(1 - 2) - 3</literal>

49

-

and evaluates to <literal>-4</literal>. "=" on the other hand is

50

-

right-associative, so <literal>$a = $b = $c</literal> is grouped as

51

-

<literal>$a = ($b = $c)</literal>.

52

-

</para>

53

-

<para>

54

-

Operators of equal precedence that are non-associative cannot be used

55

-

next to each other, for example <literal>1 &lt; 2 &gt; 1</literal> is

56

-

illegal in PHP. The expression <literal>1 &lt;= 1 == 1</literal> on the

57

-

other hand is legal, because the <literal>==</literal> operator has a lower

58

-

precedence than the <literal>&lt;=</literal> operator.

59

-

</para>

60

-

<para>

61

-

Associativity is only meaningful for binary (and ternary) operators.

62

-

Unary operators are either prefix or postfix so this notion is not applicable.

63

-

For example <literal>!!$a</literal> can only be grouped as <literal>!(!$a)</literal>.

64

-

</para>

65

-

<para>

66

-

Use of parentheses, even when not strictly necessary, can often increase

67

-

readability of the code by making grouping explicit rather than relying

68

-

on the implicit operator precedence and associativity.

69

-

</para>

70

-

<para>

71

-

The following table lists the operators in order of precedence, with

72

-

the highest-precedence ones at the top. Operators on the same line

73

-

have equal precedence, in which case associativity decides grouping.

74

-

<table>

75

-

<title>Operator Precedence</title>

76

-

<tgroup cols="2">

77

-

<thead>

78

-

<row>

79

-

<entry>Associativity</entry>

80

-

<entry>Operators</entry>

81

-

<entry>Additional Information</entry>

82

-

</row>

83

-

</thead>

84

-

<tbody>

85

-

<row>

86

-

<entry>(n/a)</entry>

87

-

<entry>

88

-

<literal>clone</literal>

89

-

<literal>new</literal>

90

-

</entry>

91

-

<entry><link linkend="language.oop5.cloning">clone</link> and <link linkend="language.oop5.basic.new">new</link></entry>

92

-

</row>

93

-

<row>

94

-

<entry>right</entry>

95

-

<entry><literal>**</literal></entry>

96

-

<entry><link linkend="language.operators.arithmetic">arithmetic</link></entry>

97

-

</row>

98

-

<row>

99

-

<entry>(n/a)</entry>

100

-

<entry>

101

-

<literal>+</literal>

102

-

<literal>-</literal>

103

-

<literal>++</literal>

104

-

<literal>--</literal>

105

-

<literal>~</literal>

106

-

<literal>(int)</literal>

107

-

<literal>(float)</literal>

108

-

<literal>(string)</literal>

109

-

<literal>(array)</literal>

110

-

<literal>(object)</literal>

111

-

<literal>(bool)</literal>

112

-

<literal>@</literal>

113

-

</entry>

114

-

<entry>

115

-

<link linkend="language.operators.arithmetic">arithmetic</link> (unary <literal>+</literal> and <literal>-</literal>),

116

-

<link linkend="language.operators.increment">increment/decrement</link>,

117

-

<link linkend="language.operators.bitwise">bitwise</link>,

118

-

<link linkend="language.types.typecasting">type casting</link>&listendand;

119

-

<link linkend="language.operators.errorcontrol">error control</link>

120

-

</entry>

121

-

</row>

122

-

<row>

123

-

<entry>left</entry>

124

-

<entry><literal>instanceof</literal></entry>

125

-

<entry>

126

-

<link linkend="language.operators.type">type</link>

127

-

</entry>

128

-

</row>

129

-

<row>

130

-

<entry>(n/a)</entry>

131

-

<entry><literal>!</literal></entry>

132

-

<entry>

133

-

<link linkend="language.operators.logical">logical</link>

134

-

</entry>

135

-

</row>

136

-

<row>

137

-

<entry>left</entry>

138

-

<entry>

139

-

<literal>*</literal>

140

-

<literal>/</literal>

141

-

<literal>%</literal>

142

-

</entry>

143

-

<entry>

144

-

<link linkend="language.operators.arithmetic">arithmetic</link>

145

-

</entry>

146

-

</row>

147

-

<row>

148

-

<entry>left</entry>

149

-

<entry>

150

-

<literal>+</literal>

151

-

<literal>-</literal>

152

-

<literal>.</literal>

153

-

</entry>

154

-

<entry>

155

-

<link linkend="language.operators.arithmetic">arithmetic</link> (binary <literal>+</literal> and <literal>-</literal>),

156

-

<link linkend="language.operators.array">array</link>&listendand;

157

-

<link linkend="language.operators.string">string</link> (<literal>.</literal> prior to PHP 8.0.0)

158

-

</entry>

159

-

</row>

160

-

<row>

161

-

<entry>left</entry>

162

-

<entry>

163

-

<literal>&lt;&lt;</literal>

164

-

<literal>&gt;&gt;</literal>

165

-

</entry>

166

-

<entry>

167

-

<link linkend="language.operators.bitwise">bitwise</link>

168

-

</entry>

169

-

</row>

170

-

<row>

171

-

<entry>left</entry>

172

-

<entry><literal>.</literal></entry>

173

-

<entry>

174

-

<link linkend="language.operators.string">string</link> (as of PHP 8.0.0)

175

-

</entry>

176

-

</row>

177

-

<row>

178

-

<entry>non-associative</entry>

179

-

<entry>

180

-

<literal>&lt;</literal>

181

-

<literal>&lt;=</literal>

182

-

<literal>&gt;</literal>

183

-

<literal>&gt;=</literal>

184

-

</entry>

185

-

<entry>

186

-

<link linkend="language.operators.comparison">comparison</link>

187

-

</entry>

188

-

</row>

189

-

<row>

190

-

<entry>non-associative</entry>

191

-

<entry>

192

-

<literal>==</literal>

193

-

<literal>!=</literal>

194

-

<literal>===</literal>

195

-

<literal>!==</literal>

196

-

<literal>&lt;&gt;</literal>

197

-

<literal>&lt;=&gt;</literal>

198

-

</entry>

199

-

<entry>

200

-

<link linkend="language.operators.comparison">comparison</link>

201

-

</entry>

202

-

</row>

203

-

<row>

204

-

<entry>left</entry>

205

-

<entry><literal>&amp;</literal></entry>

206

-

<entry>

207

-

<link linkend="language.operators.bitwise">bitwise</link>&listendand;

208

-

<link linkend="language.references">references</link></entry>

209

-

</row>

210

-

<row>

211

-

<entry>left</entry>

212

-

<entry><literal>^</literal></entry>

213

-

<entry>

214

-

<link linkend="language.operators.bitwise">bitwise</link>

215

-

</entry>

216

-

</row>

217

-

<row>

218

-

<entry>left</entry>

219

-

<entry><literal>|</literal></entry>

220

-

<entry>

221

-

<link linkend="language.operators.bitwise">bitwise</link>

222

-

</entry>

223

-

</row>

224

-

<row>

225

-

<entry>left</entry>

226

-

<entry><literal>&amp;&amp;</literal></entry>

227

-

<entry>

228

-

<link linkend="language.operators.logical">logical</link>

229

-

</entry>

230

-

</row>

231

-

<row>

232

-

<entry>left</entry>

233

-

<entry><literal>||</literal></entry>

234

-

<entry>

235

-

<link linkend="language.operators.logical">logical</link>

236

-

</entry>

237

-

</row>

238

-

<row>

239

-

<entry>right</entry>

240

-

<entry><literal>??</literal></entry>

241

-

<entry>

242

-

<link linkend="language.operators.comparison.coalesce">null coalescing</link>

243

-

</entry>

244

-

</row>

245

-

<row>

246

-

<entry>non-associative</entry>

247

-

<entry><literal>? :</literal></entry>

248

-

<entry>

249

-

<link linkend="language.operators.comparison.ternary">ternary</link>

250

-

(left-associative prior to PHP 8.0.0)

251

-

</entry>

252

-

</row>

253

-

<row>

254

-

<entry>right</entry>

255

-

<entry>

256

-

<literal>=</literal>

257

-

<literal>+=</literal>

258

-

<literal>-=</literal>

259

-

<literal>*=</literal>

260

-

<literal>**=</literal>

261

-

<literal>/=</literal>

262

-

<literal>.=</literal>

263

-

<literal>%=</literal>

264

-

<literal>&amp;=</literal>

265

-

<literal>|=</literal>

266

-

<literal>^=</literal>

267

-

<literal>&lt;&lt;=</literal>

268

-

<literal>&gt;&gt;=</literal>

269

-

<literal>??=</literal>

270

-

</entry>

271

-

<entry>

272

-

<link linkend="language.operators.assignment">assignment</link>

273

-

</entry>

274

-

</row>

275

-

<row>

276

-

<entry>(n/a)</entry>

277

-

<entry><literal>yield from</literal></entry>

278

-

<entry>

279

-

<link linkend="control-structures.yield.from">yield from</link>

280

-

</entry>

281

-

</row>

282

-

<row>

283

-

<entry>(n/a)</entry>

284

-

<entry><literal>yield</literal></entry>

285

-

<entry>

286

-

<link linkend="control-structures.yield">yield</link>

287

-

</entry>

288

-

</row>

289

-

<row>

290

-

<entry>(n/a)</entry>

291

-

<entry><literal>print</literal></entry>

292

-

<entry><function>print</function></entry>

293

-

</row>

294

-

<row>

295

-

<entry>left</entry>

296

-

<entry><literal>and</literal></entry>

297

-

<entry>

298

-

<link linkend="language.operators.logical">logical</link>

299

-

</entry>

300

-

</row>

301

-

<row>

302

-

<entry>left</entry>

303

-

<entry><literal>xor</literal></entry>

304

-

<entry>

305

-

<link linkend="language.operators.logical">logical</link>

306

-

</entry>

307

-

</row>

308

-

<row>

309

-

<entry>left</entry>

310

-

<entry><literal>or</literal></entry>

311

-

<entry>

312

-

<link linkend="language.operators.logical">logical</link>

313

-

</entry>

314

-

</row>

315

-

</tbody>

316

-

</tgroup>

317

-

</table>

318

-

</para>

319

-

<para>

320

-

<example>

321

-

<title>Associativity</title>

322

-

<programlisting role="php">

323

-

<![CDATA[

324

-

<?php

325

-

$a = 3 * 3 % 5; // (3 * 3) % 5 = 4

326

-

// ternary operator associativity differs from C/C++

327

-

$a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2 (prior to PHP 8.0.0)

328

-

329

-

$a = 1;

330

-

$b = 2;

331

-

$a = $b += 3; // $a = ($b += 3) -> $a = 5, $b = 5

332

-

?>

333

-

]]>

334

-

</programlisting>

335

-

</example>

336

-

</para>

337

-

<para>

338

-

Operator precedence and associativity only determine how expressions

339

-

are grouped, they do not specify an order of evaluation. PHP does not

340

-

(in the general case) specify in which order an expression is evaluated

341

-

and code that assumes a specific order of evaluation should be avoided,

342

-

because the behavior can change between versions of PHP or depending on

343

-

the surrounding code.

344

-

<example>

345

-

<title>Undefined order of evaluation</title>

346

-

<programlisting role="php">

347

-

<![CDATA[

348

-

<?php

349

-

$a = 1;

350

-

echo $a + $a++; // may print either 2 or 3

351

-

352

-

$i = 1;

353

-

$array[$i] = $i++; // may set either index 1 or 2

354

-

?>

355

-

]]>

356

-

</programlisting>

357

-

</example>

358

-

<example>

359

-

<title><literal>+</literal>, <literal>-</literal> and <literal>.</literal> have the same precedence (prior to PHP 8.0.0)</title>

360

-

<programlisting role="php">

361

-

<![CDATA[

362

-

<?php

363

-

$x = 4;

364

-

// this line might result in unexpected output:

365

-

echo "x minus one equals " . $x-1 . ", or so I hope\n";

366

-

// because it is evaluated like this line (prior to PHP 8.0.0):

367

-

echo (("x minus one equals " . $x) - 1) . ", or so I hope\n";

368

-

// the desired precedence can be enforced by using parentheses:

369

-

echo "x minus one equals " . ($x-1) . ", or so I hope\n";

370

-

?>

371

-

]]>

372

-

</programlisting>

373

-

&example.outputs;

374

-

<screen>

375

-

<![CDATA[

376

-

-1, or so I hope

377

-

-1, or so I hope

378

-

x minus one equals 3, or so I hope

379

-

]]>

380

-

</screen>

381

-

</example>

382

-

</para>

383

-

<note>

384

-

<para>

385

-

Although <literal>=</literal> has a lower precedence than

386

-

most other operators, PHP will still allow expressions

387

-

similar to the following: <literal>if (!$a = foo())</literal>,

388

-

in which case the return value of <literal>foo()</literal> is

389

-

put into <varname>$a</varname>.

390

-

</para>

391

-

</note>

392

-

<sect2 role="changelog">

393

-

&reftitle.changelog;

394

-

<informaltable>

395

-

<tgroup cols="2">

396

-

<thead>

397

-

<row>

398

-

<entry>&Version;</entry>

399

-

<entry>&Description;</entry>

400

-

</row>

401

-

</thead>

402

-

<tbody>

403

-

<row>

404

-

<entry>8.0.0</entry>

405

-

<entry>

406

-

String concatenation (<literal>.</literal>) now has a lower precedence than

407

-

arithmetic addition/subtraction (<literal>+</literal> and <literal>-</literal>) and

408

-

bitwise shift left/right (<literal>&lt;&lt;</literal> and <literal>&gt;&gt;</literal>);

409

-

previously it had the same precedence as <literal>+</literal> and <literal>-</literal>

410

-

and a higher precedence than <literal>&lt;&lt;</literal> and <literal>&gt;&gt;</literal>.

411

-

</entry>

412

-

</row>

413

-

<row>

414

-

<entry>8.0.0</entry>

415

-

<entry>

416

-

The ternary operator (<literal>? :</literal>) is non-associative now;

417

-

previously it was left-associative.

418

-

</entry>

419

-

</row>

420

-

<row>

421

-

<entry>7.4.0</entry>

422

-

<entry>

423

-

Relying on the precedence of string concatenation (<literal>.</literal>) relative to

424

-

arithmetic addition/subtraction (<literal>+</literal> or <literal>-</literal>) or

425

-

bitwise shift left/right (<literal>&lt;&lt;</literal> or <literal>&gt;&gt;</literal>),

426

-

i.e. using them together in an unparenthesized expression, is deprecated.

427

-

</entry>

428

-

</row>

429

-

<row>

430

-

<entry>7.4.0</entry>

431

-

<entry>

432

-

Relying on left-associativity of the ternary operator (<literal>? :</literal>),

433

-

i.e. nesting multiple unparenthesized ternary operators, is deprecated.

434

-

</entry>

435

-

</row>

436

-

</tbody>

437

-

</tgroup>

438

-

</informaltable>

439

-

</sect2>

440

-

</sect1>

441

-

442

-

<sect1 xml:id="language.operators.arithmetic">

443

-

<title>Arithmetic Operators</title>

444

-

<simpara>

445

-

Remember basic arithmetic from school? These work just

446

-

like those.

447

-

</simpara>

448

-

<table>

449

-

<title>Arithmetic Operators</title>

450

-

<tgroup cols="3">

451

-

<thead>

452

-

<row>

453

-

<entry>Example</entry>

454

-

<entry>Name</entry>

455

-

<entry>Result</entry>

456

-

</row>

457

-

</thead>

458

-

<tbody>

459

-

<row>

460

-

<entry>+$a</entry>

461

-

<entry>Identity</entry>

462

-

<entry>

463

-

Conversion of <varname>$a</varname> to <type>int</type> or

464

-

<type>float</type> as appropriate.

465

-

</entry>

466

-

</row>

467

-

<row>

468

-

<entry>-$a</entry>

469

-

<entry>Negation</entry>

470

-

<entry>Opposite of <varname>$a</varname>.</entry>

471

-

</row>

472

-

<row>

473

-

<entry>$a + $b</entry>

474

-

<entry>Addition</entry>

475

-

<entry>Sum of <varname>$a</varname> and <varname>$b</varname>.</entry>

476

-

</row>

477

-

<row>

478

-

<entry>$a - $b</entry>

479

-

<entry>Subtraction</entry>

480

-

<entry>Difference of <varname>$a</varname> and <varname>$b</varname>.</entry>

481

-

</row>

482

-

<row>

483

-

<entry>$a * $b</entry>

484

-

<entry>Multiplication</entry>

485

-

<entry>Product of <varname>$a</varname> and <varname>$b</varname>.</entry>

486

-

</row>

487

-

<row>

488

-

<entry>$a / $b</entry>

489

-

<entry>Division</entry>

490

-

<entry>Quotient of <varname>$a</varname> and <varname>$b</varname>.</entry>

491

-

</row>

492

-

<row>

493

-

<entry>$a % $b</entry>

494

-

<entry>Modulo</entry>

495

-

<entry>Remainder of <varname>$a</varname> divided by <varname>$b</varname>.</entry>

496

-

</row>

497

-

<row>

498

-

<entry>$a ** $b</entry>

499

-

<entry>Exponentiation</entry>

500

-

<entry>Result of raising <varname>$a</varname> to the <varname>$b</varname>'th power.</entry>

501

-

</row>

502

-

</tbody>

503

-

</tgroup>

504

-

</table>

505

-

<simpara>

506

-

The division operator ("/") returns a float value unless the two operands

507

-

are integers (or strings that get converted to integers) and the numbers

508

-

are evenly divisible, in which case an integer value will be returned. For

509

-

integer division, see <function>intdiv</function>.

510

-

</simpara>

511

-

<simpara>

512

-

Operands of modulo are converted to <type>int</type>

513

-

before processing. For floating-point modulo, see

514

-

<function>fmod</function>.

515

-

</simpara>

516

-

<para>

517

-

The result of the modulo operator <literal>%</literal> has the same sign

518

-

as the dividend — that is, the result of <literal>$a % $b</literal>

519

-

will have the same sign as <varname>$a</varname>. For example:

520

-

<informalexample>

521

-

<programlisting role="php">

522

-

<![CDATA[

523

-

<?php

524

-

525

-

echo (5 % 3)."\n"; // prints 2

526

-

echo (5 % -3)."\n"; // prints 2

527

-

echo (-5 % 3)."\n"; // prints -2

528

-

echo (-5 % -3)."\n"; // prints -2

529

-

530

-

?>

531

-

]]>

532

-

</programlisting>

533

-

</informalexample>

534

-

</para>

535

-

<sect2 role="seealso">

536

-

&reftitle.seealso;

537

-

<para>

538

-

<simplelist>

539

-

<member><link linkend="ref.math">Math functions</link></member>

540

-

</simplelist>

541

-

</para>

542

-

</sect2>

543

-

</sect1>

544

-

545

-

<sect1 xml:id="language.operators.assignment">

546

-

<title>Assignment Operators</title>

547

-

<simpara>

548

-

The basic assignment operator is "=". Your first inclination might

549

-

be to think of this as "equal to". Don't. It really means that the

550

-

left operand gets set to the value of the expression on the

551

-

right (that is, "gets set to").

552

-

</simpara>

553

-

<para>

554

-

The value of an assignment expression is the value assigned. That

555

-

is, the value of "<literal>$a = 3</literal>" is 3. This allows you to do some tricky

556

-

things:

557

-

<informalexample>

558

-

<programlisting role="php">

559

-

<![CDATA[

560

-

<?php

561

-

562

-

$a = ($b = 4) + 5; // $a is equal to 9 now, and $b has been set to 4.

563

-

564

-

?>

565

-

]]>

566

-

</programlisting>

567

-

</informalexample>

568

-

</para>

569

-

<para>

570

-

In addition to the basic assignment operator, there are "combined

571

-

operators" for all of the <link linkend="language.operators">binary

572

-

arithmetic</link>, array union and string operators that allow you to use a value in an

573

-

expression and then set its value to the result of that expression. For

574

-

example:

575

-

<informalexample>

576

-

<programlisting role="php">

577

-

<![CDATA[

578

-

<?php

579

-

580

-

$a = 3;

581

-

$a += 5; // sets $a to 8, as if we had said: $a = $a + 5;

582

-

$b = "Hello ";

583

-

$b .= "There!"; // sets $b to "Hello There!", just like $b = $b . "There!";

584

-

585

-

?>

586

-

]]>

587

-

</programlisting>

588

-

</informalexample>

589

-

</para>

590

-

<para>

591

-

Note that the assignment copies the original variable to the new

592

-

one (assignment by value), so changes to one will not affect the

593

-

other. This may also have relevance if you need to copy something

594

-

like a large array inside a tight loop.

595

-

</para>

596

-

<para>

597

-

An exception to the usual assignment by value behaviour within PHP occurs

598

-

with <type>object</type>s, which are assigned by reference.

599

-

Objects may be explicitly copied via the <link

600

-

linkend="language.oop5.cloning">clone</link> keyword.

601

-

</para>

602

-

603

-

<sect2 xml:id="language.operators.assignment.reference">

604

-

<title>Assignment by Reference</title>

605

-

<para>

606

-

Assignment by reference is also supported, using the

607

-

"<computeroutput>$var = &amp;$othervar;</computeroutput>" syntax.

608

-

Assignment by reference means that both variables end up pointing at the

609

-

same data, and nothing is copied anywhere.

610

-

</para>

611

-

<para>

612

-

<example>

613

-

<title>Assigning by reference</title>

614

-

<programlisting role="php">

615

-

<![CDATA[

616

-

<?php

617

-

$a = 3;

618

-

$b = &$a; // $b is a reference to $a

619

-

620

-

print "$a\n"; // prints 3

621

-

print "$b\n"; // prints 3

622

-

623

-

$a = 4; // change $a

624

-

625

-

print "$a\n"; // prints 4

626

-

print "$b\n"; // prints 4 as well, since $b is a reference to $a, which has

627

-

// been changed

628

-

?>

629

-

]]>

630

-

</programlisting>

631

-

</example>

632

-

</para>

633

-

<para>

634

-

The <link linkend="language.oop5.basic.new">new</link>

635

-

operator returns a reference automatically, as such assigning the result of

636

-

<link linkend="language.oop5.basic.new">new</link> by reference is an error.

637

-

</para>

638

-

<para>

639

-

<informalexample>

640

-

<programlisting role="php">

641

-

<![CDATA[

642

-

<?php

643

-

class C {}

644

-

645

-

$o = &new C;

646

-

?>

647

-

]]>

648

-

</programlisting>

649

-

&example.outputs;

650

-

<screen>

651

-

<![CDATA[

652

-

Parse error: syntax error, unexpected 'new' (T_NEW) in …

653

-

]]>

654

-

</screen>

655

-

</informalexample>

656

-

</para>

657

-

<para>

658

-

More information on references and their potential uses can be found in

659

-

the <link linkend="language.references">References Explained</link>

660

-

section of the manual.

661

-

</para>

662

-

</sect2>

663

-

664

-

<sect2 xml:id="language.operators.assignment.arithmetic">

665

-

<title>Arithmetic Assignment Operators</title>

666

-

<informaltable>

667

-

<tgroup cols="3">

668

-

<thead>

669

-

<row>

670

-

<entry>Example</entry>

671

-

<entry>Equivalent</entry>

672

-

<entry>Operation</entry>

673

-

</row>

674

-

</thead>

675

-

<tbody>

676

-

<row>

677

-

<entry>$a += $b</entry>

678

-

<entry>$a = $a + $b</entry>

679

-

<entry>Addition</entry>

680

-

</row>

681

-

<row>

682

-

<entry>$a -= $b</entry>

683

-

<entry>$a = $a - $b</entry>

684

-

<entry>Subtraction</entry>

685

-

</row>

686

-

<row>

687

-

<entry>$a *= $b</entry>

688

-

<entry>$a = $a * $b</entry>

689

-

<entry>Multiplication</entry>

690

-

</row>

691

-

<row>

692

-

<entry>$a /= $b</entry>

693

-

<entry>$a = $a / $b</entry>

694

-

<entry>Division</entry>

695

-

</row>

696

-

<row>

697

-

<entry>$a %= $b</entry>

698

-

<entry>$a = $a % $b</entry>

699

-

<entry>Modulus</entry>

700

-

</row>

701

-

<row>

702

-

<entry>$a **= $b</entry>

703

-

<entry>$a = $a ** $b</entry>

704

-

<entry>Exponentiation</entry>

705

-

</row>

706

-

</tbody>

707

-

</tgroup>

708

-

</informaltable>

709

-

</sect2>

710

-

711

-

<sect2 xml:id="language.operators.assignment.bitwise">

712

-

<title>Bitwise Assignment Operators</title>

713

-

<informaltable>

714

-

<tgroup cols="3">

715

-

<thead>

716

-

<row>

717

-

<entry>Example</entry>

718

-

<entry>Equivalent</entry>

719

-

<entry>Operation</entry>

720

-

</row>

721

-

</thead>

722

-

<tbody>

723

-

<row>

724

-

<entry>$a &amp;= $b</entry>

725

-

<entry>$a = $a &amp; $b</entry>

726

-

<entry>Bitwise And</entry>

727

-

</row>

728

-

<row>

729

-

<entry>$a |= $b</entry>

730

-

<entry>$a = $a | $b</entry>

731

-

<entry>Bitwise Or</entry>

732

-

</row>

733

-

<row>

734

-

<entry>$a ^= $b</entry>

735

-

<entry>$a = $a ^ $b</entry>

736

-

<entry>Bitwise Xor</entry>

737

-

</row>

738

-

<row>

739

-

<entry>$a &lt;&lt;= $b</entry>

740

-

<entry>$a = $a &lt;&lt; $b</entry>

741

-

<entry>Left Shift</entry>

742

-

</row>

743

-

<row>

744

-

<entry>$a &gt;&gt;= $b</entry>

745

-

<entry>$a = $a &gt;&gt; $b</entry>

746

-

<entry>Right Shift</entry>

747

-

</row>

748

-

</tbody>

749

-

</tgroup>

750

-

</informaltable>

751

-

</sect2>

752

-

753

-

<sect2 xml:id="language.operators.assignment.other">

754

-

<title>Other Assignment Operators</title>

755

-

<informaltable>

756

-

<tgroup cols="3">

757

-

<thead>

758

-

<row>

759

-

<entry>Example</entry>

760

-

<entry>Equivalent</entry>

761

-

<entry>Operation</entry>

762

-

</row>

763

-

</thead>

764

-

<tbody>

765

-

<row>

766

-

<entry>$a .= $b</entry>

767

-

<entry>$a = $a . $b</entry>

768

-

<entry>String Concatenation</entry>

769

-

</row>

770

-

<row>

771

-

<entry>$a ??= $b</entry>

772

-

<entry>$a = $a ?? $b</entry>

773

-

<entry>Null Coalesce</entry>

774

-

</row>

775

-

</tbody>

776

-

</tgroup>

777

-

</informaltable>

778

-

</sect2>

779

-

780

-

<sect2 role="seealso" xml:id="language.operators.assignment.see-also">

781

-

&reftitle.seealso;

782

-

<para>

783

-

<simplelist>

784

-

<member><link linkend="language.operators.arithmetic">arithmetic operators</link></member>

785

-

<member><link linkend="language.operators.bitwise">bitwise operators</link></member>

786

-

<member><link linkend="language.operators.comparison.coalesce">null coalescing operator</link></member>

787

-

</simplelist>

788

-

</para>

789

-

</sect2>

790

-

</sect1>

791

-

792

-

<sect1 xml:id="language.operators.bitwise">

793

-

<title>Bitwise Operators</title>

794

-

<simpara>

795

-

Bitwise operators allow evaluation and manipulation of specific

796

-

bits within an integer.

797

-

</simpara>

798

-

<table>

799

-

<title>Bitwise Operators</title>

800

-

<tgroup cols="3">

801

-

<thead>

802

-

<row>

803

-

<entry>Example</entry>

804

-

<entry>Name</entry>

805

-

<entry>Result</entry>

806

-

</row>

807

-

</thead>

808

-

<tbody>

809

-

<row>

810

-

<entry><userinput>$a &amp; $b</userinput></entry>

811

-

<entry>And</entry>

812

-

<entry>Bits that are set in both <varname>$a</varname> and <varname>$b</varname> are set.</entry>

813

-

</row>

814

-

<row>

815

-

<entry><userinput>$a | $b</userinput></entry>

816

-

<entry>Or (inclusive or)</entry>

817

-

<entry>Bits that are set in either <varname>$a</varname> or <varname>$b</varname> are set.</entry>

818

-

</row>

819

-

<row>

820

-

<entry><userinput>$a ^ $b</userinput></entry>

821

-

<entry>Xor (exclusive or)</entry>

822

-

<entry>

823

-

Bits that are set in <varname>$a</varname> or <varname>$b</varname> but not both are set.

824

-

</entry>

825

-

</row>

826

-

<row>

827

-

<entry><userinput>~ $a</userinput></entry>

828

-

<entry>Not</entry>

829

-

<entry>

830

-

Bits that are set in <varname>$a</varname> are not set, and vice versa.

831

-

</entry>

832

-

</row>

833

-

<row>

834

-

<entry><userinput>$a &lt;&lt; $b</userinput></entry>

835

-

<entry>Shift left</entry>

836

-

<entry>

837

-

Shift the bits of <varname>$a</varname> <varname>$b</varname> steps to the left (each step means

838

-

"multiply by two")

839

-

</entry>

840

-

</row>

841

-

<row>

842

-

<entry><userinput>$a &gt;&gt; $b</userinput></entry>

843

-

<entry>Shift right</entry>

844

-

<entry>

845

-

Shift the bits of <varname>$a</varname> <varname>$b</varname> steps to the right (each step means

846

-

"divide by two")

847

-

</entry>

848

-

</row>

849

-

</tbody>

850

-

</tgroup>

851

-

</table>

852

-

<para>

853

-

Bit shifting in PHP is arithmetic.

854

-

Bits shifted off either end are discarded.

855

-

Left shifts have zeros shifted in on the right while the sign

856

-

bit is shifted out on the left, meaning the sign of an operand

857

-

is not preserved.

858

-

Right shifts have copies of the sign bit shifted in on the left,

859

-

meaning the sign of an operand is preserved.

860

-

</para>

861

-

<para>

862

-

Use parentheses to ensure the desired

863

-

<link linkend="language.operators.precedence">precedence</link>.

864

-

For example, <literal>$a &amp; $b == true</literal> evaluates

865

-

the equivalency then the bitwise and; while

866

-

<literal>($a &amp; $b) == true</literal> evaluates the bitwise and

867

-

then the equivalency.

868

-

</para>

869

-

<para>

870

-

If both operands for the <literal>&amp;</literal>, <literal>|</literal> and

871

-

<literal>^</literal> operators are strings, then the operation will be

872

-

performed on the ASCII values of the characters that make up the strings and

873

-

the result will be a string. In all other cases, both operands will be

874

-

<link linkend="language.types.integer.casting">converted to integers</link>

875

-

and the result will be an integer.

876

-

</para>

877

-

<para>

878

-

If the operand for the <literal>~</literal> operator is a string, the

879

-

operation will be performed on the ASCII values of the characters that make

880

-

up the string and the result will be a string, otherwise the operand and the

881

-

result will be treated as integers.

882

-

</para>

883

-

<para>

884

-

Both operands and the result for the <literal>&lt;&lt;</literal> and

885

-

<literal>&gt;&gt;</literal> operators are always treated as integers.

886

-

</para>

887

-

<para>

888

-

<informalexample>

889

-

<para>

890

-

<literallayout>

891

-

PHP's error_reporting ini setting uses bitwise values,

892

-

providing a real-world demonstration of turning

893

-

bits off. To show all errors, except for notices,

894

-

the php.ini file instructions say to use:

895

-

<userinput>E_ALL &amp; ~E_NOTICE</userinput>

896

-

</literallayout>

897

-

</para>

898

-

<para>

899

-

<literallayout>

900

-

This works by starting with E_ALL:

901

-

<computeroutput>00000000000000000111011111111111</computeroutput>

902

-

Then taking the value of E_NOTICE...

903

-

<computeroutput>00000000000000000000000000001000</computeroutput>

904

-

... and inverting it via <literal>~</literal>:

905

-

<computeroutput>11111111111111111111111111110111</computeroutput>

906

-

Finally, it uses AND (&amp;) to find the bits turned

907

-

on in both values:

908

-

<computeroutput>00000000000000000111011111110111</computeroutput>

909

-

</literallayout>

910

-

</para>

911

-

<para>

912

-

<literallayout>

913

-

Another way to accomplish that is using XOR (<literal>^</literal>)

914

-

to find bits that are on in only one value or the other:

915

-

<userinput>E_ALL ^ E_NOTICE</userinput>

916

-

</literallayout>

917

-

</para>

918

-

</informalexample>

919

-

</para>

920

-

<para>

921

-

<informalexample>

922

-

<para>

923

-

<literallayout>

924

-

error_reporting can also be used to demonstrate turning bits on.

925

-

The way to show just errors and recoverable errors is:

926

-

<userinput>E_ERROR | E_RECOVERABLE_ERROR</userinput>

927

-

</literallayout>

928

-

</para>

929

-

<para>

930

-

<literallayout>

931

-

This process combines E_ERROR

932

-

<computeroutput>00000000000000000000000000000001</computeroutput>

933

-

and

934

-

<computeroutput>00000000000000000001000000000000</computeroutput>

935

-

using the OR (<literal>|</literal>) operator

936

-

to get the bits turned on in either value:

937

-

<computeroutput>00000000000000000001000000000001</computeroutput>

938

-

</literallayout>

939

-

</para>

940

-

</informalexample>

941

-

</para>

942

-

<para>

943

-

<example>

944

-

<title>Bitwise AND, OR and XOR operations on integers</title>

945

-

<programlisting role="php">

946

-

<![CDATA[

947

-

<?php

948

-

/*

949

-

* Ignore the top section,

950

-

* it is just formatting to make output clearer.

951

-

*/

952

-

953

-

$format = '(%1$2d = %1$04b) = (%2$2d = %2$04b)'

954

-

. ' %3$s (%4$2d = %4$04b)' . "\n";

955

-

956

-

echo <<<EOH

957

-

--------- --------- -- ---------

958

-

result value op test

959

-

--------- --------- -- ---------

960

-

EOH;

961

-

962

-

963

-

/*

964

-

* Here are the examples.

965

-

*/

966

-

967

-

$values = array(0, 1, 2, 4, 8);

968

-

$test = 1 + 4;

969

-

970

-

echo "\n Bitwise AND \n";

971

-

foreach ($values as $value) {

972

-

$result = $value & $test;

973

-

printf($format, $result, $value, '&', $test);

974

-

}

975

-

976

-

echo "\n Bitwise Inclusive OR \n";

977

-

foreach ($values as $value) {

978

-

$result = $value | $test;

979

-

printf($format, $result, $value, '|', $test);

980

-

}

981

-

982

-

echo "\n Bitwise Exclusive OR (XOR) \n";

983

-

foreach ($values as $value) {

984

-

$result = $value ^ $test;

985

-

printf($format, $result, $value, '^', $test);

986

-

}

987

-

?>

988

-

]]>

989

-

</programlisting>

990

-

&example.outputs;

991

-

<screen>

992

-

<![CDATA[

993

-

--------- --------- -- ---------

994

-

result value op test

995

-

--------- --------- -- ---------

996

-

Bitwise AND

997

-

( 0 = 0000) = ( 0 = 0000) & ( 5 = 0101)

998

-

( 1 = 0001) = ( 1 = 0001) & ( 5 = 0101)

999

-

( 0 = 0000) = ( 2 = 0010) & ( 5 = 0101)

1000

-

( 4 = 0100) = ( 4 = 0100) & ( 5 = 0101)

1001

-

( 0 = 0000) = ( 8 = 1000) & ( 5 = 0101)

1002

-

1003

-

Bitwise Inclusive OR

1004

-

( 5 = 0101) = ( 0 = 0000) | ( 5 = 0101)

1005

-

( 5 = 0101) = ( 1 = 0001) | ( 5 = 0101)

1006

-

( 7 = 0111) = ( 2 = 0010) | ( 5 = 0101)

1007

-

( 5 = 0101) = ( 4 = 0100) | ( 5 = 0101)

1008

-

(13 = 1101) = ( 8 = 1000) | ( 5 = 0101)

1009

-

1010

-

Bitwise Exclusive OR (XOR)

1011

-

( 5 = 0101) = ( 0 = 0000) ^ ( 5 = 0101)

1012

-

( 4 = 0100) = ( 1 = 0001) ^ ( 5 = 0101)

1013

-

( 7 = 0111) = ( 2 = 0010) ^ ( 5 = 0101)

1014

-

( 1 = 0001) = ( 4 = 0100) ^ ( 5 = 0101)

1015

-

(13 = 1101) = ( 8 = 1000) ^ ( 5 = 0101)

1016

-

]]>

1017

-

</screen>

1018

-

</example>

1019

-

</para>

1020

-

<para>

1021

-

<example>

1022

-

<title>Bitwise XOR operations on strings</title>

1023

-

<programlisting role="php">

1024

-

<![CDATA[

1025

-

<?php

1026

-

echo 12 ^ 9; // Outputs '5'

1027

-

1028

-

echo "12" ^ "9"; // Outputs the Backspace character (ascii 8)

1029

-

// ('1' (ascii 49)) ^ ('9' (ascii 57)) = #8

1030

-

1031

-

echo "hallo" ^ "hello"; // Outputs the ascii values #0 #4 #0 #0 #0

1032

-

// 'a' ^ 'e' = #4

1033

-

1034

-

echo 2 ^ "3"; // Outputs 1

1035

-

// 2 ^ ((int)"3") == 1

1036

-

1037

-

echo "2" ^ 3; // Outputs 1

1038

-

// ((int)"2") ^ 3 == 1

1039

-

?>

1040

-

]]>

1041

-

</programlisting>

1042

-

</example>

1043

-

</para>

1044

-

<para>

1045

-

<example>

1046

-

<title>Bit shifting on integers</title>

1047

-

<programlisting role="php">

1048

-

<![CDATA[

1049

-

<?php

1050

-

/*

1051

-

* Here are the examples.

1052

-

*/

1053

-

1054

-

echo "\n--- BIT SHIFT RIGHT ON POSITIVE INTEGERS ---\n";

1055

-

1056

-

$val = 4;

1057

-

$places = 1;

1058

-

$res = $val >> $places;

1059

-

p($res, $val, '>>', $places, 'copy of sign bit shifted into left side');

1060

-

1061

-

$val = 4;

1062

-

$places = 2;

1063

-

$res = $val >> $places;

1064

-

p($res, $val, '>>', $places);

1065

-

1066

-

$val = 4;

1067

-

$places = 3;

1068

-

$res = $val >> $places;

1069

-

p($res, $val, '>>', $places, 'bits shift out right side');

1070

-

1071

-

$val = 4;

1072

-

$places = 4;

1073

-

$res = $val >> $places;

1074

-

p($res, $val, '>>', $places, 'same result as above; can not shift beyond 0');

1075

-

1076

-

1077

-

echo "\n--- BIT SHIFT RIGHT ON NEGATIVE INTEGERS ---\n";

1078

-

1079

-

$val = -4;

1080

-

$places = 1;

1081

-

$res = $val >> $places;

1082

-

p($res, $val, '>>', $places, 'copy of sign bit shifted into left side');

1083

-

1084

-

$val = -4;

1085

-

$places = 2;

1086

-

$res = $val >> $places;

1087

-

p($res, $val, '>>', $places, 'bits shift out right side');

1088

-

1089

-

$val = -4;

1090

-

$places = 3;

1091

-

$res = $val >> $places;

1092

-

p($res, $val, '>>', $places, 'same result as above; can not shift beyond -1');

1093

-

1094

-

1095

-

echo "\n--- BIT SHIFT LEFT ON POSITIVE INTEGERS ---\n";

1096

-

1097

-

$val = 4;

1098

-

$places = 1;

1099

-

$res = $val << $places;

1100

-

p($res, $val, '<<', $places, 'zeros fill in right side');

1101

-

1102

-

$val = 4;

1103

-

$places = (PHP_INT_SIZE * 8) - 4;

1104

-

$res = $val << $places;

1105

-

p($res, $val, '<<', $places);

1106

-

1107

-

$val = 4;

1108

-

$places = (PHP_INT_SIZE * 8) - 3;

1109

-

$res = $val << $places;

1110

-

p($res, $val, '<<', $places, 'sign bits get shifted out');

1111

-

1112

-

$val = 4;

1113

-

$places = (PHP_INT_SIZE * 8) - 2;

1114

-

$res = $val << $places;

1115

-

p($res, $val, '<<', $places, 'bits shift out left side');

1116

-

1117

-

1118

-

echo "\n--- BIT SHIFT LEFT ON NEGATIVE INTEGERS ---\n";

1119

-

1120

-

$val = -4;

1121

-

$places = 1;

1122

-

$res = $val << $places;

1123

-

p($res, $val, '<<', $places, 'zeros fill in right side');

1124

-

1125

-

$val = -4;

1126

-

$places = (PHP_INT_SIZE * 8) - 3;

1127

-

$res = $val << $places;

1128

-

p($res, $val, '<<', $places);

1129

-

1130

-

$val = -4;

1131

-

$places = (PHP_INT_SIZE * 8) - 2;

1132

-

$res = $val << $places;

1133

-

p($res, $val, '<<', $places, 'bits shift out left side, including sign bit');

1134

-

1135

-

1136

-

/*

1137

-

* Ignore this bottom section,

1138

-

* it is just formatting to make output clearer.

1139

-

*/

1140

-

1141

-

function p($res, $val, $op, $places, $note = '') {

1142

-

$format = '%0' . (PHP_INT_SIZE * 8) . "b\n";

1143

-

1144

-

printf("Expression: %d = %d %s %d\n", $res, $val, $op, $places);

1145

-

1146

-

echo " Decimal:\n";

1147

-

printf(" val=%d\n", $val);

1148

-

printf(" res=%d\n", $res);

1149

-

1150

-

echo " Binary:\n";

1151

-

printf(' val=' . $format, $val);

1152

-

printf(' res=' . $format, $res);

1153

-

1154

-

if ($note) {

1155

-

echo " NOTE: $note\n";

1156

-

}

1157

-

1158

-

echo "\n";

1159

-

}

1160

-

?>

1161

-

]]>

1162

-

</programlisting>

1163

-

&example.outputs.32bit;

1164

-

<screen>

1165

-

<![CDATA[

1166

-

1167

-

--- BIT SHIFT RIGHT ON POSITIVE INTEGERS ---

1168

-

Expression: 2 = 4 >> 1

1169

-

Decimal:

1170

-

val=4

1171

-

res=2

1172

-

Binary:

1173

-

val=00000000000000000000000000000100

1174

-

res=00000000000000000000000000000010

1175

-

NOTE: copy of sign bit shifted into left side

1176

-

1177

-

Expression: 1 = 4 >> 2

1178

-

Decimal:

1179

-

val=4

1180

-

res=1

1181

-

Binary:

1182

-

val=00000000000000000000000000000100

1183

-

res=00000000000000000000000000000001

1184

-

1185

-

Expression: 0 = 4 >> 3

1186

-

Decimal:

1187

-

val=4

1188

-

res=0

1189

-

Binary:

1190

-

val=00000000000000000000000000000100

1191

-

res=00000000000000000000000000000000

1192

-

NOTE: bits shift out right side

1193

-

1194

-

Expression: 0 = 4 >> 4

1195

-

Decimal:

1196

-

val=4

1197

-

res=0

1198

-

Binary:

1199

-

val=00000000000000000000000000000100

1200

-

res=00000000000000000000000000000000

1201

-

NOTE: same result as above; can not shift beyond 0

1202

-

1203

-

1204

-

--- BIT SHIFT RIGHT ON NEGATIVE INTEGERS ---

1205

-

Expression: -2 = -4 >> 1

1206

-

Decimal:

1207

-

val=-4

1208

-

res=-2

1209

-

Binary:

1210

-

val=11111111111111111111111111111100

1211

-

res=11111111111111111111111111111110

1212

-

NOTE: copy of sign bit shifted into left side

1213

-

1214

-

Expression: -1 = -4 >> 2

1215

-

Decimal:

1216

-

val=-4

1217

-

res=-1

1218

-

Binary:

1219

-

val=11111111111111111111111111111100

1220

-

res=11111111111111111111111111111111

1221

-

NOTE: bits shift out right side

1222

-

1223

-

Expression: -1 = -4 >> 3

1224

-

Decimal:

1225

-

val=-4

1226

-

res=-1

1227

-

Binary:

1228

-

val=11111111111111111111111111111100

1229

-

res=11111111111111111111111111111111

1230

-

NOTE: same result as above; can not shift beyond -1

1231

-

1232

-

1233

-

--- BIT SHIFT LEFT ON POSITIVE INTEGERS ---

1234

-

Expression: 8 = 4 << 1

1235

-

Decimal:

1236

-

val=4

1237

-

res=8

1238

-

Binary:

1239

-

val=00000000000000000000000000000100

1240

-

res=00000000000000000000000000001000

1241

-

NOTE: zeros fill in right side

1242

-

1243

-

Expression: 1073741824 = 4 << 28

1244

-

Decimal:

1245

-

val=4

1246

-

res=1073741824

1247

-

Binary:

1248

-

val=00000000000000000000000000000100

1249

-

res=01000000000000000000000000000000

1250

-

1251

-

Expression: -2147483648 = 4 << 29

1252

-

Decimal:

1253

-

val=4

1254

-

res=-2147483648

1255

-

Binary:

1256

-

val=00000000000000000000000000000100

1257

-

res=10000000000000000000000000000000

1258

-

NOTE: sign bits get shifted out

1259

-

1260

-

Expression: 0 = 4 << 30

1261

-

Decimal:

1262

-

val=4

1263

-

res=0

1264

-

Binary:

1265

-

val=00000000000000000000000000000100

1266

-

res=00000000000000000000000000000000

1267

-

NOTE: bits shift out left side

1268

-

1269

-

1270

-

--- BIT SHIFT LEFT ON NEGATIVE INTEGERS ---

1271

-

Expression: -8 = -4 << 1

1272

-

Decimal:

1273

-

val=-4

1274

-

res=-8

1275

-

Binary:

1276

-

val=11111111111111111111111111111100

1277

-

res=11111111111111111111111111111000

1278

-

NOTE: zeros fill in right side

1279

-

1280

-

Expression: -2147483648 = -4 << 29

1281

-

Decimal:

1282

-

val=-4

1283

-

res=-2147483648

1284

-

Binary:

1285

-

val=11111111111111111111111111111100

1286

-

res=10000000000000000000000000000000

1287

-

1288

-

Expression: 0 = -4 << 30

1289

-

Decimal:

1290

-

val=-4

1291

-

res=0

1292

-

Binary:

1293

-

val=11111111111111111111111111111100

1294

-

res=00000000000000000000000000000000

1295

-

NOTE: bits shift out left side, including sign bit

1296

-

]]>

1297

-

</screen>

1298

-

&example.outputs.64bit;

1299

-

<screen>

1300

-

<![CDATA[

1301

-

1302

-

--- BIT SHIFT RIGHT ON POSITIVE INTEGERS ---

1303

-

Expression: 2 = 4 >> 1

1304

-

Decimal:

1305

-

val=4

1306

-

res=2

1307

-

Binary:

1308

-

val=0000000000000000000000000000000000000000000000000000000000000100

1309

-

res=0000000000000000000000000000000000000000000000000000000000000010

1310

-

NOTE: copy of sign bit shifted into left side

1311

-

1312

-

Expression: 1 = 4 >> 2

1313

-

Decimal:

1314

-

val=4

1315

-

res=1

1316

-

Binary:

1317

-

val=0000000000000000000000000000000000000000000000000000000000000100

1318

-

res=0000000000000000000000000000000000000000000000000000000000000001

1319

-

1320

-

Expression: 0 = 4 >> 3

1321

-

Decimal:

1322

-

val=4

1323

-

res=0

1324

-

Binary:

1325

-

val=0000000000000000000000000000000000000000000000000000000000000100

1326

-

res=0000000000000000000000000000000000000000000000000000000000000000

1327

-

NOTE: bits shift out right side

1328

-

1329

-

Expression: 0 = 4 >> 4

1330

-

Decimal:

1331

-

val=4

1332

-

res=0

1333

-

Binary:

1334

-

val=0000000000000000000000000000000000000000000000000000000000000100

1335

-

res=0000000000000000000000000000000000000000000000000000000000000000

1336

-

NOTE: same result as above; can not shift beyond 0

1337

-

1338

-

1339

-

--- BIT SHIFT RIGHT ON NEGATIVE INTEGERS ---

1340

-

Expression: -2 = -4 >> 1

1341

-

Decimal:

1342

-

val=-4

1343

-

res=-2

1344

-

Binary:

1345

-

val=1111111111111111111111111111111111111111111111111111111111111100

1346

-

res=1111111111111111111111111111111111111111111111111111111111111110

1347

-

NOTE: copy of sign bit shifted into left side

1348

-

1349

-

Expression: -1 = -4 >> 2

1350

-

Decimal:

1351

-

val=-4

1352

-

res=-1

1353

-

Binary:

1354

-

val=1111111111111111111111111111111111111111111111111111111111111100

1355

-

res=1111111111111111111111111111111111111111111111111111111111111111

1356

-

NOTE: bits shift out right side

1357

-

1358

-

Expression: -1 = -4 >> 3

1359

-

Decimal:

1360

-

val=-4

1361

-

res=-1

1362

-

Binary:

1363

-

val=1111111111111111111111111111111111111111111111111111111111111100

1364

-

res=1111111111111111111111111111111111111111111111111111111111111111

1365

-

NOTE: same result as above; can not shift beyond -1

1366

-

1367

-

1368

-

--- BIT SHIFT LEFT ON POSITIVE INTEGERS ---

1369

-

Expression: 8 = 4 << 1

1370

-

Decimal:

1371

-

val=4

1372

-

res=8

1373

-

Binary:

1374

-

val=0000000000000000000000000000000000000000000000000000000000000100

1375

-

res=0000000000000000000000000000000000000000000000000000000000001000

1376

-

NOTE: zeros fill in right side

1377

-

1378

-

Expression: 4611686018427387904 = 4 << 60

1379

-

Decimal:

1380

-

val=4

1381

-

res=4611686018427387904

1382

-

Binary:

1383

-

val=0000000000000000000000000000000000000000000000000000000000000100

1384

-

res=0100000000000000000000000000000000000000000000000000000000000000

1385

-

1386

-

Expression: -9223372036854775808 = 4 << 61

1387

-

Decimal:

1388

-

val=4

1389

-

res=-9223372036854775808

1390

-

Binary:

1391

-

val=0000000000000000000000000000000000000000000000000000000000000100

1392

-

res=1000000000000000000000000000000000000000000000000000000000000000

1393

-

NOTE: sign bits get shifted out

1394

-

1395

-

Expression: 0 = 4 << 62

1396

-

Decimal:

1397

-

val=4

1398

-

res=0

1399

-

Binary:

1400

-

val=0000000000000000000000000000000000000000000000000000000000000100

1401

-

res=0000000000000000000000000000000000000000000000000000000000000000

1402

-

NOTE: bits shift out left side

1403

-

1404

-

1405

-

--- BIT SHIFT LEFT ON NEGATIVE INTEGERS ---

1406

-

Expression: -8 = -4 << 1

1407

-

Decimal:

1408

-

val=-4

1409

-

res=-8

1410

-

Binary:

1411

-

val=1111111111111111111111111111111111111111111111111111111111111100

1412

-

res=1111111111111111111111111111111111111111111111111111111111111000

1413

-

NOTE: zeros fill in right side

1414

-

1415

-

Expression: -9223372036854775808 = -4 << 61

1416

-

Decimal:

1417

-

val=-4

1418

-

res=-9223372036854775808

1419

-

Binary:

1420

-

val=1111111111111111111111111111111111111111111111111111111111111100

1421

-

res=1000000000000000000000000000000000000000000000000000000000000000

1422

-

1423

-

Expression: 0 = -4 << 62

1424

-

Decimal:

1425

-

val=-4

1426

-

res=0

1427

-

Binary:

1428

-

val=1111111111111111111111111111111111111111111111111111111111111100

1429

-

res=0000000000000000000000000000000000000000000000000000000000000000

1430

-

NOTE: bits shift out left side, including sign bit

1431

-

]]>

1432

-

</screen>

1433

-

</example>

1434

-

</para>

1435

-

<warning>

1436

-

<para>

1437

-

Use functions from the <link linkend="book.gmp">gmp</link> extension for

1438

-

bitwise manipulation on numbers beyond <literal>PHP_INT_MAX</literal>.

1439

-

</para>

1440

-

</warning>

1441

-

1442

-

<sect2 role="seealso">

1443

-

&reftitle.seealso;

1444

-

<para>

1445

-

<simplelist>

1446

-

<!-- <link linkend="language.oop5.basic.class.class">::class</link> -->

1447

-

<member><function>pack</function></member>

1448

-

<member><function>unpack</function></member>

1449

-

<member><function>gmp_and</function></member>

1450

-

<member><function>gmp_or</function></member>

1451

-

<member><function>gmp_xor</function></member>

1452

-

<member><function>gmp_testbit</function></member>

1453

-

<member><function>gmp_clrbit</function></member>

1454

-

</simplelist>

1455

-

</para>

1456

-

</sect2>

1457

-

</sect1>

1458

-

1459

-

<sect1 xml:id="language.operators.comparison">

1460

-

<title>Comparison Operators</title>

1461

-

<simpara>

1462

-

Comparison operators, as their name implies, allow you to compare

1463

-

two values. You may also be interested in viewing

1464

-

<link linkend="types.comparisons">the type comparison tables</link>,

1465

-

as they show examples of various type related comparisons.

1466

-

</simpara>

1467

-

<table>

1468

-

<title>Comparison Operators</title>

1469

-

<tgroup cols="3">

1470

-

<thead>

1471

-

<row>

1472

-

<entry>Example</entry>

1473

-

<entry>Name</entry>

1474

-

<entry>Result</entry>

1475

-

</row>

1476

-

</thead>

1477

-

<tbody>

1478

-

<row>

1479

-

<entry>$a == $b</entry>

1480

-

<entry>Equal</entry>

1481

-

<entry>&true; if <varname>$a</varname> is equal to <varname>$b</varname> after type juggling.</entry>

1482

-

</row>

1483

-

<row>

1484

-

<entry>$a === $b</entry>

1485

-

<entry>Identical</entry>

1486

-

<entry>

1487

-

&true; if <varname>$a</varname> is equal to <varname>$b</varname>, and they are of the same

1488

-

type.

1489

-

</entry>

1490

-

</row>

1491

-

<row>

1492

-

<entry>$a != $b</entry>

1493

-

<entry>Not equal</entry>

1494

-

<entry>&true; if <varname>$a</varname> is not equal to <varname>$b</varname> after type juggling.</entry>

1495

-

</row>

1496

-

<row>

1497

-

<entry>$a &lt;&gt; $b</entry>

1498

-

<entry>Not equal</entry>

1499

-

<entry>&true; if <varname>$a</varname> is not equal to <varname>$b</varname> after type juggling.</entry>

1500

-

</row>

1501

-

<row>

1502

-

<entry>$a !== $b</entry>

1503

-

<entry>Not identical</entry>

1504

-

<entry>

1505

-

&true; if <varname>$a</varname> is not equal to <varname>$b</varname>, or they are not of the same

1506

-

type.

1507

-

</entry>

1508

-

</row>

1509

-

<row>

1510

-

<entry>$a &lt; $b</entry>

1511

-

<entry>Less than</entry>

1512

-

<entry>&true; if <varname>$a</varname> is strictly less than <varname>$b</varname>.</entry>

1513

-

</row>

1514

-

<row>

1515

-

<entry>$a &gt; $b</entry>

1516

-

<entry>Greater than</entry>

1517

-

<entry>&true; if <varname>$a</varname> is strictly greater than <varname>$b</varname>.</entry>

1518

-

</row>

1519

-

<row>

1520

-

<entry>$a &lt;= $b</entry>

1521

-

<entry>Less than or equal to </entry>

1522

-

<entry>&true; if <varname>$a</varname> is less than or equal to <varname>$b</varname>.</entry>

1523

-

</row>

1524

-

<row>

1525

-

<entry>$a &gt;= $b</entry>

1526

-

<entry>Greater than or equal to </entry>

1527

-

<entry>&true; if <varname>$a</varname> is greater than or equal to <varname>$b</varname>.</entry>

1528

-

</row>

1529

-

<row>

1530

-

<entry>$a &lt;=&gt; $b</entry>

1531

-

<entry>Spaceship</entry>

1532

-

<entry>

1533

-

An <type>int</type> less than, equal to, or greater than zero when

1534

-

<varname>$a</varname> is less than, equal to, or greater than

1535

-

<varname>$b</varname>, respectively.

1536

-

</entry>

1537

-

</row>

1538

-

</tbody>

1539

-

</tgroup>

1540

-

</table>

1541

-

<para>

1542

-

If both operands are

1543

-

<link linkend="language.types.numeric-strings">numeric strings</link>,

1544

-

or one operand is a number and the other one is a

1545

-

<link linkend="language.types.numeric-strings">numeric string</link>,

1546

-

then the comparison is done numerically.

1547

-

These rules also apply to the

1548

-

<link linkend="control-structures.switch">switch</link> statement.

1549

-

The type conversion does not take place when the comparison is

1550

-

<literal>===</literal> or <literal>!==</literal> as this involves

1551

-

comparing the type as well as the value.

1552

-

</para>

1553

-

1554

-

<warning>

1555

-

<para>

1556

-

Prior to PHP 8.0.0, if a <type>string</type> is compared to a number

1557

-

or a numeric string then the <type>string</type> was converted to a

1558

-

number before performing the comparison. This can lead to surprising

1559

-

results as can be seen with the following example:

1560

-

<informalexample>

1561

-

<programlisting role="php">

1562

-

<![CDATA[

1563

-

<?php

1564

-

var_dump(0 == "a");

1565

-

var_dump("1" == "01");

1566

-

var_dump("10" == "1e1");

1567

-

var_dump(100 == "1e2");

1568

-

1569

-

switch ("a") {

1570

-

case 0:

1571

-

echo "0";

1572

-

break;

1573

-

case "a":

1574

-

echo "a";

1575

-

break;

1576

-

}

1577