Loose comparison vs strict comparison in PHP

Introduction

Loose and strict comparisons help you check if two values are equal in different ways. Loose comparison is flexible, strict comparison is exact.

When you want to check if two values are equal but don't care about their types.

When you want to make sure two values are exactly the same, including their types.

When comparing user input that might be a string or number.

When checking if a variable is exactly true or false, not just truthy or falsy.

Syntax

PHP

$a == $b;  // Loose comparison
$a === $b; // Strict comparison

Loose comparison (==) converts types if needed before comparing.

Strict comparison (===) checks both value and type without conversion.

Examples

Loose comparison says true because '5' and 5 are equal after type conversion.Strict comparison says false because one is integer and the other is string.

PHP

$a = 5;
$b = '5';
var_dump($a == $b);  // true
var_dump($a === $b); // false

Loose comparison treats 0 and false as equal.Strict comparison sees different types and returns false.

PHP

$x = 0;
$y = false;
var_dump($x == $y);  // true
var_dump($x === $y); // false

Loose comparison treats null and empty string as not equal.Strict comparison sees different types and returns false.

PHP

$m = null;
$n = '';
var_dump($m == $n);  // false
var_dump($m === $n); // false

Sample Program

This program shows how loose comparison (==) treats 10 and '10' as equal, but strict comparison (===) does not because of type difference.

It also shows strict comparison returns true when both value and type match.

PHP

<?php
$a = 10;
$b = '10';
$c = 10;
$d = 20;

// Loose comparisons
var_dump($a == $b); // true
var_dump($a == $d); // false

// Strict comparisons
var_dump($a === $b); // false
var_dump($a === $c); // true

Important Notes

Loose comparison can lead to unexpected results if you don't know how PHP converts types.

Use strict comparison when you want to avoid bugs caused by type juggling.

Remember that null, false, 0, and empty strings can behave unexpectedly with loose comparison.

Summary

Loose comparison (==) checks if values are equal after converting types.

Strict comparison (===) checks if values and types are exactly the same.

Use strict comparison to avoid surprises and bugs.

Practice

1. What is the main difference between == and === in PHP?

easy

A. == compares values after type conversion, === compares value and type exactly

B. == compares only types, === compares only values

C. == is used for assignment, === is used for comparison

D. == compares memory addresses, === compares values

Solution

1. Step 1: Understand loose comparison

   Loose comparison (==) converts types if needed and then compares values.

2. Step 2: Understand strict comparison

   Strict comparison (===) checks both value and type without conversion.

3. Final Answer:

   == compares values after type conversion, === compares value and type exactly -> Option A

4. Quick Check:

   Loose == vs Strict === = == compares values after type conversion, === compares value and type exactly [OK]

Hint: Remember: === means exactly equal type and value [OK]

Common Mistakes:

• Thinking == compares types only
• Confusing assignment (=) with comparison (==)
• Assuming === converts types before comparing

2. Which of the following is the correct syntax for strict comparison in PHP?

easy

A. $a = $b;

B. $a !== $b;

C. $a == $b;

D. $a === $b;

Solution

1. Step 1: Identify strict comparison operator

   Strict comparison uses three equal signs: ===.

2. Step 2: Check syntax correctness

   $a === $b; is valid syntax for strict comparison.

3. Final Answer:

   $a === $b; -> Option D

4. Quick Check:

   Strict comparison syntax = $a === $b; [OK]

Hint: Use three equal signs for strict comparison [OK]

Common Mistakes:

• Typing == instead of ===
• Using = which is assignment, not comparison
• Confusing == (loose) with === (strict)

3. What will be the output of the following PHP code?

$a = 0;
$b = '0';
if ($a == $b) {
    echo 'Equal';
} else {
    echo 'Not Equal';
}
if ($a === $b) {
    echo ' Strictly Equal';
} else {
    echo ' Not Strictly Equal';
}

medium

A. Equal Strictly Equal

B. Not Equal Strictly Equal

C. Equal Not Strictly Equal

D. Not Equal Not Strictly Equal

Solution

1. Step 1: Evaluate loose comparison ($a == $b)

   $a is integer 0, $b is string '0'. Loose comparison converts types, so 0 == '0' is true, prints 'Equal'.

2. Step 2: Evaluate strict comparison ($a === $b)

   Strict comparison checks type and value. Integer 0 !== string '0', so false, prints ' Not Strictly Equal'.

3. Final Answer:

   Equal Not Strictly Equal -> Option C

4. Quick Check:

   0 == '0' true, 0 === '0' false = Equal Not Strictly Equal [OK]

Hint: Loose ignores type, strict checks type too [OK]

Common Mistakes:

• Assuming strict comparison returns true for 0 and '0'
• Confusing output order
• Ignoring spaces in echoed strings

4. Find the error in this PHP code snippet:

$x = '10';
if ($x = 10) {
    echo 'Match';
} else {
    echo 'No Match';
}

medium

A. Using assignment (=) instead of comparison (==) in if condition

B. Missing semicolon after echo statement

C. Using double quotes instead of single quotes

D. Variable $x is not defined

Solution

1. Step 1: Check if condition operator

   The condition uses = which assigns 10 to $x instead of comparing.

2. Step 2: Understand effect of assignment in if

   Assignment returns 10 (truthy), so 'Match' always prints, ignoring original $x value.

3. Final Answer:

   Using assignment (=) instead of comparison (==) in if condition -> Option A

4. Quick Check:

   Assignment in if condition = Using assignment (=) instead of comparison (==) in if condition [OK]

Hint: Use == or === for comparison, not = [OK]

Common Mistakes:

• Confusing = with == in conditions
• Thinking missing semicolon causes error here
• Assuming quotes affect comparison operator

5. You want to check if a user input variable $input is exactly the integer 0 (zero) and not a string '0' or other falsy value. Which condition is the best to use?

hard

A. if ($input == 0)

B. if ($input === 0)

C. if ($input != 0)

D. if ($input !== 0)

Solution

1. Step 1: Understand the requirement

   We want to check if $input is integer 0 exactly, not string '0' or other falsy values.

2. Step 2: Choose strict comparison

   == allows type conversion, so string '0' == 0 is true, which is not desired. === checks type and value strictly.

3. Final Answer:

   if ($input === 0) -> Option B

4. Quick Check:

   Exact type and value check = if ($input === 0) [OK]

Hint: Use === to check exact type and value [OK]

Common Mistakes:

• Using == and getting true for string '0'
• Using != or !== which check for inequality
• Ignoring type differences in comparisons