Extérieur de la Variable d'Accès en Classe PHP

Considérons la situation suivante

fichier: ./include/functions/table-config.php
contenant: 

.
.
$tablePages = 'orweb_pages';
.
.

fichier: ./include/classes/uri-resolve.php
contenant: 

class URIResolve {
.
.
$category = null ;
.
.
function process_uri() {
...
    $this->category = $tablePages;
...
}
.
.
}

fichier: ./settings.php
contenant: 

.
.
require_once(ABSPATH.INC.FUNC.'/table-config.php');
require_once(ABSPATH.INC.CLASS.'/uri-resolve.php');
.
.

Ce travail sera. Je veux dire, permettra l'accès à l' $tablePages de process_uri() acceptable ou que ça va donner de faux résultats.

Veuillez suggérer des corrections ou des solutions de contournement en cas d'erreur peuvent se produire.

OriginalL'auteur |

  1. 3

    Global (non recommandé), une constante ou un singleton classe de configuration.

    Simplement y compris

    $tablePages = 'orweb_pages';

    donnera à votre variable locale afin de ne pas être visibles à l'intérieur d'autres classes. Si vous utilisez une constante:

    define('TABLE_PAGES', 'orweb_pages');

    TABLE_PAGES sera disponible pour l'accès en lecture dans l'application, quelle que soit la portée.

    L'avantage d'une constante au cours d'une variable globale, c'est que vous n'avez pas à vous inquiéter à ce sujet étant remplacée dans d'autres domaines de l'application.

    ne constantes nécessairement être des Majuscules ou est-ce juste une pratique de programmation d'éviter toute banalisation de l'identificateur d'affrontements?
    Juste pratique courante
    est la portée vrai problème pour les fonctions définies à l'extérieur de la classe?
    non, les fonctions déclarées hors d'une classe sont dans l'espace de noms global

    OriginalL'auteur

  2. 9

    Utiliser le mot clé global:

    Dans le fichier où vous êtes à l'affectation de la valeur.

    global $tablePages;
$tablePages = 'orweb_pages';

    Et dans l'autre fichier:

    class URIResolve {
  var $category;
  function process_uri() {
    global $tablePages;
    $this->category = $tablePages;
  }
}

    Aussi, toutes les variables globales sont disponibles dans la $GLOBALS tableau (qui lui-même est une superglobale), de sorte que vous pouvez accéder à la variable globale n'importe où, sans l'aide du mot clé global, en faisant quelque chose comme ceci:

    $my_value = $GLOBALS['tablePages'];

    Cela sert aussi à rendre plus difficile à écraser accidentellement la valeur de la mondiale. Dans l'exemple précédent, les modifications apportées à $tablePages allait changer la variable globale. De nombreuses à un bug de sécurité a été créé par le fait d'avoir un mondial $user et de l'écraser avec un plus puissant des informations de l'utilisateur.

    L'autre, même approche plus sûre est de fournir de la variable dans le constructeur de URIResolve:

    class URIResolve {
  var $category;

  function __construct ($tablePages) {
    $this->category= $tablePages;
  }

  function process_uri() {
    //Now you can access table pages here as an variable instance
  }
}

//This would then be used as:
new URIResolve($tablePages);
    Merci beaucoup! Des doutes: je vais avoir à déclarer manuellement $GLOBALS['tablePages'] = 'tablePages'; à droite?
    J'aime la dernière astuce pour passer au constructeur. Important. Thumbs up.

    OriginalL'auteur

  3. 0
    <?php
 //Use variable php : $GLOBALS in __construct
 $x = "Example variable outer class";

class ExampleClass{
    public $variables; 
  function __construct()
  {
    $this->variables = $GLOBALS; //get all variables from $GLOBALS
  }
    //example get value var 
  public function UseVar(){
   echo $this->variables['x']; //return Example variable outer class
  }
    //example set value var
  public function setVar(){
    $this->variables['x'] = 100;
  } 
}
echo $x //return Example variable outer class;

$Example = new ExampleClass();
$Example->UseVar(); //return Example variable outer class
$Example->setVar(); //$x = 100;

//or use attr variables 
echo $Example->variables['x']; //100
$Example->variables['x'] = "Hiii"; 
?>
    En général, les réponses sont beaucoup plus utiles que s'ils incluent une explication de ce que le code est destiné à faire.

    OriginalL'auteur