Solution:

In my index.php I'm loading maybe foobarfunc() like this:

 foobar::foobarfunc();  // Wrong, it is not static method
Copy code

but can also be

$foobar = new foobar;  // correct
$foobar->foobarfunc();
Copy code

You can not invoke method this way because it is not static method.

foobar::foobarfunc();
Copy code

You should instead use:

foobar->foobarfunc();
Copy code

If however you have created a static method something like:

static $foo; // your top variable set as static

public static function foo() {
    return self::$foo;
}
Copy code

then you can use this:

foobar::foobarfunc();
Copy code

Solution:

You are calling a non-static method :

public function foobarfunc() {
    return $this->foo();
}
Copy code

Using a static-call :

foobar::foobarfunc();
Copy code

When using a static-call, the function will be called (even if not declared asstatic), but, as there is no instance of an object, there is no$this.

So :

• You should not use static calls for non-static methods
• Your static methods (or statically-called methods) can't use $this, which normally points to the current instance of the class, as there is no class instance when you're using static-calls.

Here, the methods of your class are using the current instance of the class, as they need to access the$foo property of the class.

This means your methods need an instance of the class -- which means they cannot be static.

This means you shouldn't use static calls : you should instanciate the class, and use the object to call the methods, like you did in your last portion of code :

$foobar = new foobar();
$foobar->foobarfunc();
Copy code

For more informations, don't hesitate to read, in the PHP manual :

• The Classes and Objects section
• And the Static Keyword page.

Also note that you probably don't need this line in your__construct method :

global $foo;
Copy code

Using the will make the$foo variable, declared outside of all functions and classes, visibile from inside that method... And you probably don't have such a$foo variable.

To access the$foo class-property, you only need to use$this->foo, like you did.

Solution:

If you are invokingfoobarfunc with resolution scope operator (::), then you are calling it statically, e.g. on the class level instead of the instance level, thus you are using$this when not in object context.$this does not exist in class context.

If you enableE_STRICT, PHP will raise a Notice about this:

Strict Standards: 
Non-static method foobar::foobarfunc() should not be called statically
Copy code

Do this instead

$fb = new foobar;
echo $fb->foobarfunc();
Copy code

On a sidenote, I suggest not to useglobal inside your classes. If you need something from outside inside your class, pass it through the constructor. This is called Dependency Injection and it will make your code much more maintainable and less dependant on outside things.

Solution:

First you understand one thing, $this inside a class denotes the current object.
That is which is you are created out side of the class to call class function or variable.

So when you are calling your class function like foobar::foobarfunc(), object is not created. But inside that function you written return $this->foo(). Now here $this is nothing. Thats why its saying Using $this when not in object context in class.php

Solutions:

1. Create a object and call foobarfunc().

2. Call foo() using class name inside the foobarfunc().

Solution:

Fast method : (new foobar())->foobarfunc();

You need to load your class replace :

foobar::foobarfunc();
Copy code

by :

(new foobar())->foobarfunc();
Copy code

or :

$Foobar = new foobar();
$Foobar->foobarfunc();
Copy code

Or make static function to usefoobar::.

class foobar {
    //...

    static function foobarfunc() {
        return $this->foo();
    }
}
Copy code

Solution:

When you call the function in a static context,$this simply doesn't exist.

You would have to usethis::xyz() instead.

To find out what context you're in when a function can be called both statically and in an object instance, a good approach is outlined in this question:

Solution:

It seems to me to be a bug in PHP. The error

'Fatal error: Uncaught Error: Using $this when not in object context in'

appears in the function using$this, but the error is that the calling function is using non-static function as a static. I.e:

Class_Name
{
    function foo()
    {
        $this->do_something(); // The error appears there.
    }
    function do_something()
    {
        ///
    }
}
Copy code

While the error is here:

Class_Name::foo();
Copy code

Solution:

$foobar = new foobar; put the class foobar in $foobar, not the object. To get the object, you need to add parenthesis:$foobar = new foobar();

Your error is simply that you call a method on a class, so there is no$this since$this only exists in objects.

Solution:

Just use the Class method using thisfoobar->foobarfunc();