Ho un problema:

Sto scrivendo una nuova WebApp senza un framework.

Nel mio index.php sto usando:require_once('load.php');

E in load.php sto usando require_once('class.php');per caricare il mio class.php .

Nel mio class.php ho questo errore:

Errore irreversibile: usare $ this quando non è nel contesto dell'oggetto in class.php on line ... (in questo esempio sarebbe 11)

Un esempio di come è scritto il mio class.php :

class foobar {

    public $foo;

    public function __construct() {
        global $foo;

        $this->foo = $foo;
    }

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

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

Nel mio index.php sto caricando forse in foobarfunc()questo modo:

foobar::foobarfunc();

ma può anche essere

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

Perché sta arrivando l'errore?

Nel mio index.php sto caricando forse foobarfunc () in questo modo:

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

ma può anche essere

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

Non è possibile richiamare il metodo in questo modo perché non è un metodo statico.

foobar::foobarfunc();

Dovresti invece usare:

foobar->foobarfunc();

Se tuttavia hai creato un metodo statico simile al seguente:

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

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

allora puoi usare questo:

foobar::foobarfunc();

Stai chiamando un metodo non statico:

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

Utilizzando una chiamata statica:

foobar::foobarfunc();

Quando si utilizza una chiamata statica, la funzione verrà chiamata (anche se non dichiarata come static) , ma, poiché non esiste un'istanza di un oggetto, non esiste $this.

Così :

• Non utilizzare le chiamate statiche per metodi non statici
• I tuoi metodi statici (o metodi chiamati staticamente) non possono usare $ this, che normalmente punta all'istanza corrente della classe, poiché non esiste un'istanza di classe quando usi le chiamate statiche.

Qui, i metodi della tua classe utilizzano l'istanza corrente della classe, poiché devono accedere alla $fooproprietà della classe.

Ciò significa che i tuoi metodi richiedono un'istanza della classe, il che significa che non possono essere statici.

Questo significa che non dovresti usare chiamate statiche: dovresti istanziare la classe e usare l'oggetto per chiamare i metodi, come hai fatto nell'ultima parte di codice:

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

Per maggiori informazioni, non esitate a leggere, nel manuale di PHP:

• La sezione Classi e oggetti
• E la pagina delle parole chiave statiche .

Si noti inoltre che probabilmente non è necessaria questa riga nel __constructmetodo:

global $foo;

L'uso della globalparola chiave renderà la $foovariabile, dichiarata al di fuori di tutte le funzioni e classi, visibile dall'interno di quel metodo ... E probabilmente non hai una tale $foovariabile.

Per accedere alla $foo proprietà class , devi solo usare $this->foo, come hai fatto tu.

Se si sta invocando foobarfunccon l' operatore scope scope ( ::), lo si chiama in modo statico , ad es. A livello di classe anziché a livello di istanza, quindi si utilizza $thisquando non si è nel contesto dell'oggetto . $thisnon esiste nel contesto di classe.

Se abiliti E_STRICT, PHP solleverà un avviso a riguardo:

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

Fallo invece

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

Su un sidenote, suggerisco di non usare globalall'interno delle tue lezioni. Se hai bisogno di qualcosa dall'esterno all'interno della tua classe, passalo attraverso il costruttore. Questo si chiama Dependency Injection e renderà il tuo codice molto più gestibile e meno dipendente da cose esterne.

Per prima cosa capisci una cosa, $ this all'interno di una classe indica l' oggetto corrente .
È per questo che sei creato fuori dalla classe per chiamare la funzione o la variabile di classe.

Quindi quando chiami la tua funzione di classe come foobar :: foobarfunc (), l'oggetto non viene creato. Ma all'interno di quella funzione hai scritto return $ this-> foo (). Ora qui $ questo non è niente. Ecco perché sta dicendo Usando $ this quando non nel contesto dell'oggetto in class.php

soluzioni:

1. Crea un oggetto e chiama foobarfunc ().

2. Chiama foo () usando il nome della classe all'interno di foobarfunc ().

Quando si chiama la funzione in un contesto statico, $this semplicemente non esiste.

Dovresti usare this::xyz() invece.

Per scoprire in quale contesto ti trovi quando una funzione può essere chiamata sia staticamente sia in un'istanza di oggetto, in questa domanda è delineato un buon approccio: come capire se sono statico o un oggetto?

Metodo rapido: (new foobar ()) -> foobarfunc ();

È necessario caricare la sostituzione della classe:

foobar::foobarfunc();

di:

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

o :

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

Oppure crea una funzione statica da usare foobar::.

class foobar {
    //...

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

$foobar = new foobar;metti il foobar di classe in $ foobar, non l'oggetto . Per ottenere l'oggetto, è necessario aggiungere una parentesi:$foobar = new foobar();

Il tuo errore è semplicemente che si chiama un metodo su una classe, quindi non esiste $thispoiché $thisesiste solo negli oggetti.

Mi sembra un bug in PHP. L'errore

"Errore irreversibile: errore non rilevato: utilizzo di $ this quando non nel contesto dell'oggetto in"

appare nella funzione utilizzando $this, ma l'errore è che la funzione chiamante utilizza una funzione non statica come statica. Vale a dire:

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

Mentre l'errore è qui:

Class_Name::foo();

Usa semplicemente il metodo Class usando questo foobar->foobarfunc();