Methods and $this keyword in PHP - Time & Space Complexity

Time Complexity: Methods and $this keyword

O(n)

Understanding Time Complexity

When using methods and the $this keyword in PHP classes, it's important to know how the program's running time changes as the input or object size grows.

We want to understand how calling methods and accessing properties with $this affects the number of steps the program takes.

Scenario Under Consideration

Analyze the time complexity of the following code snippet.

class Counter {
    private array $items;

    public function __construct(array $items) {
        $this->items = $items;
    }

    public function countItems(): int {
        $count = 0;
        foreach ($this->items as $item) {
            $count++;
        }
        return $count;
    }
}

This code defines a class with a method that counts how many items are stored in an array property accessed via $this.

Identify Repeating Operations

Identify the loops, recursion, array traversals that repeat.

• Primary operation: Looping through the $this->items array inside the countItems method.
• How many times: Once for each item in the array, so as many times as the array length.

How Execution Grows With Input

As the number of items in the array grows, the method loops through each one once.

Input Size (n)	Approx. Operations
10	About 10 loops
100	About 100 loops
1000	About 1000 loops

Pattern observation: The number of steps grows directly with the number of items. Double the items, double the work.

Final Time Complexity

Time Complexity: O(n)

This means the time to count items grows in a straight line with the number of items in the array.

Common Mistake

[X] Wrong: "Using $this inside a method makes the code slower regardless of input size."

[OK] Correct: Accessing properties with $this itself is very fast and does not add extra loops. The main time depends on how many items you process, not just using $this.

Interview Connect

Understanding how methods and $this work together helps you explain how object-oriented code runs efficiently as data grows. This skill shows you can think about code performance clearly.

Self-Check

"What if the countItems method called another method inside the loop? How would that affect the time complexity?"

Practice

1. What does the $this keyword represent inside a PHP class method?

easy

A. A global variable

B. A static variable

C. The current object instance

D. The class name

Solution

1. Step 1: Understand the role of $this in PHP classes

   $this is used inside class methods to refer to the current object instance that called the method.

2. Step 2: Differentiate from other options

   It is not a static or global variable, nor does it represent the class name itself.

3. Final Answer:

   The current object instance -> Option C

4. Quick Check:

   $this = current object instance [OK]

Hint: Remember: $this always means 'this object' [OK]

Common Mistakes:

• Confusing $this with static variables
• Thinking $this is the class name
• Assuming $this is a global variable

2. Which of the following is the correct way to call a method named greet inside a PHP class using $this?

easy

A. this->greet();

B. self->greet();

C. $this.greet();

D. $this->greet();

Solution

1. Step 1: Recall PHP method call syntax inside classes

   Methods are called on objects using the arrow operator -> with $this representing the current object.

2. Step 2: Check each option

   $this->greet(); is the correct syntax. The other options use invalid syntax.

3. Final Answer:

   $this->greet(); -> Option D

4. Quick Check:

   Method call syntax = $this->method(); [OK]

Hint: Use $this->methodName(); to call methods inside class [OK]

Common Mistakes:

• Using dot (.) instead of arrow (->) operator
• Omitting the dollar sign in $this
• Using self without scope resolution operator

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

class Person {
  public $name = 'Alice';
  public function sayName() {
    return 'Name: ' . $this->name;
  }
}
$p = new Person();
echo $p->sayName();

medium

A. Name: Alice

B. Name: $name

C. Name:

D. Error: Undefined property

Solution

1. Step 1: Understand property access with $this

   The method sayName() returns the string 'Name: ' concatenated with the object's name property accessed via $this->name.

2. Step 2: Check the property value and output

   The property name is set to 'Alice', so the output will be 'Name: Alice'.

3. Final Answer:

   Name: Alice -> Option A

4. Quick Check:

   Property accessed via $this = 'Alice' [OK]

Hint: Remember: $this->property accesses current object's data [OK]

Common Mistakes:

• Forgetting to use $this to access properties
• Expecting literal string output without variable substitution
• Confusing property name with string '$name'

4. Identify the error in this PHP class method:

class Car {
  public $model = 'Tesla';
  public function getModel() {
    return $model;
  }
}

medium

A. Missing $this when accessing $model

B. Method name should be GetModel with capital G

C. Property $model must be private

D. Return statement should be return $this->getModel;

Solution

1. Step 1: Check property access inside method

   Inside class methods, properties must be accessed with $this->propertyName. Here, $model is used without $this->.

2. Step 2: Validate other options

   Method names are case-insensitive in PHP, property visibility is not an error here, and the suggested return $this->getModel; is incorrect.

3. Final Answer:

   Missing $this when accessing $model -> Option A

4. Quick Check:

   Use $this->property to access properties [OK]

Hint: Always use $this-> to access object properties inside methods [OK]

Common Mistakes:

• Accessing properties without $this->
• Confusing method name case sensitivity
• Misunderstanding property visibility rules

5. Given the class below, what will be the output?

class Counter {
  private $count = 0;
  public function increment() {
    $this->count++;
  }
  public function getCount() {
    return $this->count;
  }
}
$c = new Counter();
$c->increment();
$c->increment();
echo $c->getCount();

hard

A. Error: Cannot access private property

B. 2

C. 1

D. 0

Solution

1. Step 1: Understand property increment inside the class

   The increment() method increases the private $count property by 1 each time it is called.

2. Step 2: Trace method calls and final output

   Calling increment() twice increases $count from 0 to 2. Then getCount() returns 2.

3. Final Answer:

   2 -> Option B

4. Quick Check:

   Two increments = count 2 [OK]

Hint: Private properties accessed via $this inside class work fine [OK]

Common Mistakes:

• Assuming private properties can't be accessed inside class methods
• Forgetting that increment operator changes value
• Expecting output before increments