...

...

@@ -1,2440 +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 lesser

58

-

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

59

-

</para>

60

-

<para>

61

-

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

62

-

readability of the code by making grouping explicit rather than relying

63

-

on the implicit operator precedence and associativity.

64

-

</para>

65

-

<para>

66

-

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

67

-

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

68

-

have equal precedence, in which case associativity decides grouping.

69

-

<table>

70

-

<title>Operator Precedence</title>

71

-

<tgroup cols="2">

72

-

<thead>

73

-

<row>

74

-

<entry>Associativity</entry>

75

-

<entry>Operators</entry>

76

-

<entry>Additional Information</entry>

77

-

</row>

78

-

</thead>

79

-

<tbody>

80

-

<row>

81

-

<entry>non-associative</entry>

82

-

<entry>

83

-

<literal>clone</literal>

84

-

<literal>new</literal>

85

-

</entry>

86

-

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

87

-

</row>

88

-

<row>

89

-

<entry>left</entry>

90

-

<entry><literal>[</literal></entry>

91

-

<entry><function>array</function></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>right</entry>

100

-

<entry>

101

-

<literal>++</literal>

102

-

<literal>--</literal>

103

-

<literal>~</literal>

104

-

<literal>(int)</literal>

105

-

<literal>(float)</literal>

106

-

<literal>(string)</literal>

107

-

<literal>(array)</literal>

108

-

<literal>(object)</literal>

109

-

<literal>(bool)</literal>

110

-

<literal>@</literal>

111

-

</entry>

112

-

<entry>

113

-

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

114

-

</entry>

115

-

</row>

116

-

<row>

117

-

<entry>non-associative</entry>

118

-

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

119

-

<entry>

120

-

<link linkend="language.types">types</link>

121

-

</entry>

122

-

</row>

123

-

<row>

124

-

<entry>right</entry>

125

-

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

126

-

<entry>

127

-

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

128

-

</entry>

129

-

</row>

130

-

<row>

131

-

<entry>left</entry>

132

-

<entry>

133

-

<literal>*</literal>

134

-

<literal>/</literal>

135

-

<literal>%</literal>

136

-

</entry>

137

-

<entry>

138

-

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

139

-

</entry>

140

-

</row>

141

-

<row>

142

-

<entry>left</entry>

143

-

<entry>

144

-

<literal>+</literal>

145

-

<literal>-</literal>

146

-

<literal>.</literal>

147

-

</entry>

148

-

<entry>

149

-

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

150

-

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

151

-

</row>

152

-

<row>

153

-

<entry>left</entry>

154

-

<entry>

155

-

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

156

-

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

157

-

</entry>

158

-

<entry>

159

-

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

160

-

</entry>

161

-

</row>

162

-

<row>

163

-

<entry>non-associative</entry>

164

-

<entry>

165

-

<literal>&lt;</literal>

166

-

<literal>&lt;=</literal>

167

-

<literal>&gt;</literal>

168

-

<literal>&gt;=</literal>

169

-

</entry>

170

-

<entry>

171

-

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

172

-

</entry>

173

-

</row>

174

-

<row>

175

-

<entry>non-associative</entry>

176

-

<entry>

177

-

<literal>==</literal>

178

-

<literal>!=</literal>

179

-

<literal>===</literal>

180

-

<literal>!==</literal>

181

-

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

182

-

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

183

-

</entry>

184

-

<entry>

185

-

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

186

-

</entry>

187

-

</row>

188

-

<row>

189

-

<entry>left</entry>

190

-

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

191

-

<entry>

192

-

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

193

-

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

194

-

</row>

195

-

<row>

196

-

<entry>left</entry>

197

-

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

198

-

<entry>

199

-

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

200

-

</entry>

201

-

</row>

202

-

<row>

203

-

<entry>left</entry>

204

-

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

205

-

<entry>

206

-

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

207

-

</entry>

208

-

</row>

209

-

<row>

210

-

<entry>left</entry>

211

-

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

212

-

<entry>

213

-

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

214

-

</entry>

215

-

</row>

216

-

<row>

217

-

<entry>left</entry>

218

-

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

219

-

<entry>

220

-

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

221

-

</entry>

222

-

</row>

223

-

<row>

224

-

<entry>right</entry>

225

-

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

226

-

<entry>

227

-

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

228

-

</entry>

229

-

</row>

230

-

<row>

231

-

<entry>left</entry>

232

-

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

233

-

<entry>

234

-

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

235

-

</entry>

236

-

</row>

237

-

<row>

238

-

<entry>right</entry>

239

-

<entry>

240

-

<literal>=</literal>

241

-

<literal>+=</literal>

242

-

<literal>-=</literal>

243

-

<literal>*=</literal>

244

-

<literal>**=</literal>

245

-

<literal>/=</literal>

246

-

<literal>.=</literal>

247

-

<literal>%=</literal>

248

-

<literal>&amp;=</literal>

249

-

<literal>|=</literal>

250

-

<literal>^=</literal>

251

-

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

252

-

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

253

-

</entry>

254

-

<entry>

255

-

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

256

-

</entry>

257

-

</row>

258

-

<row>

259

-

<entry>left</entry>

260

-

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

261

-

<entry>

262

-

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

263

-

</entry>

264

-

</row>

265

-

<row>

266

-

<entry>left</entry>

267

-

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

268

-

<entry>

269

-

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

270

-

</entry>

271

-

</row>

272

-

<row>

273

-

<entry>left</entry>

274

-

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

275

-

<entry>

276

-

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

277

-

</entry>

278

-

</row>

279

-

</tbody>

280

-

</tgroup>

281

-

</table>

282

-

</para>

283

-

<para>

284

-

<example>

285

-

<title>Associativity</title>

286

-

<programlisting role="php">

287

-

<![CDATA[

288

-

<?php

289

-

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

290

-

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

291

-

$a = true ? 0 : true ? 1 : 2; // (true ? 0 : true) ? 1 : 2 = 2

292

-

293

-

$a = 1;

294

-

$b = 2;

295

-

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

296

-

?>

297

-

]]>

298

-

</programlisting>

299

-

</example>

300

-

</para>

301

-

<para>

302

-

Operator precedence and associativity only determine how expressions

303

-

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

304

-

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

305

-

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

306

-

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

307

-

the surrounding code.

308

-

<example>

309

-

<title>Undefined order of evaluation</title>

310

-

<programlisting role="php">

311

-

<![CDATA[

312

-

<?php

313

-

$a = 1;

314

-

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

315

-

316

-

$i = 1;

317

-

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

318

-

?>

319

-

]]>

320

-

</programlisting>

321

-

</example>

322

-

<example>

323

-

<title><literal>+</literal>, <literal>-</literal> and <literal>.</literal> have the same precedence</title>

324

-

<programlisting role="php">

325

-

<![CDATA[

326

-

<?php

327

-

$x = 4;

328

-

// this line might result in unexpected output:

329

-

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

330

-

// because it is evaluated like this line:

331

-

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

332

-

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

333

-

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

334

-

?>

335

-

]]>

336

-

</programlisting>

337

-

&example.outputs;

338

-

<screen>

339

-

<![CDATA[

340

-

-1, or so I hope

341

-

-1, or so I hope

342

-

x minus one equals 3, or so I hope

343

-

]]>

344

-

</screen>

345

-

</example>

346

-

</para>

347

-

<note>

348

-

<para>

349

-

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

350

-

most other operators, PHP will still allow expressions

351

-

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

352

-

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

353

-

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

354

-

</para>

355

-

</note>

356

-

</sect1>

357

-

358

-

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

359

-

<title>Arithmetic Operators</title>

360

-

<simpara>

361

-

Remember basic arithmetic from school? These work just

362

-

like those.

363

-

</simpara>

364

-

<table>

365

-

<title>Arithmetic Operators</title>

366

-

<tgroup cols="3">

367

-

<thead>

368

-

<row>

369

-

<entry>Example</entry>

370

-

<entry>Name</entry>

371

-

<entry>Result</entry>

372

-

</row>

373

-

</thead>

374

-

<tbody>

375

-

<row>

376

-

<entry>+$a</entry>

377

-

<entry>Identity</entry>

378

-

<entry>

379

-

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

380

-

<type>float</type> as appropriate.

381

-

</entry>

382

-

</row>

383

-

<row>

384

-

<entry>-$a</entry>

385

-

<entry>Negation</entry>

386

-

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

387

-

</row>

388

-

<row>

389

-

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

390

-

<entry>Addition</entry>

391

-

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

392

-

</row>

393

-

<row>

394

-

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

395

-

<entry>Subtraction</entry>

396

-

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

397

-

</row>

398

-

<row>

399

-

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

400

-

<entry>Multiplication</entry>

401

-

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

402

-

</row>

403

-

<row>

404

-

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

405

-

<entry>Division</entry>

406

-

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

407

-

</row>

408

-

<row>

409

-

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

410

-

<entry>Modulo</entry>

411

-

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

412

-

</row>

413

-

<row>

414

-

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

415

-

<entry>Exponentiation</entry>

416

-

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

417

-

</row>

418

-

</tbody>

419

-

</tgroup>

420

-

</table>

421

-

<simpara>

422

-

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

423

-

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

424

-

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

425

-

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

426

-

</simpara>

427

-

<simpara>

428

-

Operands of modulo are converted to integers (by stripping the decimal

429

-

part) before processing. For floating-point modulo, see

430

-

<function>fmod</function>.

431

-

</simpara>

432

-

<para>

433

-

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

434

-

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

435

-

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

436

-

<informalexample>

437

-

<programlisting role="php">

438

-

<![CDATA[

439

-

<?php

440

-

441

-

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

442

-

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

443

-

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

444

-

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

445

-

446

-

?>

447

-

]]>

448

-

</programlisting>

449

-

</informalexample>

450

-

</para>

451

-

<simpara>

452

-

See also the manual page on

453

-

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

454

-

</simpara>

455

-

456

-

</sect1>

457

-

458

-

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

459

-

<title>Assignment Operators</title>

460

-

<simpara>

461

-

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

462

-

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

463

-

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

464

-

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

465

-

</simpara>

466

-

<para>

467

-

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

468

-

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

469

-

things:

470

-

<informalexample>

471

-

<programlisting role="php">

472

-

<![CDATA[

473

-

<?php

474

-

475

-

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

476

-

477

-

?>

478

-

]]>

479

-

</programlisting>

480

-

</informalexample>

481

-

</para>

482

-

<para>

483

-

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

484

-

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

485

-

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

486

-

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

487

-

example:

488

-

<informalexample>

489

-

<programlisting role="php">

490

-

<![CDATA[

491

-

<?php

492

-

493

-

$a = 3;

494

-

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

495

-

$b = "Hello ";

496

-

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

497

-

498

-

?>

499

-

]]>

500

-

</programlisting>

501

-

</informalexample>

502

-

</para>

503

-

<para>

504

-

Note that the assignment copies the original variable to the new

505

-

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

506

-

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

507

-

like a large array inside a tight loop.

508

-

</para>

509

-

<para>

510

-

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

511

-

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

512

-

Objects may be explicitly copied via the <link

513

-

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

514

-

</para>

515

-

516

-

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

517

-

<title>Assignment by Reference</title>

518

-

<para>

519

-

Assignment by reference is also supported, using the

520

-

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

521

-

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

522

-

same data, and nothing is copied anywhere.

523

-

</para>

524

-

<para>

525

-

<example>

526

-

<title>Assigning by reference</title>

527

-

<programlisting role="php">

528

-

<![CDATA[

529

-

<?php

530

-

$a = 3;

531

-

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

532

-

533

-

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

534

-

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

535

-

536

-

$a = 4; // change $a

537

-

538

-

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

539

-

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

540

-

// been changed

541

-

?>

542

-

]]>

543

-

</programlisting>

544

-

</example>

545

-

</para>

546

-

<para>

547

-

As of PHP 5, the <link linkend="language.oop5.basic.new">new</link>

548

-

operator returns a reference automatically, so assigning the result of

549

-

<link linkend="language.oop5.basic.new">new</link> by reference results

550

-

in an <constant>E_DEPRECATED</constant> message in PHP 5.3 and later, and

551

-

an <constant>E_STRICT</constant> message in earlier versions.

552

-

</para>

553

-

<para>

554

-

For example, this code will result in a warning:

555

-

<informalexample>

556

-

<programlisting role="php">

557

-

<![CDATA[

558

-

<?php

559

-

class C {}

560

-

561

-

/* The following line generates the following error message:

562

-

* Deprecated: Assigning the return value of new by reference is deprecated in...

563

-

*/

564

-

$o = &new C;

565

-

?>

566

-

]]>

567

-

</programlisting>

568

-

</informalexample>

569

-

</para>

570

-

<para>

571

-

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

572

-

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

573

-

section of the manual.

574

-

</para>

575

-

</sect2>

576

-

</sect1>

577

-

578

-

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

579

-

<title>Bitwise Operators</title>

580

-

<simpara>

581

-

Bitwise operators allow evaluation and manipulation of specific

582

-

bits within an integer.

583

-

</simpara>

584

-

<table>

585

-

<title>Bitwise Operators</title>

586

-

<tgroup cols="3">

587

-

<thead>

588

-

<row>

589

-

<entry>Example</entry>

590

-

<entry>Name</entry>

591

-

<entry>Result</entry>

592

-

</row>

593

-

</thead>

594

-

<tbody>

595

-

<row>

596

-

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

597

-

<entry>And</entry>

598

-

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

599

-

</row>

600

-

<row>

601

-

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

602

-

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

603

-

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

604

-

</row>

605

-

<row>

606

-

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

607

-

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

608

-

<entry>

609

-

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

610

-

</entry>

611

-

</row>

612

-

<row>

613

-

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

614

-

<entry>Not</entry>

615

-

<entry>

616

-

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

617

-

</entry>

618

-

</row>

619

-

<row>

620

-

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

621

-

<entry>Shift left</entry>

622

-

<entry>

623

-

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

624

-

"multiply by two")

625

-

</entry>

626

-

</row>

627

-

<row>

628

-

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

629

-

<entry>Shift right</entry>

630

-

<entry>

631

-

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

632

-

"divide by two")

633

-

</entry>

634

-

</row>

635

-

</tbody>

636

-

</tgroup>

637

-

</table>

638

-

<para>

639

-

Bit shifting in PHP is arithmetic.

640

-

Bits shifted off either end are discarded.

641

-

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

642

-

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

643

-

is not preserved.

644

-

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

645

-

meaning the sign of an operand is preserved.

646

-

</para>

647

-

<para>

648

-

Use parentheses to ensure the desired

649

-

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

650

-

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

651

-

the equivalency then the bitwise and; while

652

-

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

653

-

then the equivalency.

654

-

</para>

655

-

<para>

656

-

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

657

-

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

658

-

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

659

-

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

660

-

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

661

-

and the result will be an integer.

662

-

</para>

663

-

<para>

664

-

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

665

-

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

666

-

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

667

-

result will be treated as integers.

668

-

</para>

669

-

<para>

670

-

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

671

-

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

672

-

</para>

673

-

<para>

674

-

<informalexample>

675

-

<para>

676

-

<literallayout>

677

-

PHP's error_reporting ini setting uses bitwise values,

678

-

providing a real-world demonstration of turning

679

-

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

680

-

the php.ini file instructions say to use:

681

-

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

682

-

</literallayout>

683

-

</para>

684

-

<para>

685

-

<literallayout>

686

-

This works by starting with E_ALL:

687

-

<computeroutput>00000000000000000111011111111111</computeroutput>

688

-

Then taking the value of E_NOTICE...

689

-

<computeroutput>00000000000000000000000000001000</computeroutput>

690

-

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

691

-

<computeroutput>11111111111111111111111111110111</computeroutput>

692

-

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

693

-

on in both values:

694

-

<computeroutput>00000000000000000111011111110111</computeroutput>

695

-

</literallayout>

696

-

</para>

697

-

<para>

698

-

<literallayout>

699

-

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

700

-

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

701

-

<userinput>E_ALL ^ E_NOTICE</userinput>

702

-

</literallayout>

703

-

</para>

704

-

</informalexample>

705

-

</para>

706

-

<para>

707

-

<informalexample>

708

-

<para>

709

-

<literallayout>

710

-

error_reporting can also be used to demonstrate turning bits on.

711

-

The way to show just errors and recoverable errors is:

712

-

<userinput>E_ERROR | E_RECOVERABLE_ERROR</userinput>

713

-

</literallayout>

714

-

</para>

715

-

<para>

716

-

<literallayout>

717

-

This process combines E_ERROR

718

-

<computeroutput>00000000000000000000000000000001</computeroutput>

719

-

and

720

-

<computeroutput>00000000000000000001000000000000</computeroutput>

721

-

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

722

-

to get the bits turned on in either value:

723

-

<computeroutput>00000000000000000001000000000001</computeroutput>

724

-

</literallayout>

725

-

</para>

726

-

</informalexample>

727

-

</para>

728

-

<para>

729

-

<example>

730

-

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

731

-

<programlisting role="php">

732

-

<![CDATA[

733

-

<?php

734

-

/*

735

-

* Ignore the top section,

736

-

* it is just formatting to make output clearer.

737

-

*/

738

-

739

-

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

740

-

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

741

-

742

-

echo <<<EOH

743

-

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

744

-

result value op test

745

-

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

746

-

EOH;

747

-

748

-

749

-

/*

750

-

* Here are the examples.

751

-

*/

752

-

753

-

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

754

-

$test = 1 + 4;

755

-

756

-

echo "\n Bitwise AND \n";

757

-

foreach ($values as $value) {

758

-

$result = $value & $test;

759

-

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

760

-

}

761

-

762

-

echo "\n Bitwise Inclusive OR \n";

763

-

foreach ($values as $value) {

764

-

$result = $value | $test;

765

-

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

766

-

}

767

-

768

-

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

769

-

foreach ($values as $value) {

770

-

$result = $value ^ $test;

771

-

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

772

-

}

773

-

?>

774

-

]]>

775

-

</programlisting>

776

-

&example.outputs;

777

-

<screen>

778

-

<![CDATA[

779

-

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

780

-

result value op test

781

-

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

782

-

Bitwise AND

783

-

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

784

-

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

785

-

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

786

-

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

787

-

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

788

-

789

-

Bitwise Inclusive OR

790

-

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

791

-

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

792

-

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

793

-

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

794

-

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

795

-

796

-

Bitwise Exclusive OR (XOR)

797

-

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

798

-

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

799

-

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

800

-

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

801

-

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

802

-

]]>

803

-

</screen>

804

-

</example>

805

-

</para>

806

-

<para>

807

-

<example>

808

-

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

809

-

<programlisting role="php">

810

-

<![CDATA[

811

-

<?php

812

-

echo 12 ^ 9; // Outputs '5'

813

-

814

-

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

815

-

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

816

-

817

-

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

818

-

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

819

-

820

-

echo 2 ^ "3"; // Outputs 1

821

-

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

822

-

823

-

echo "2" ^ 3; // Outputs 1

824

-

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

825

-

?>

826

-

]]>

827

-

</programlisting>

828

-

</example>

829

-

</para>

830

-

<para>

831

-

<example>

832

-

<title>Bit shifting on integers</title>

833

-

<programlisting role="php">

834

-

<![CDATA[

835

-

<?php

836

-

/*

837

-

* Here are the examples.

838

-

*/

839

-

840

-

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

841

-

842

-

$val = 4;

843

-

$places = 1;

844

-

$res = $val >> $places;

845

-

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

846

-

847

-

$val = 4;

848

-

$places = 2;

849

-

$res = $val >> $places;

850

-

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

851

-

852

-

$val = 4;

853

-

$places = 3;

854

-

$res = $val >> $places;

855

-

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

856

-

857

-

$val = 4;

858

-

$places = 4;

859

-

$res = $val >> $places;

860

-

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

861

-

862

-

863

-

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

864

-

865

-

$val = -4;

866

-

$places = 1;

867

-

$res = $val >> $places;

868

-

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

869

-

870

-

$val = -4;

871

-

$places = 2;

872

-

$res = $val >> $places;

873

-

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

874

-

875

-

$val = -4;

876

-

$places = 3;

877

-

$res = $val >> $places;

878

-

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

879

-

880

-

881

-

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

882

-

883

-

$val = 4;

884

-

$places = 1;

885

-

$res = $val << $places;

886

-

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

887

-

888

-

$val = 4;

889

-

$places = (PHP_INT_SIZE * 8) - 4;

890

-

$res = $val << $places;

891

-

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

892

-

893

-

$val = 4;

894

-

$places = (PHP_INT_SIZE * 8) - 3;

895

-

$res = $val << $places;

896

-

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

897

-

898

-

$val = 4;

899

-

$places = (PHP_INT_SIZE * 8) - 2;

900

-

$res = $val << $places;

901

-

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

902

-

903

-

904

-

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

905

-

906

-

$val = -4;

907

-

$places = 1;

908

-

$res = $val << $places;

909

-

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

910

-

911

-

$val = -4;

912

-

$places = (PHP_INT_SIZE * 8) - 3;

913

-

$res = $val << $places;

914

-

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

915

-

916

-

$val = -4;

917

-

$places = (PHP_INT_SIZE * 8) - 2;

918

-

$res = $val << $places;

919

-

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

920

-

921

-

922

-

/*

923

-

* Ignore this bottom section,

924

-

* it is just formatting to make output clearer.

925

-

*/

926

-

927

-

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

928

-

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

929

-

930

-

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

931

-

932

-

echo " Decimal:\n";

933

-

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

934

-

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

935

-

936

-

echo " Binary:\n";

937

-

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

938

-

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

939

-

940

-

if ($note) {

941

-

echo " NOTE: $note\n";

942

-

}

943

-

944

-

echo "\n";

945

-

}

946

-

?>

947

-

]]>

948

-

</programlisting>

949

-

&example.outputs.32bit;

950

-

<screen>

951

-

<![CDATA[

952

-

953

-

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

954

-

Expression: 2 = 4 >> 1

955

-

Decimal:

956

-

val=4

957

-

res=2

958

-

Binary:

959

-

val=00000000000000000000000000000100

960

-

res=00000000000000000000000000000010

961

-

NOTE: copy of sign bit shifted into left side

962

-

963

-

Expression: 1 = 4 >> 2

964

-

Decimal:

965

-

val=4

966

-

res=1

967

-

Binary:

968

-

val=00000000000000000000000000000100

969

-

res=00000000000000000000000000000001

970

-

971

-

Expression: 0 = 4 >> 3

972

-

Decimal:

973

-

val=4

974

-

res=0

975

-

Binary:

976

-

val=00000000000000000000000000000100

977

-

res=00000000000000000000000000000000

978

-

NOTE: bits shift out right side

979

-

980

-

Expression: 0 = 4 >> 4

981

-

Decimal:

982

-

val=4

983

-

res=0

984

-

Binary:

985

-

val=00000000000000000000000000000100

986

-

res=00000000000000000000000000000000

987

-

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

988

-

989

-

990

-

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

991

-

Expression: -2 = -4 >> 1

992

-

Decimal:

993

-

val=-4

994

-

res=-2

995

-

Binary:

996

-

val=11111111111111111111111111111100

997

-

res=11111111111111111111111111111110

998

-

NOTE: copy of sign bit shifted into left side

999

-

1000

-

Expression: -1 = -4 >> 2

1001

-

Decimal:

1002

-

val=-4

1003

-

res=-1

1004

-

Binary:

1005

-

val=11111111111111111111111111111100

1006

-

res=11111111111111111111111111111111

1007

-

NOTE: bits shift out right side

1008

-

1009

-

Expression: -1 = -4 >> 3

1010

-

Decimal:

1011

-

val=-4

1012

-

res=-1

1013

-

Binary:

1014

-

val=11111111111111111111111111111100

1015

-

res=11111111111111111111111111111111

1016

-

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

1017

-

1018

-

1019

-

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

1020

-

Expression: 8 = 4 << 1

1021

-

Decimal:

1022

-

val=4

1023

-

res=8

1024

-

Binary:

1025

-

val=00000000000000000000000000000100

1026

-

res=00000000000000000000000000001000

1027

-

NOTE: zeros fill in right side

1028

-

1029

-

Expression: 1073741824 = 4 << 28

1030

-

Decimal:

1031

-

val=4

1032

-

res=1073741824

1033

-

Binary:

1034

-

val=00000000000000000000000000000100

1035

-

res=01000000000000000000000000000000

1036

-

1037

-

Expression: -2147483648 = 4 << 29

1038

-

Decimal:

1039

-

val=4

1040

-

res=-2147483648

1041

-

Binary:

1042

-

val=00000000000000000000000000000100

1043

-

res=10000000000000000000000000000000

1044

-

NOTE: sign bits get shifted out

1045

-

1046

-

Expression: 0 = 4 << 30

1047

-

Decimal:

1048

-

val=4

1049

-

res=0

1050

-

Binary:

1051

-

val=00000000000000000000000000000100

1052

-

res=00000000000000000000000000000000

1053

-

NOTE: bits shift out left side

1054

-

1055

-

1056

-

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

1057

-

Expression: -8 = -4 << 1

1058

-

Decimal:

1059

-

val=-4

1060

-

res=-8

1061

-

Binary:

1062

-

val=11111111111111111111111111111100

1063

-

res=11111111111111111111111111111000

1064

-

NOTE: zeros fill in right side

1065

-

1066

-

Expression: -2147483648 = -4 << 29

1067

-

Decimal:

1068

-

val=-4

1069

-

res=-2147483648

1070

-

Binary:

1071

-

val=11111111111111111111111111111100

1072

-

res=10000000000000000000000000000000

1073

-

1074

-

Expression: 0 = -4 << 30

1075

-

Decimal:

1076

-

val=-4

1077

-

res=0

1078

-

Binary:

1079

-

val=11111111111111111111111111111100

1080

-

res=00000000000000000000000000000000

1081

-

NOTE: bits shift out left side, including sign bit

1082

-

]]>

1083

-

</screen>

1084

-

&example.outputs.64bit;

1085

-

<screen>

1086

-

<![CDATA[

1087

-

1088

-

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

1089

-

Expression: 2 = 4 >> 1

1090

-

Decimal:

1091

-

val=4

1092

-

res=2

1093

-

Binary:

1094

-

val=0000000000000000000000000000000000000000000000000000000000000100

1095

-

res=0000000000000000000000000000000000000000000000000000000000000010

1096

-

NOTE: copy of sign bit shifted into left side

1097

-

1098

-

Expression: 1 = 4 >> 2

1099

-

Decimal:

1100

-

val=4

1101

-

res=1

1102

-

Binary:

1103

-

val=0000000000000000000000000000000000000000000000000000000000000100

1104

-

res=0000000000000000000000000000000000000000000000000000000000000001

1105

-

1106

-

Expression: 0 = 4 >> 3

1107

-

Decimal:

1108

-

val=4

1109

-

res=0

1110

-

Binary:

1111

-

val=0000000000000000000000000000000000000000000000000000000000000100

1112

-

res=0000000000000000000000000000000000000000000000000000000000000000

1113

-

NOTE: bits shift out right side

1114

-

1115

-

Expression: 0 = 4 >> 4

1116

-

Decimal:

1117

-

val=4

1118

-

res=0

1119

-

Binary:

1120

-

val=0000000000000000000000000000000000000000000000000000000000000100

1121

-

res=0000000000000000000000000000000000000000000000000000000000000000

1122

-

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

1123

-

1124

-

1125

-

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

1126

-

Expression: -2 = -4 >> 1

1127

-

Decimal:

1128

-

val=-4

1129

-

res=-2

1130

-

Binary:

1131

-

val=1111111111111111111111111111111111111111111111111111111111111100

1132

-

res=1111111111111111111111111111111111111111111111111111111111111110

1133

-

NOTE: copy of sign bit shifted into left side

1134

-

1135

-

Expression: -1 = -4 >> 2

1136

-

Decimal:

1137

-

val=-4

1138

-

res=-1

1139

-

Binary:

1140

-

val=1111111111111111111111111111111111111111111111111111111111111100

1141

-

res=1111111111111111111111111111111111111111111111111111111111111111

1142

-

NOTE: bits shift out right side

1143

-

1144

-

Expression: -1 = -4 >> 3

1145

-

Decimal:

1146

-

val=-4

1147

-

res=-1

1148

-

Binary:

1149

-

val=1111111111111111111111111111111111111111111111111111111111111100

1150

-

res=1111111111111111111111111111111111111111111111111111111111111111

1151

-

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

1152

-

1153

-

1154

-

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

1155

-

Expression: 8 = 4 << 1

1156

-

Decimal:

1157

-

val=4

1158

-

res=8

1159

-

Binary:

1160

-

val=0000000000000000000000000000000000000000000000000000000000000100

1161

-

res=0000000000000000000000000000000000000000000000000000000000001000

1162

-

NOTE: zeros fill in right side

1163

-

1164

-

Expression: 4611686018427387904 = 4 << 60

1165

-

Decimal:

1166

-

val=4

1167

-

res=4611686018427387904

1168

-

Binary:

1169

-

val=0000000000000000000000000000000000000000000000000000000000000100

1170

-

res=0100000000000000000000000000000000000000000000000000000000000000

1171

-

1172

-

Expression: -9223372036854775808 = 4 << 61

1173

-

Decimal:

1174

-

val=4

1175

-

res=-9223372036854775808

1176

-

Binary:

1177

-

val=0000000000000000000000000000000000000000000000000000000000000100

1178

-

res=1000000000000000000000000000000000000000000000000000000000000000

1179

-

NOTE: sign bits get shifted out

1180

-

1181

-

Expression: 0 = 4 << 62

1182

-

Decimal:

1183

-

val=4

1184

-

res=0

1185

-

Binary:

1186

-

val=0000000000000000000000000000000000000000000000000000000000000100

1187

-

res=0000000000000000000000000000000000000000000000000000000000000000

1188

-

NOTE: bits shift out left side

1189

-

1190

-

1191

-

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

1192

-

Expression: -8 = -4 << 1

1193

-

Decimal:

1194

-

val=-4

1195

-

res=-8

1196

-

Binary:

1197

-

val=1111111111111111111111111111111111111111111111111111111111111100

1198

-

res=1111111111111111111111111111111111111111111111111111111111111000

1199

-

NOTE: zeros fill in right side

1200

-

1201

-

Expression: -9223372036854775808 = -4 << 61

1202

-

Decimal:

1203

-

val=-4

1204

-

res=-9223372036854775808

1205

-

Binary:

1206

-

val=1111111111111111111111111111111111111111111111111111111111111100

1207

-

res=1000000000000000000000000000000000000000000000000000000000000000

1208

-

1209

-

Expression: 0 = -4 << 62

1210

-

Decimal:

1211

-

val=-4

1212

-

res=0

1213

-

Binary:

1214

-

val=1111111111111111111111111111111111111111111111111111111111111100

1215

-

res=0000000000000000000000000000000000000000000000000000000000000000

1216

-

NOTE: bits shift out left side, including sign bit

1217

-

]]>

1218

-

</screen>

1219

-

</example>

1220

-

</para>

1221

-

<warning>

1222

-

<para>

1223

-

Shifting integers by values greater than or equal to the system long

1224

-

integer width results in undefined behavior. In other words, don't shift

1225

-

more than 31 bits on a 32-bit system, and don't shift more than 63 bits on

1226

-

a 64-bit system.

1227

-

</para>

1228

-

<para>

1229

-

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

1230

-

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

1231

-

</para>

1232

-

</warning>

1233

-

<para>

1234

-

See also

1235

-

<function>pack</function>,

1236

-

<function>unpack</function>,

1237

-

<function>gmp_and</function>,

1238

-

<function>gmp_or</function>,

1239

-

<function>gmp_xor</function>,

1240

-

<function>gmp_testbit</function>,

1241

-

<function>gmp_clrbit</function>

1242

-

</para>

1243

-

</sect1>

1244

-

1245

-

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

1246

-

<title>Comparison Operators</title>

1247

-

<simpara>

1248

-

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

1249

-

two values. You may also be interested in viewing

1250

-

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

1251

-

as they show examples of various type related comparisons.

1252

-

</simpara>

1253

-

<table>

1254

-

<title>Comparison Operators</title>

1255

-

<tgroup cols="3">

1256

-

<thead>

1257

-

<row>

1258

-

<entry>Example</entry>

1259

-

<entry>Name</entry>

1260

-

<entry>Result</entry>

1261

-

</row>

1262

-

</thead>

1263

-

<tbody>

1264

-

<row>

1265

-

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

1266

-

<entry>Equal</entry>

1267

-

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

1268

-

</row>

1269

-

<row>

1270

-

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

1271

-

<entry>Identical</entry>

1272

-

<entry>

1273

-

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

1274

-

type.

1275

-

</entry>

1276

-

</row>

1277

-

<row>

1278

-

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

1279

-

<entry>Not equal</entry>

1280

-

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

1281

-

</row>

1282

-

<row>

1283

-

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

1284

-

<entry>Not equal</entry>

1285

-

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

1286

-

</row>

1287

-

<row>

1288

-

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

1289

-

<entry>Not identical</entry>

1290

-

<entry>

1291

-

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

1292

-

type.

1293

-

</entry>

1294

-

</row>

1295

-

<row>

1296

-

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

1297

-

<entry>Less than</entry>

1298

-

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

1299

-

</row>

1300

-

<row>

1301

-

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

1302

-

<entry>Greater than</entry>

1303

-

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

1304

-

</row>

1305

-

<row>

1306

-

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

1307

-

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

1308

-

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

1309

-

</row>

1310

-

<row>

1311

-

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

1312

-

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

1313

-

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

1314

-

</row>

1315

-

<row>

1316

-

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

1317

-

<entry>Spaceship</entry>

1318

-

<entry>

1319

-

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

1320

-

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

1321

-

than <varname>$b</varname>. Available as of PHP 7.

1322

-

</entry>

1323

-

</row>

1324

-

</tbody>

1325

-

</tgroup>

1326

-

</table>

1327

-

<para>

1328

-

If you compare a number with a string or the comparison involves numerical

1329

-

strings, then each string is

1330

-

<link linkend="language.types.string.conversion">converted to a number</link>

1331

-

and the comparison performed numerically. These rules also apply to the

1332

-

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

1333

-

type conversion does not take place when the comparison is === or !== as

1334

-

this involves comparing the type as well as the value.

1335

-

<informalexample>

1336

-

<programlisting role="php">

1337

-

<![CDATA[

1338

-

<?php

1339

-

var_dump(0 == "a"); // 0 == 0 -> true

1340

-

var_dump("1" == "01"); // 1 == 1 -> true

1341

-

var_dump("10" == "1e1"); // 10 == 10 -> true

1342

-

var_dump(100 == "1e2"); // 100 == 100 -> true

1343

-

1344

-

switch ("a") {

1345

-

case 0:

1346

-

echo "0";

1347

-

break;

1348

-

case "a": // never reached because "a" is already matched with 0

1349

-

echo "a";

1350

-

break;

1351

-

}

1352

-

?>

1353

-

]]>

1354

-

</programlisting>

1355

-

<programlisting role="php">

1356

-

<![CDATA[

1357

-

<?php

1358

-

// Integers

1359

-

echo 1 <=> 1; // 0

1360

-

echo 1 <=> 2; // -1

1361

-

echo 2 <=> 1; // 1

1362

-

1363

-

// Floats

1364

-

echo 1.5 <=> 1.5; // 0

1365

-

echo 1.5 <=> 2.5; // -1

1366

-

echo 2.5 <=> 1.5; // 1

1367

-

1368

-

// Strings

1369

-

echo "a" <=> "a"; // 0

1370

-

echo "a" <=> "b"; // -1

1371

-

echo "b" <=> "a"; // 1

1372

-

1373

-

echo "a" <=> "aa"; // -1

1374

-

echo "zz" <=> "aa"; // 1

1375

-

1376

-

// Arrays

1377

-

echo [] <=> []; // 0

1378

-

echo [1, 2, 3] <=> [1, 2, 3]; // 0

1379

-

echo [1, 2, 3] <=> []; // 1

1380

-

echo [1, 2, 3] <=> [1, 2, 1]; // 1

1381

-

echo [1, 2, 3] <=> [1, 2, 4]; // -1

1382

-

1383

-

// Objects

1384

-

$a = (object) ["a" => "b"];

1385

-

$b = (object) ["a" => "b"];

1386

-

echo $a <=> $b; // 0

1387

-

1388

-

$a = (object) ["a" => "b"];

1389

-

$b = (object) ["a" => "c"];

1390

-

echo $a <=> $b; // -1

1391

-

1392

-

$a = (object) ["a" => "c"];

1393

-

$b = (object) ["a" => "b"];

1394

-

echo $a <=> $b; // 1

1395

-

1396

-

// only values are compared

1397

-

$a = (object) ["a" => "b"];

1398

-

$b = (object) ["b" => "b"];

1399

-

echo $a <=> $b; // 1

1400

-

1401

-

?>

1402

-

]]>

1403

-

1404

-

</programlisting>

1405

-

</informalexample>

1406

-

</para>

1407

-

1408

-

<para>

1409

-

For various types, comparison is done according to the following

1410

-

table (in order).

1411

-

</para>

1412

-

<table xml:id="language.operators.comparison.types">

1413

-

<title>Comparison with Various Types</title>

1414

-

<tgroup cols="3">

1415

-

<thead>

1416

-

<row>

1417

-

<entry>Type of Operand 1</entry>

1418

-

<entry>Type of Operand 2</entry>

1419

-

<entry>Result</entry>

1420

-

</row>

1421

-

</thead>

1422

-

<tbody>

1423

-

<row>

1424

-

<entry><type>null</type> or <type>string</type></entry>

1425

-

<entry><type>string</type></entry>

1426

-

<entry>Convert &null; to "", numerical or lexical comparison</entry>

1427

-

</row>

1428

-

<row>

1429

-

<entry><type>bool</type> or <type>null</type></entry>

1430

-

<entry>anything</entry>

1431

-

<entry>Convert both sides to <type>bool</type>, &false; &lt; &true;</entry>

1432

-

</row>

1433

-

<row>

1434

-

<entry><type>object</type></entry>

1435

-

<entry><type>object</type></entry>

1436

-

<entry>Built-in classes can define its own comparison, different classes

1437

-

are uncomparable, same class - compare properties the same way as

1438

-

arrays (PHP 4), PHP 5 has its own <link

1439

-

linkend="language.oop5.object-comparison">explanation</link>

1440

-

</entry>

1441

-

</row>

1442

-

<row>

1443

-

<entry><type>string</type>, <type>resource</type> or <type>number</type></entry>

1444

-

<entry><type>string</type>, <type>resource</type> or <type>number</type></entry>

1445

-

<entry>Translate strings and resources to numbers, usual math</entry>

1446

-

</row>

1447

-

<row>

1448

-

<entry><type>array</type></entry>

1449

-

<entry><type>array</type></entry>

1450

-

<entry>Array with fewer members is smaller, if key from operand 1 is not

1451

-

found in operand 2 then arrays are uncomparable, otherwise - compare

1452

-

value by value (see following example)</entry>

1453

-

</row>

1454

-

<row>

1455

-

<entry><type>object</type></entry>

1456

-

<entry>anything</entry>

1457

-

<entry><type>object</type> is always greater</entry>

1458

-

</row>

1459

-

<row>

1460

-

<entry><type>array</type></entry>

1461

-

<entry>anything</entry>

1462

-

<entry><type>array</type> is always greater</entry>

1463

-

</row>

1464

-

</tbody>

1465

-

</tgroup>

1466

-

</table>

1467

-

1468

-

<para>

1469

-

<example>

1470

-

<title>Boolean/null comparison</title>

1471

-

<programlisting role="php">

1472

-

<![CDATA[

1473

-

<?php

1474

-

// Bool and null are compared as bool always

1475

-

var_dump(1 == TRUE); // TRUE - same as (bool)1 == TRUE

1476

-

var_dump(0 == FALSE); // TRUE - same as (bool)0 == FALSE

1477

-

var_dump(100 < TRUE); // FALSE - same as (bool)100 < TRUE

1478

-

var_dump(-10 < FALSE);// FALSE - same as (bool)-10 < FALSE

1479

-

var_dump(min(-100, -10, NULL, 10, 100)); // NULL - (bool)NULL < (bool)-100 is FALSE < TRUE

1480

-

?>

1481

-

]]>

1482

-

</programlisting>

1483

-

</example>

1484

-

</para>

1485

-

1486

-

1487

-

<para>

1488

-

<example>

1489

-

<title>Transcription of standard array comparison</title>

1490

-

<programlisting role="php">

1491

-

<![CDATA[

1492

-

<?php

1493

-

// Arrays are compared like this with standard comparison operators

1494

-

function standard_array_compare($op1, $op2)

1495

-

{

1496

-

if (count($op1) < count($op2)) {

1497

-

return -1; // $op1 < $op2

1498

-

} elseif (count($op1) > count($op2)) {

1499

-

return 1; // $op1 > $op2

1500

-

}

1501

-

foreach ($op1 as $key => $val) {

1502

-

if (!array_key_exists($key, $op2)) {

1503

-

return null; // uncomparable

1504

-

} elseif ($val < $op2[$key]) {

1505

-

return -1;

1506

-

} elseif ($val > $op2[$key]) {

1507

-

return 1;

1508

-

}

1509

-

}

1510

-

return 0; // $op1 == $op2

1511

-

}

1512

-

?>

1513

-

]]>

1514

-

</programlisting>

1515

-

</example>

1516

-

</para>

1517

-

1518

-

<para>

1519

-

See also <function>strcasecmp</function>,

1520

-

<function>strcmp</function>,

1521

-

<link linkend="language.operators.array">Array operators</link>,

1522

-

and the manual section on

1523

-

<link linkend="language.types">Types</link>.

1524

-

</para>

1525

-

1526

-

<warning>

1527

-

<title>Comparison of floating point numbers</title>

1528

-

1529

-

<para>

1530

-

Because of the way <type>float</type>s are represented internally, you

1531

-

should not test two <type>float</type>s for equality.

1532

-

</para>

1533

-

1534

-

<para>

1535

-

See the documentation for <type>float</type> for more information.

1536

-

</para>

1537

-

</warning>

1538

-

1539

-

<sect2 xml:id="language.operators.comparison.ternary">

1540

-

<title>Ternary Operator</title>

1541

-

<para>

1542

-

Another conditional operator is the "?:" (or ternary) operator.

1543

-

<example>

1544

-

<title>Assigning a default value</title>

1545

-

<programlisting role="php">

1546

-

<![CDATA[

1547

-

<?php

1548

-

// Example usage for: Ternary Operator

1549

-

$action = (empty($_POST['action'])) ? 'default' : $_POST['action'];

1550

-

1551

-

// The above is identical to this if/else statement

1552

-

if (empty($_POST['action'])) {

1553

-

$action = 'default';

1554

-

} else {

1555

-

$action = $_POST['action'];

1556

-

}

1557

-

1558

-

?>

1559

-

]]>

1560

-

</programlisting>

1561

-

</example>

1562

-

The expression <literal>(expr1) ? (expr2) : (expr3)</literal>

1563

-

evaluates to <replaceable>expr2</replaceable> if

1564

-

<replaceable>expr1</replaceable> evaluates to &true;, and

1565

-

<replaceable>expr3</replaceable> if

1566

-

<replaceable>expr1</replaceable> evaluates to &false;.

1567

-

</para>

1568

-

<para>

1569

-

Since PHP 5.3, it is possible to leave out the middle part of the ternary

1570

-

operator. Expression <literal>expr1 ?: expr3</literal> returns

1571

-

<replaceable>expr1</replaceable> if <replaceable>expr1</replaceable>

1572

-

evaluates to &true;, and <replaceable>expr3</replaceable> otherwise.

1573

-

</para>

1574

-

<note>

1575

-

<simpara>