get instance () dans Codeigniter: pourquoi l'attribuer à une variable?

dans Codeigniter, get_instance() est une fonction globalement disponible qui renvoie le super-objet Controller qui contient toutes les classes actuellement chargées (il renvoie l'instance de la classe Controller). Je vais inclure le code source actuel:

get_instance() est défini dans Codeigniter.php

// Load the base controller class
require BASEPATH.'core/Controller.php';

function &get_instance()
{
    return CI_Controller::get_instance();
}

et CI_Controller est défini dans Controller.php

class CI_Controller {

    private static $instance;

    /**
     * Constructor
     */
    public function __construct()
    {
        self::$instance =& $this;

        // Assign all the class objects that were instantiated by the
        // bootstrap file (CodeIgniter.php) to local class variables
        // so that CI can run as one big super object.
        foreach (is_loaded() as $var => $class)
        {
            $this->$var =& load_class($class);
        }

        $this->load =& load_class('Loader', 'core');

        $this->load->set_base_classes()->ci_autoloader();

        log_message('debug', "Controller Class Initialized");
    }

    public static function &get_instance()
    {
        return self::$instance;
    }
}

Voici comment il est recommandé de l'utiliser dans le guide de l'utilisateur pour la création de bibliothèques :

utiliser des ressources CodeIgniter dans votre bibliothèque

pour accéder aux ressources natives de CodeIgniter dans votre bibliothèque, utilisez le get_instance() de la fonction. Cette fonction renvoie le code super objet.

Normalement à partir de votre contrôleur, vous appeler tout de les fonctions CodeIgniter disponibles en utilisant le $this construire: $this->load->helper('url'); $this->load->library('session'); $this->config->item('base_url'); etc.

$this , cependant, ne fonctionne directement au sein de vos contrôleurs, votre modèles, ou de votre point de vue. Si vous souhaitez utiliser les cours de CodeIgniter à partir de vos propres cours personnalisés, vous pouvez le faire comme suit:

d'abord, assignez l'objet CodeIgniter à une variable:

$IC =& get_instance();

une Fois que vous avez assigné l'objet pour une variable, vous devez utiliser variable au lieu de $this : $IC =& get_instance(); $IC->load->helper('url'); $IC->load->library('session'); $CI - > config - > item ('base_url'); etc.

Note: vous remarquerez que la fonction get_instance() ci-dessus est

$IC =& get_instance();

C'est très important. assigner par référence permet vous d'utiliser le objet CodeIgniter original plutôt que d'en créer une copie.

Related posts: explain $CI =& get_instance(); / Codeigniter: obtenir L'Instance

donc, voici ma question actuelle:

pourquoi le guide de l'utilisateur recommande-t-il d'affecter get_instance() à une variable? Je suis assez certain de comprendre les implications de ne pas assigner par référence, mais pourquoi est-il recommandé de l'affecter à une variable lorsque get_instance()->load->model() fonctionne bien?

je vois beaucoup d'défini par l'utilisateur ou un tiers des classes de CI que de céder à une propriété de l'objet:

class MY_Class {

    private $CI;

    function __construct()
    {
        $this->CI =& get_instance();
    }
    function my_func()
    {
        $this->CI->load->view('some_view');
    }
    function my_other_func()
    {
        $this->CI->load->model('some_model');
    }
}

Mauvais exemple, mais je le vois souvent. Pourquoi s'embêter avec cette méthode, au lieu de simplement appeler get_instance() directement? It semble comme si assigner l'objet contrôleur entier à une variable de classe ne serait pas une grande idée, même si elle est une référence. Peut-être qu'il n'a pas d'importance.

je veux écrire une fonction wrapper pour get_instance() donc c'est plus facile de taper, et je n'ai pas à l'assigner constamment à une variable.

function CI()
{
    return get_instance();
}

Ou:

function CI()
{
    $CI =& get_instance();
    return $CI;
}

alors je pourrais utiliser CI()->class->method() de n'importe où sans la peine de l'assigner à une variable, il est très facile d'écrire et de comprendre ce qu'il fait, et peut entraîner plus court, plus le code élégant.

• y a-t-il une raison de ne pas adopter cette approche?
• y a-t-il une différence entre les deux fonctions CI() ci-dessus?
• Pourquoi est-il recommandé d'attribuer get_instance() à une variable plutôt que de l'appeler directement?
• que signifie le & dans function &get_instance(){} là où il est défini? Je sais un peu ce que références sont pour et je les utilise quand c'est approprié, mais je n'ai jamais vu une fonction définie de cette façon. Si j'écris une fonction wrapper, devrais-je l'utiliser aussi?

veuillez noter qu'il ne s'agit pas tellement d'une question style , mais d'une question technique. Je veux savoir s'il y a des problèmes, performance ou autrement , avec l'utilisation de la méthode que je suggère.

EDIT : Jusqu'à présent nous ont:

• L'enchaînement de méthode n'est pas disponible dans php4, donc l'assignation à une variable est une solution de contournement (bien que cela soit assez hors de propos puisque Codeigniter a abandonné le soutien de php4)
• le petit overhead d'appeler une fonction plus d'une fois pour retourner l'objet, plutôt que de l'appeler une fois et de l'assigner à une variable.

autre chose, ou s'agit-il des seuls problèmes potentiels?