Access a non-static property from a static method

Question

class database{
    protected $db;

    protected function connect(){
        $this->db = new mysqli( /* DB info */ ); // Connecting to a database
    }
}

class example extends database{
    public function __construct(){
        $this->connect();
    }

    public static function doQuery(){
        $query = $this->db->query("theQuery");   // Not working.
        $query = self::$db->query("theQuery");   // Not working.
        $query = parent::$db->query("theQuery"); // Also not working.
    }
}

I want to do something like that but I cant find a way that works, The property has to static...

would it not be easier to make the static method into a regular method without the static keyword. — Nahser Bakht, Feb 27 '13 at 17:35
`$this` does not exist in static methods. what you want is impossible, unless you pass in a copy of `$this` as a parameter from wherever you're calling the static method. — Marc B, Feb 27 '13 at 17:35
I need this to be a static method because i use it without an instance. — WhiteBlue, Feb 27 '13 at 17:37
doQuery() is a static method so using '$this' inside doQuery makes no sense at all!! — kunal18, Jun 26 '13 at 10:06

score 23 · Answer 1 · edited Jul 11 '19 at 14:37

You may access by instantiating a new object ($self = new static;). The sample code:

class Database{

    protected $db;

    protected function connect(){
        $this->db = new mysqli( /* DB info */ ); // Connecting to a database
    }
}


class Example extends Database{

    public function __construct(){
        $this->connect();
    }

    public static function doQuery(){

        $self = new static; //OBJECT INSTANTIATION
        $query = $self->db->query("theQuery");   // working.

    }
}

This is the same as calling $self = new Example; but more programmatically, if the class name is ever changed it does not need updating.

score 10 · Answer 2 · edited Mar 25 '21 at 15:39

You cannot access non-static properties from static methods. Non-static properties belong only to instantiated objects, where every instantiated object has a separate property value.

I will illustrate on an example, this code doesn't work:

class Example {
    public $a;

    public function __construct($a) {
        $this->a = $a;
    }
    public static function getA() {
        return $this->a;
    }
}

$first = new Example(3);
$second = new Example(4);

// is $value equal to 3 or 4?
$value = Example::getA();

score 4 · Answer 3 · answered Jun 26 '13 at 09:53

as marko said You cannot access non-static properties from static methods. if possible change your property to static and then your code works.

I did something like this..

class Member_DashBoard extends Page {

  public static $lapsed_id = 4; //Membership lapsed status id


    //calling static function by passing static property
    $status_custom = self::getMembershipStatusLapsed(self::$lapsed_id);//
                $status_custom_id = $status_custom['id'];



      public static function getMembershipStatusLapsed($membershipStatusId) {

        $statusDetails = array();
        $membershipStatus = new Core_MembershipStatus();
        $membershipStatus->id = $membershipStatusId;
        if ($membershipStatus->find(TRUE)) {
          Core_DAO::storeValues($membershipStatus, $statusDetails);
        }

        return $statusDetails;
      }


    }

hope it helps someone :)

--cheers

score 2 · Answer 4 · answered Mar 20 '19 at 22:08

You can access a private or protected property from a static method

class foo {
  private $x;
  static public function create()
  {
    $obj = new self();
    $obj->x = 22;
    return $obj;
  }
}

$y = foo::create();
var_dump($y);
// object(foo)[1]
//  private 'x' => int 22

// ----------------------
// this could just as easily be a normal method $bar->modify();

class bar {
  private $x;
  static public function modify(bar $bar)
  {
    $bar->x = 23;
  }
}

$bar = new bar();
bar::modify($bar);
var_dump($bar);
// object(bar)[2]
//  private 'x' => int 23

score 1 · Answer 5 · answered Sep 11 '14 at 20:01

It is best to determine the specifications for the object when creating it and it sounds like your specification of the object doesn't match the pattern you chose.

Generally you should ask yourself, "Do I only need to have a single instance of an object (static) or more than one?"

For this particular instance (connect to and query a database), having an instantiated object for the database object is not advisable unless you need to establish multiple connections to the database/s.

Thusly you have a use-case for an instanced vs static object. Multiple concurrent connections could overload the database, depending on the configuration and how many times a connection is created in a single execution.

So with that in mind there are several OOP design "patterns" for PHP available to aid in the architecture of object/s. See http://www.slideshare.net/RobertGonzalez/object-oriented-design-patterns-for-php-presentation for a good walk through of the more common patterns.

For a working example http://ideone.com/6qxvqx

Note I renamed mysqli to mysqli2 and created a fake class to handle query and added some tracking to the connection and object creation.

<?php

interface iDatabase
{
   static public function execute();
   public function instantiatedExecute();
}

abstract class database implements iDatabase
{

    protected static $conn;

    /**
     * create an instance of database that uses the same connection across all instances
     */
    final public function __construct()
    {
        self::connect();
    }

    /**
     * Connect to a database if not already connected
     */
    final protected static function connect()
    {
        if (null === self::$conn || false === (self::$conn instanceof mysqli)) {
            self::$conn = new mysqli( /* DB info */ );
            //add error checking here...
        }
        return self::$conn;
    }

   /**
    * query database connection
    */
   final public function query($query)
   {
       return self::doQuery($query);
   }

   /**
    * static query database connection
    */
   final public static function doQuery($query)
   {

      //sanitize query here if desired
      return self::connect()->query($query);
   }

}

class example extends database
{

    /**
     * example specific static execution
     */
    public static function execute($query)
    {
        self::doQuery($query);
    }

    /**
     * example specific non-static execution
     */
    public function instantiatedExecute($query)
    {
       $this->query($query);
    }
}

score 0 · Answer 6 · edited May 23 '17 at 12:09

0

Access a non-static property from a static method

7 Answers7

Linked