PHP Erreur fatale: En utilisant $ quand pas dans le contexte de l'objet

Question

J'ai un problème:

J'écris une nouvelle WebApp sans cadre.

Dans mon index.php J'utilise: require_once('load.php');

load.php J'utilise require_once('class.php'); pour charger mon class.php .

Dans mon class.php J'ai cette erreur:

  

Erreur fatale: Utiliser $ quand pas dans le contexte de l'objet dans class.php en ligne ... (dans cet exemple, il serait 11)

Un exemple comment mon class.php est écrit:

class foobar {

    public $foo;

    public function __construct() {
        global $foo;

        $this->foo = $foo;
    }

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

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

Dans mon index.php Je chargement foobarfunc() peut-être comme ceci:

foobar::foobarfunc();

mais peut aussi être

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

Pourquoi l'erreur vient?

Answer 1

  

Dans mon index.php je charge peut-être   foobarfunc () comme ceci:

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

  

mais peut aussi être

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

Vous ne pouvez pas invoquer la méthode de cette façon, car il est pas la méthode statique.

foobar::foobarfunc();

Vous devriez utiliser:

foobar->foobarfunc();

Si toutefois vous avez créé une méthode statique quelque chose comme:

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

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

vous pouvez utiliser ceci:

foobar::foobarfunc();

Answer 2

Vous appelez une méthode non statique:

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

L'utilisation d'un appel statique:

foobar::foobarfunc();

Lorsque vous utilisez un appel statique, la fonction sera appelée (même si non déclarée static) , mais comme il n'y a pas d'exemple d'un objet, il n'y a pas $this.

• Vous ne devriez pas utiliser les appels statiques pour les méthodes non statiques
• Vos méthodes statiques (ou statiquement méthodes dites) ne peuvent pas utiliser cette $, ce qui fait normalement à l'instance actuelle de la classe, car il n'y a pas d'instance de classe lorsque vous utilisez-appels statiques.

Ici, les méthodes de votre classe utilisent l'instance actuelle de la classe, car ils ont besoin d'accéder à la propriété $foo de la classe.

Cela signifie que vos méthodes ont besoin d'une instance de la classe -. Ce qui signifie qu'ils ne peuvent pas être statiques

Cela signifie que vous ne devez pas utiliser les appels statiques: vous devez instancier la classe, et utiliser l'objet pour appeler les méthodes, comme vous l'avez fait dans votre dernière partie du code:

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

Pour plus d'informations, ne pas hésiter à lire, dans le manuel PHP:

• et objets section
• Et page de mots-clés statique.

Notez également que vous ne avez probablement pas besoin de cette ligne dans votre méthode de __construct:

global $foo;

Utilisation du global mot-clé fera la variable $foo, déclarée en dehors de toutes les fonctions et les classes, visibile de l'intérieur de cette méthode ... et vous ne probablement pas une telle variable $foo.

Pour accéder au $foo classe propriété, vous ne besoin d'utiliser $this->foo, comme vous l'avez fait.

Answer 3

Si vous invoquez foobarfunc avec champ d'application de la résolution (::), vous appelez ce statiquement, par exemple sur le niveau de la classe au lieu du niveau de l'instance, donc vous êtes à l'aide $this lorsqu'ils ne sont pas dans le contexte de l'objet . $this n'existe pas dans le contexte de la classe.

Si vous activez E_STRICT, PHP soulèvera un avis à ce sujet:

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

Pour ce faire, au lieu

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

Sur un Sidenote, je suggère de ne pas utiliser global dans vos classes. Si vous avez besoin de quelque chose de l'extérieur à l'intérieur de votre classe, passer par le constructeur. Ceci est appelé injection de dépendances et il fera votre code beaucoup plus maintenable et moins dépendants des choses à l'extérieur.

Answer 4

D'abord, vous comprenez une chose, $ cette dans une classe représente l'objet courant .
C'est qui vous est créé à côté sont de la classe pour appeler une fonction de classe ou variable.

Alors, quand vous appelez votre fonction de classe comme foobar :: foobarfunc (), l'objet est pas créé. Mais à l'intérieur de cette fonction vous écrit return $ this-> foo (). Maintenant ici $ ce n'est rien. Cest pourquoi le dire Utiliser $ quand pas dans le contexte de l'objet dans class.php

Solutions:

1. Créer un objet et appelez foobarfunc ().

2. Appel foo () en utilisant le nom de classe à l'intérieur du foobarfunc ().

Answer 5

Lorsque vous appelez la fonction dans un contexte statique, $this n'existe pas.

Vous devez utiliser this::xyz() à la place.

Pour en savoir quel contexte vous êtes quand une fonction peut être appelée à la fois statique et dans une instance d'objet, une bonne approche est décrite dans cette question: Comment savoir si je suis statique ou un objet?

Answer 6

Méthode rapide: (nouveau foobar ()) -> foobarfunc ();

Vous devez charger remplacer votre classe:

foobar::foobarfunc();

par:

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

ou

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

Ou faire statique fonction à utiliser foobar::.

class foobar {
    //...

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

Answer 7

$foobar = new foobar; mis la classe foobar dans foobar $, pas l'objet . Pour obtenir l'objet, vous devez ajouter entre parenthèses: $foobar = new foobar();

Votre erreur est tout simplement que vous appelez une méthode sur une classe, donc il n'y a pas $this depuis $this existe que dans les objets.

Answer 8

Il suffit d'utiliser la méthode de classe en utilisant ce foobar->foobarfunc();