y compris la classe dans une autre classe en php

Question

i ont une page php qui contient des variables concernant la base de données à savoir l'adresse du serveur, nom d'utilisateur et mot de passe, etc.

config.php comprendra

<?php 
    $dbserver=""; 
    $username=""; 
    $password=""; 
    $database=""; 
?> 

j'ai une classe qui contient toutes les fonctions requises pour mon site web. Comment puis-je importer mes variables de page php dans cette classe à utiliser pour la connectivité de la base de données?

ma classe

<?php 
    class a{ 
     include("config.php"); 
     function db_connect(){ 
     mysql_connect($dbserver,$username,$password); 
     } 
    } 
?> 

Answer 1

J'ai utilisé la configuration de base de données dans le constructeur de la classe. Je pense que c'était la seule solution n'incluant aucune troisième page dans le scénario.

Answer 2

habituellement à cet effet, Constantes existent. Mais si vous voulez utiliser des variables, tout ce que vous avez à faire est require_once (yourFile), puis quand vous voulez utiliser ces variables (qui sont globales) dans une méthode d'une classe, il suffit de les appeler global $myVar; (comme si vous le déclariez). Seulement besoin de le faire une fois pour chaque variable globale que vous souhaitez utiliser dans le contexte.

Exemple:

settings.php:

$conn = 'my connection'; 

MyClass.php:

class MyClass 
{ 
    function DoSomething() 
    { 
     require_once('settings.php'); 
     global $conn; 
     doSomethingWith($conn); 
    } 
} 

Answer 3

Mise à jour

Pour une classe de base de données qui nécessite des options de configuration, le plus simple façon serait d'utiliser la config v alues ​​comme paramètres (exemple 1 de ma réponse originale ci-dessous).

Une approche plus complexe, mais aussi plus flexible, serait une classe Config.

class Config 
{ 
    private $config = array(); 

    public function __construct(array $config) 
    { 
    $this->config = $config; 
    } 

    public function Register($key, $value) 
    { 
    $this->config[$key] = $value; 
    } 

    public function Get($key) 
    { 
    if (!isset($this->config[$key])) return null; 
    return $this->config[$key]; 
    } 
} 

Votre classe DB ressemblerait à quelque chose comme ceci:

class Database 
{ 
    private $config = null; 

    public function __construct(Config $config) 
    { 
    $this->config = $config; 
    } 

    public function Connect() 
    { 
    do_connect_stuff($this->config->Get('host'), $this->config->Get('user'), .....); 
    } 
} 

fichier config.php

<?php 

$config = new Config(
    array(
    "host" => "localhost", 
    "user" => "user", 
    ... 
) 
); 

/* 
alternative: 
$config = new Config(); 
$config->Register('host', 'localhost'); 
$config->Register('user', 'user'); 
... 
*/ 
?> 

fichier qui nécessite la base de données:

<?php 

$database = new Database($config); 
$database->Connect(); 

?> 

Comme un côté indice: Utilisez PDO, c'est bien mieux que e vieilles fonctions mysql_*.

---

Réponse originale

Le style approprié serait de transmettre les variables aux fonctions en tant que paramètre ou les transmettre lors de la création de l'objet. Vous pouvez également utiliser les méthodes Init pour transmettre les paramètres.

Exemples:
(Lequel le code suivant, vous devez utiliser dépend de ce que vous avez déjà et comment votre code est conçu, comme « propre » serait un objet pour lequel vous transmettre les variables lorsque vous appelez la méthode processAction

En supposant que dans votre script vous avez une variable $action que vous obtenez de $ _GET ou d'une autre manière.

L'utilisation d'un objet

class Controller 
{ 
    public function ProcessAction($action, $some_other_parameter, $and_yet_another_parameter) 
    { 
    [...] 
    } 
} 

Vous appelez ensuite avec

$action = do_some_stuff_to_get_action(); 
$controller = new Controller(); 
$controller->ProcessAction($action, $other_parameter, $second_parameter); 

Utilisation d'une classe statique

class Controller 
{ 
     public static function ProcessAction($action, $some_other_parameter, $and_yet_another_parameter) 
     { 
     [...] 
     } 
} 

Appelé avec:

$action = do_some_stuff_to_get_action(); 
Controller::ProcessAction($action, $other_parameter, $second_parameter); 

En passant les paramètres avant d'appeler la fonction

objet

class Controller 
{ 
    private $action = ""; 
    private $some_other_parameter = ""; 

    public function __construct($action, $some_other_parameter) 
    { 
    $this->action = $action; 
    $this->some_other_parameter = $some_other_parameter; 
    } 

    public function ProcessAction() 
    { 
    if ($this->action == 'do_stuff') 
    { 
     [...] 
    } 
    } 
} 

Appelé avec:

$action = do_some_stuff_to_get_action(); 
$controller = new Controller($action, $other_parameter); 
$controller->ProcessAction(); 

méthodes statiques

class Controller 
{ 
     private static $action = ""; 
     private static $some_other_parameter = ""; 

     public static function Init($action, $some_other_parameter) 
     { 
     self::$action = $action; 
     self::$some_other_parameter = $some_other_parameter; 
     } 

     public static function ProcessAction() 
     { 
     if (self::$action == 'do_stuff') 
     { 
      [...] 
     } 
     } 
} 

Appelé avec:

$action = do_some_stuff_to_get_action(); 
Controller::Init($action, $other_parameter); 
Controller::ProcessAction();