¿Violan $ _POST, $ _GET, etc., el principio de encapsulación?

El uso de globales hace que su código sea difícil de probar, por lo que es más propenso a errores, no es seguro e impredecible. Es por eso que pasamos las variables que queremos dentro de una función / objeto. Entonces mi pregunta es simple:

¿Violan $ _POST, $ _GET, etc., el principio de encapsulación ?

Estoy pensando que, para retener el control de esas variables de una manera OO, una solución ideal sería agregar algunas líneas como esta al código:

// Convert the $_GET array to an object
$get = json_decode(json_encode($_GET), FALSE);  // stackoverflow.com/a/1869147
// Stop it from being included from anywhere
unset($_GET);

// Small example of what could be done later on
$DB = new PDO(/* ... */);
$Person = new Person($DB, $get->id);

No he visto esto en ningún lado, ni siquiera un tutorial ni recomendación. Además, podemos ver claramente cómo el código anterior es mucho más fácil de probar que uno que incluye $Person = new Person($DB, $_GET['id']);o incluso (lo feo), $Person = new Person($DB);ya que puede usar un $getobjeto simulado .

¿El código anterior está en la dirección correcta o me falta algo?

EDITAR: Después de un poco de investigación ( Zend framework y Cake PHP ) como sugirió Alexander Kuzmin, parece ser lo correcto. Probablemente sean demasiado grandes para que yo pueda cavar en el código ATM, pero lo tendré en cuenta.

No estoy seguro de por qué se aplica json_decodea $_GET“convertir a un una matriz”; $_GETYa es una matriz.

El uso de los superglobales ( $_GET, $_POSTetc.) es una violación del principio de encapsulación. Pero ha habido una línea trazada donde dejas de encapsular cosas. Solicitar datos es un buen candidato para la encapsulación, pero no se deje engañar por la trampa de intentar encapsular todas las cosas .

La mayoría de los frameworks generalmente envuelven los superglobales de PHP en alguna forma de objeto de solicitud. Hacer esto hace que sea más fácil burlarse de las pruebas, etc. El enfoque más simple sería:

<?php
class Request
{
    public $get;
    public $post;
    public $session;
    public $cookie;

    public function __construct($get, $post, $session, $cookie)
    {
        $this->get = $get;
        $this->post = $post;
        $this->session = $session;
        $this->cookie = $cookie;
    }
}

$request = new Request($_GET, $_POST, $_SESSION, $_COOKIE);

Es simple y rudimentario, pero hace el trabajo. También es recomendable filtrar los datos en este punto, para defenderse de las inyecciones de XSS.

Pero está envuelto en un Requestobjeto. El Requestobjeto tiene cuatro matrices, y estas matrices se pueden burlar fácilmente:

$get = array(
    'foo' => 'bar'
);
$post = array();
$session = array(
    'user' => 1
);
$cookie = array();

$request = new Request($get, $post, $session, $cookie);

Usar superglobales $_{POST,GET,SERVER}o lo que sea que viole la encapsulación.

Este problema crece cuando quiere crear "solicitudes locales" dentro del lado del servidor de su aplicación como lo hacen muchos frameworks hoy en día.

No estoy acostumbrado a trabajar con frameworkds, pero lo que suelo hacer es crear un par de Solicitud / Respuesta al comienzo de mi procesamiento. La solicitud contiene los valores de estos parámetros globales.

Si quiero crear una subrequest del lado del servidor, tengo dos opciones: usar el contexto actual o crear uno completamente nuevo. Entonces, creo que no deberías desarmar estas variables superglobales porque QUIZÁS querrías usarlas nuevamente. Además, por esta razón, no estoy de acuerdo con que los parámetros de solicitud sean singletons.

Al contener solo valores, no referencias a estas superglobales, un cambio en un objeto Request nunca afectará a otro, por lo que se resuelve el problema con el estado global.

Entonces, básicamente, tengo dos opciones:

// Using global context
$request = new Request(array(
    'post' => $_POST,
    'get' => $_GET
));

// or creating a new context

$request = new Request(array(
    'post' => ['someKey' => 'someValue'],
    'get' => ['queryParam' => 'queryValue'],
));

POST- y GET-vars se envían al servidor de forma masiva y php tiene que tener sentido. En cierto modo, tiene sentido tenerlos disponibles en todo el mundo, para que el desarrollador pueda elegir dónde procesarlos.

Muchos frameworks (como CakePHP, por ejemplo) leen los Parámetros y luego los colocan en una matriz, objeto o estructura similar. Después de eso, se manejan como cualquier otro dato y se pasan a todos los métodos que los necesitan.

La encapsulación es un buen principio cuando existe la posibilidad de que necesite varias instancias de algo. Pero solo hay un conjunto de parámetros para una página web. Si estuvieran en una clase en lugar de variables globales, probablemente serían singletons. No hay una mejora significativa al pasar de las variables globales a las clases singleton, es solo una sintaxis diferente para acceder a ellas. Todavía son objetos intrínsecamente globales, es más engorroso porque tienes que controlar la instancia de clase y pasarla.

Como se accede a estos parámetros con tanta frecuencia, los diseñadores de PHP tomaron la decisión de facilitar su acceso, en lugar de adherirse a principios de diseño rígidos. Es una buena idea hacer que las operaciones más comunes sean convenientes, de lo contrario los programadores lo maldecirán por hacer que vuelvan a escribir lo mismo, siempre.