hogar › Tarifas › Cómo funciona oauth 2. OAuth: una descripción del protocolo en un lenguaje sencillo y comprensible. Ejemplo de uso de un token de acceso

Cómo funciona oauth 2. OAuth: una descripción del protocolo en un lenguaje sencillo y comprensible. Ejemplo de uso de un token de acceso

Hablemos de utilidades interesantes que tarde o temprano serán de utilidad para cualquier desarrollador web.

Empecemos con Enrutamiento(ing. “Enrutamiento” - enrutamiento). Inmediatamente surge la pregunta: ¿por qué es necesario el enrutamiento en un sitio web, si antes todo funcionaba bien y era satisfactorio? Es sencillo. Si desea obtener un sistema más flexible y reducir el tiempo para configurar/reconfigurar su sitio, entonces necesita enrutamiento. Además, la gestión centralizada del sitio simplificará el trabajo con el código.

Érase una vez, yo mismo usé el enrutamiento normal de la caja del interruptor y pensé que era conveniente (de hecho, incluso ese enrutamiento es mucho mejor que su ausencia).

Todo esto estaba en el viejo. php funcional incluso sin ningún indicio de programación orientada a objetos. Este tipo de sistema resultó ser muy inflexible, porque Hubo dificultades para pasar datos a los módulos, el código era muy engorroso, ya que era necesario mantener la lógica junto con el enrutamiento, y luego me di cuenta: ¿por qué no hacer lo siguiente?

1) colocar enrutamiento sin código en archivo separado(esto le permitirá editar libremente el archivo directamente a través del panel de administración)
2) colocar la lógica por separado en una clase que generaría contenido para páginas

Muchos no encontrarán ninguna novedad en este artículo, pero no intento introducir innovaciones, solo quiero abrir los ojos a aquellos que todavía están durmiendo y usan métodos menos convenientes :)

Una vez decidido el “¿por qué?”, pasemos al “¿cómo?”.

El primer paso que debemos dar para crear una ruta conveniente y práctica es escribir el siguiente código. htacceso:

Reescribir motor encendido
ReescribirCond %(REQUEST_FILENAME) !-f
ReescribirCond %(REQUEST_FILENAME) !-d
Reescribir regla. *índice. PHP[L]

Este código redirigirá todo el procesamiento de la página al índice. php, lo que nos permitirá simplificar la gestión de contenidos. Para aumentar tu comprensión, te aconsejo que prestes atención al artículo de DarkKemper.

Ahora que tenemos la redirección, pasemos a crear el archivo del enrutador. Yo uso el formato xml, pero esto no es particularmente importante, lo principal es que te resulte conveniente.

nombredelpaquete1. Nombre de clase/Nombre de método
nombredelpaquete2. Nombre de clase/Nombre de método
nombredelpaquete3. Nombre de clase/Nombre de método

Todo es bastante simple: en el archivo del enrutador puede especificar configuraciones tanto para URL individuales como para cualquier parte estática de las páginas. En el ejemplo, indiqué módulos para el encabezado del sitio, ya que para mí no cambia. Observo que, además de los módulos, puedes especificar configuraciones, parámetros pasados, reglas... En general, todo lo que quieras.

El último y más importante paso es escribir la clase Router, que gestionará todo el enrutamiento.

Primero necesitamos analizar el archivo xml:

análisis de función estática privada ($configPath) (
devolver simplexml_load_file($configPath);

El método parse() obtiene la ruta a su configuración (puede usarse para algo más que enrutamiento) y devuelve un objeto SimpleXML.

Ahora puede acceder a cualquier configuración de la siguiente manera: $xml->header->modules...

función estática pública GetContent($configPath) (
$contenido = "";
$enrutador = self::parse($configPath);
foreach($enrutador como $página) (
si(preg_match(
"#^". $página->uri. "$#"
, str_replace($_SERVER["QUERY_STRING"], "", $_SERVER["REQUEST_URI"])
, $uriPartes
if(! vacío($página->módulos->módulo)) (
foreach($página->módulos->módulo como $módulo) (
$pageModules = $módulo;
//Modul::Load() carga paquetes desde ...
$contenido. = Módulo::Cargar($módulo, $uriPartes?: $uriPartes);
//en mi configuración creé un grupo "página404", que se procesa si no se especifican módulos para esta página
if(vacío($pageModules)) (
foreach($router->página404->módulos->módulo como $módulo) (
$pageModules = $módulo;
$contenido. = Módulo::Cargar($módulo);
devolver $contenido;

Entonces, primero analizamos el archivo xml, después de lo cual procesamos la línea de … .

Si encontramos una coincidencia con la URL de la página actual, conectamos los módulos especificados en el archivo del enrutador. Si no lo encontramos, entonces los módulos de 404 páginas están conectados.

OK, todo ha terminado. Aquí no hay nada complicado.

Se pueden sacar las siguientes conclusiones:

+ El sistema es muy simple,
+ Puede cambiar páginas y secciones fácil y rápidamente hasta quedar irreconocibles,
+ Gracias a las expresiones regulares, podemos vincular módulos fácilmente (podemos pasarles parámetros).
- Si el archivo de su enrutador es grande, es mejor no trabajar sin almacenamiento en caché.

Bienvenido al segundo artículo sobre MVC y PHP. En él, discutiremos algunos principios que deberían guiarlo al utilizar la arquitectura MVC.

Enrutamiento y URL

Implementando MVC con usando PHP En Internet puede resultar un poco más difícil. El primer problema está relacionado con el enrutamiento de URL. El enrutamiento de URL es uno de los aspectos que no se tuvo en cuenta cuando se desarrolló MVC.

Entonces, ¿qué opciones tenemos para resolver el problema del enrutamiento de URL? Una de ellas es predefinir todas las URL que necesita la aplicación web. Y luego almacenarlos en el almacenamiento junto con los datos correspondientes que cargan las plantillas de Modelos, Vistas y Controlador para cada página o sección.

Luego, el sistema recibe la URL solicitada por el usuario y carga los componentes asignados a esa página. Esta es una solución viable si está creando un sitio comercial o un sitio estático que no funciona con URL dinámicas. Por ejemplo:

array("model" => "AboutModel", "view" => "AboutView", "controller" => "AboutController"), "portfolio" => array("model" => "PortfolioModel", "view" = > "PortfolioView", "controlador" => "PortfolioController")); foreach($datos como $clave => $componentes)( if ($página == $clave) ( $modelo = $componentes["modelo"]; $vista = $componentes["vista"]; $controlador = $componentes ["controlador"]; break; ) ) if (isset($modelo)) ( $m = nuevo $model(); $c = nuevo $controlador($modelo); $v = nuevo $vista($modelo); eco $v->salida();

Las URL se verán así:

ejemplo.com/index.php?page=about

ejemplo.com/index.php?page=portfolio

El ejemplo de MVC PHP carga un conjunto específico de "Modelo", "Vista" y "Controlador" para la página solicitada. Si el parámetro de URL de la página es "acerca de", se mostrará la página Acerca de. Si es "cartera", se mostrará la página Cartera.

Este ejemplo de enrutamiento estático, incluso con configuraciones tan simples, tiene varias desventajas. Uno de ellos es el hecho de que la escalabilidad del proyecto es difícil, ya que el volumen del sitio está limitado a un conjunto determinado de páginas.

Puede exponer las definiciones de las clases Modelo, Vista y Controlador, y permitir que las URL definan sus parámetros. En el ejemplo de enrutamiento estático, recuperamos el ID de clase de una matriz que contiene los datos de enrutamiento provenientes del almacenamiento persistente. Reemplazar una matriz con elementos convierte el enrutamiento estático en enrutamiento dinámico.

Ponemos la clave para cada elemento asociado en un array con una variable URL, pero las interacciones con las clases correspondientes ya están predefinidas; No pudimos comparar los valores de cada clave con el enrutamiento estático. ¿Pero por qué no intentamos hacer esto? Bueno, para empezar, no deberíamos codificar cada sección del sistema.

Puede crear secciones o páginas creando relaciones entre el Modelo, la Vista y el Controlador. Por ejemplo:

producción(); )

Nuestra nueva URL se verá así:

example.com/index.php?controller=controllername;model=modelname&view=viewname&action=actionname

La variable URL actual le dice al sistema qué función llamar en el "Controlador". Cuando esta función pasa datos al “Modelo”, también envía parte de los datos que indican qué “Vista” y “Controlador” deben cargarse.

Podría ser una variable de URL de evento, una variable separada o datos recopilados por un controlador. Recuerde, el "Controlador" nunca debe cargar datos ni pasarlos directamente a la "Vista"; solo debe interactuar con el "Modelo" y la entrada del usuario.

Ambos enfoques tienen sus pros y sus contras. El enrutamiento estático es más sólido, más rápido de implementar y brinda a los desarrolladores más control sobre el sistema. El enrutamiento dinámico le permite crear un sistema más eficiente, con mayor potencial de escalabilidad y portabilidad.

Sin embargo, con el enrutamiento dinámico, el "Controlador" puede recibir más funciones que con el enrutamiento estático. El enrutamiento dinámico puede considerarse como una modificación de la arquitectura MVC tradicional. Sin embargo, si se implementa correcta y eficazmente, el "Controlador" puede convertirse en un elemento más importante que el enrutamiento estático.

Agregar un controlador frontal permitirá que su sistema cargue particiones dinámicamente según lo que necesite.

SECO (No te repitas) y patrones

Para mí, uno de los principales argumentos a favor del uso de MVC es la capacidad de organizar todo el sistema lo más posible. Cualquier desarrollador estará de acuerdo en que lo peor para cualquier aplicación es repetir el mismo código. El principio de mantener el código simple y reutilizar componentes se llama filosofía. SECO - No te repitas(no te repitas).

Los principios DRY establecen: “ Cada dato debe presentarse en el sistema una vez, de forma inequívoca y clara.". El objetivo de DRY es expandir y explorar todas las formas posibles disponibles para que los desarrolladores hagan que el sistema sea lo más dinámico y optimizado posible. DRY implica que si necesita escribir el mismo fragmento de código en muchos lugares, en lugar de repetir ese código, cree un método separado y utilícelo cuando sea necesario.

Este enfoque optimiza el sistema e incluye capacidades de almacenamiento en caché para reducir el tiempo de procesamiento general.

Una implementación correcta de DRY es cuando cuando un elemento del sistema cambia, los elementos no relacionados no cambian. Por eso DRY es tan importante cuando se desarrolla utilizando el patrón MVC.

Plantillas

La palabra "plantilla" puede generar algunas preguntas para aquellos que han trabajado anteriormente con marcos web MVC, ya que la mayoría de las personas equiparan una plantilla con una "Vista". Como comentamos anteriormente, esto no es correcto desde la perspectiva de la arquitectura MVC tradicional.

Idealmente, la Vista debería procesar datos después de recibirlos del Modelo. Por lo tanto, tiene sentido organizar todo para que el componente Ver solo seleccione una plantilla y pase datos a esa plantilla.

De esta manera los datos estarán listos para ser mostrados usando una estructura de código de bloque, o usando echo, print. Lo principal que debe recordar es que sus datos deben estar listos para enviarse a través de la plantilla. Si su plantilla procesa datos de manera diferente, lo más probable es que su arquitectura MVC esté configurada incorrectamente.

Aquí hay un ejemplo simple de cómo una vista carga una plantilla y le pasa datos:

tstring = "La cadena se ha cargado a través de la plantilla."; $this->plantilla = "tpl/template.php"; ) )controlador = $controlador; $este->modelo = $modelo; ) salida de función pública())( $datos = "

" . $this->model->tstring ".

"; require_once($este->modelo->plantilla); ) ) El nombre de la plantilla

La plantilla PHP MVC se pasa a través de un "Modelo", que puede asignar una plantilla dependiendo de para qué sirve cada "Vista" en particular. Este método de plantilla le permite crear sistemas eficientes y extensibles al brindar la capacidad de separar el desarrollo de back-end y front-end. Este es el objetivo principal de MVC.

Conclusión

MVC ha sufrido cambios importantes desde que se utilizó por primera vez para programación. Fue y sigue siendo uno de los temas más discutidos entre los desarrolladores. Estos debates se volvieron aún más intensos después de que MVC comenzó a usarse para el desarrollo de PHP para la Web.

En este artículo escribiremos el “marco” de nuestro proyecto. Con la palabra "marco" me refiero al código de trabajo que se basará en el enfoque MVC, es decir, tendrá una clara división de la lógica en controladores, acciones, plantillas (vistas) y modelos.

Entonces, comencemos, como ya escribí en el artículo anterior, el patrón MVC implica un punto de entrada: index.php, todas las solicitudes pasarán a través de este script, toda la lógica del proyecto funcionará a través de él. Para implementar este enfoque, es necesario configurar el servidor, se supone que el sitio se ejecuta en el servidor Apache, por lo que solo necesitamos crear un archivo .htaccess en el que especificaremos las reglas de enrutamiento de URL. Además de determinar el punto de entrada, el enrutamiento le permite crear CNC (URL legibles por humanos). Es decir, después de la configuración adecuada, las direcciones de las páginas se verán así: site.ru/article/new.
Primero, creemos .htaccess, que redirigirá el procesamiento de todas las páginas al script index.php. El código se ve así:

RewriteEngine en RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule ^(.*)$ index.php?route=$1

El archivo .htaccess debe estar ubicado en la carpeta raíz del sitio y debe crear inmediatamente un script index.php, que es el punto de entrada. Escribamos una línea en index.php para probar la redirección:

"Prueba" de eco;

Ahora puedes verificar la redirección, ingresar cualquier dirección y ver qué sucede: test-mvc.web/sdf/sdf/ o test-mvc.web/sdf/sdf/2342/no importa, en cualquier caso, "Prueba ". Si viste esta inscripción, significa que lo logramos.
Continuamos, por conveniencia, creemos un archivo config.php en la raíz del sitio, en el cual estableceremos varias constantes que facilitarán la configuración del sitio. Puede ser diferentes caminos a scripts, acceso a bases de datos, etc. Ahora en la configuración configuremos lo siguiente:

// Establece las constantes: define ("DS", DIRECTORY_SEPARATOR); // separador para rutas de archivos $sitePath = realpath(dirname(__FILE__) . DS); define("SITE_PATH", $rutadelsitio); // ruta a la carpeta raíz del sitio // para conectarse a la base de datos define("DB_USER", "root"); definir("DB_PASS", ""); definir("DB_HOST", "localhost"); define("DB_NAME", "blog_mvc");

Para que podamos usar constantes y otros datos de configuración en todo el proyecto, debemos incluir el script config.php en el archivo index.php.
Además de conectar el archivo de configuración, en index.php debe crear una conexión a la base de datos, conectar el script con el núcleo del sitio e iniciar el enrutador en el que se realizará el enrutamiento.
Ahora, en orden, la creación de la conexión a la base de datos será en index.php para que la conexión se abra solo una vez. Una vez que abramos la conexión, podremos usarla en todos los controladores y modelos, pero hablaremos de eso más adelante. Ahora simplemente creemos una conexión a la base de datos. Para trabajar con la base de datos, decidí utilizar PDO. Puedes leer más sobre DOP.
Colocaremos el núcleo del sitio en la carpeta principal y llamaremos al script core.php, aquí escribiremos una función que se conectará por sí sola, las clases son necesarias para que funcione. Esta función facilitará y simplificará enormemente nuestro trabajo con controladores, modelos, etc. Porque, de cara al futuro, diré que cada controlador y cada modelo representarán una clase separada.
Además de conectar clases automáticamente, agregaremos al núcleo la creación de un almacenamiento (registro), en el que almacenaremos todo. objetos necesarios y variables que pueden ser útiles en cualquier parte del proyecto.
También conectaremos el router a archivo de índice, analizará la URL y conectará el controlador y la acción necesarios. Escribí sobre qué es un controlador en un artículo anterior, pero omití deliberadamente información sobre la acción, sin cargarla. información innecesaria. ¿Qué es entonces la acción?
Un controlador es una clase que contiene varios métodos, en Enfoque MVC cada método será una acción. Es decir, una acción es un método de clase que procesará datos y los transferirá a la vista (a la plantilla). Puede que todavía no esté del todo claro, pero después del ejemplo todo encajará.
En En este punto Basta de teoría, pasemos a la práctica. Daré el código de los archivos cuyo funcionamiento describí anteriormente.
Código de secuencia de comandos index.php:

// habilitar la visualización de todos los errores error_reporting (E_ALL); // conecta la configuración incluida ("/config.php"); // Conectarse a la base de datos $dbObject = new PDO("mysql:host=" . DB_HOST . ";dbname=" . DB_NAME, DB_USER, DB_PASS); // conecta el núcleo del sitio include (SITE_PATH . DS . "core" . DS . "core.php"); // Cargar enrutador $ enrutador = nuevo enrutador ($ registro); // escribe datos en el registro $registry->set ("router", $router); // establece la ruta a la carpeta de controladores. $enrutador->setPath(SITE_PATH. "controladores"); //inicia el enrutador $router->start();

Secuencia de comandos Core.php:

// Cargando clases sobre la función __autoload($className) ( $filename = strtolower($className) . ".php"; // define la clase y encuentra la ruta para ella $expArr = explode("_", $className ) ; if(empty($expArr) OR $expArr == "Base")( $carpeta = "clases"; )else( switch(strtolower($expArr))( case "controlador": $carpeta = "controladores"; break ; case "modelo": $carpeta = "modelos"; valor predeterminado: $carpeta; break ) // ruta a la clase $file = $filename; false; ) // incluye el archivo con la clase include ($file ) // inicia el registro (almacenamiento) $registry = new Registro;

La clase de almacenamiento Registry.php se ubicará en la carpeta /classes/

// Clase de almacenamiento Registro de clases ( private $vars = array(); // función de registro de datos set($key, $var) ( if (isset($this->vars[$key]) == true) ( throw new Exception("No se puede configurar var `" . $key . "`. Ya configurado." ) $this->vars[$key] = $var return true; if (isset($this->vars[$key]) == false) ( return null; ) return $this->vars[$key] ) // eliminar datos función remove($var) ( unset($ this; ->vars[$clave]);

Código del archivo router.php, que se encuentra en la carpeta /classes/

// clase de enrutador Class Router (privado $registro; privado $ruta; privado $args = array(); // obtiene la función de almacenamiento __construct($registro) ( $this->registry = $registro; ) // establece la ruta a la carpeta con la función de controladores setPath($path) ( $path = trim($path, "/\\"); $path .= DS; // si la ruta no existe, señale if (is_dir($path) ) == false ) ( throw new Exception ("Ruta del controlador no válida: `" . $path . "`"); ) $this->path = $path ) // definiendo el controlador y la acción desde la función privada URL getController( &$archivo, & $controlador, &$acción, &$args) ( $ruta = (vacío($_GET["ruta"])) ? "" : $_GET["ruta"]; desarmado($_GET[" ruta"]); if (empty($ruta)) ( $ruta = "index"; ) // Obtener partes de la URL $ruta = trim($ruta, "/\\"); $partes = explotar(" /", $route); // Encuentra el controlador $cmd_path = $this->path; foreach ($parts as $part) ( $fullpath = $cmd_path . $part; // Comprueba si la carpeta existe if (is_dir( $ruta completa)) ( $cmd_path .= $ parte . DS; array_shift($partes); continuar; ) // Encuentra el archivo if (is_file($fullpath . ".php")) ( $controller = $part; array_shift($parts); break; ) ) // si la URL no especifica un controlador, entonces usa el índice predeterminado if (empty ($controller)) ($controller = "index"; ) // Obtener la acción $action = array_shift($parts); if (vacío($acción)) ( $acción = "índice"; ) $archivo = $cmd_path. $controlador. ".php"; $argos = $partes; ) function start() ( // Analiza la ruta $this->getController($file, $controller, $action, $args); // Comprueba si el archivo existe, de lo contrario 404 if (is_readable($file) == false ) (morir ("404 Extraviado

"); ) // Incluye el archivo include ($file); // Crea una instancia del controlador $class = "Controller_". $controller; $controller = new $class($this->registry); // If la acción no existe - 404 if (is_callable(array($controller, $action)) == false) ( die ("404 Not Found"); ) // Ejecuta la acción $controller->$action() ) )
Ahora necesita crear carpetas para almacenar controladores, plantillas y modelos; en la raíz crearemos tres carpetas: controladores, vistas y modelos. Y creemos varios archivos de prueba /controllers/index.php, /views/index/index.php y /models/model_users.php, y ahora completemos los archivos:

// clase de controlador Controller_Index extiende Controller_Base ( // plantilla pública $layouts = "first_layouts"; // función de acción index() ( $model = new Model_Users(); $userInfo = $model->getUser(); $this-> plantilla->vars("userInfo", $userInfo"); $this->plantilla->view("índice"))

Para visualización (/views/index/index.php)

Vista de prueba
identificación:
nombre:

Y el modelo:

// modelo Clase Model_Users( función pública getUser())( return array("id"=>1, "name"=>"test_name"); ) )

Como habrás notado, la clase de controlador hereda de la clase principal Controller_Base. Esto se hace para simplificar la clase de controlador. Como todavía necesitamos conectar la clase para trabajar con plantillas, su conexión se coloca en Controller_Base.
Daré su código, está ubicado en la carpeta /classes/ y se llama controlador_base.php:

// clase de controlador abstracto Clase abstracta Controller_Base ( protected $registry; protected $template; protected $layouts; // plantilla public $vars = array(); // conecta plantillas en la función constructora __construct($registry) ( $this-> registro = $registro; // plantillas $this->template = nueva Plantilla($this->layouts, get_class($this) ) índice de función abstracta();

Ahora solo queda descubrir las plantillas. EN clase abstracta Controller_Base llamamos a la clase Plantilla y le pasamos el nombre de la plantilla y el nombre del controlador.
El código para la clase Plantilla, que se encuentra aquí /classes/ y se llama template.php

// clase para conectar plantillas y pasar datos a la plantilla de clase de visualización (privado $plantilla; privado $controlador; privado $layouts; privado $vars = array(); función __construct($layouts, $controllerName) ( $this->layouts = $layouts; $arr = explode("_", $controllerName); $this->controller = strtolower($arr); // configurando variables para mostrar la función vars($varname, $value) ( if (isset); ( $this->vars[$varname]) == true) ( trigger_error ("No se puede configurar var `" . $varname . "`. Ya está configurado y no se permite sobrescribir.", E_USER_NOTICE); devuelve falso; ) $this ->vars[$varname] = $value; return true; ) // mostrar función view($name) ( $pathLayout = SITE_PATH . "vistas" . DS . "layouts" . DS . $this->layouts . ". php"; $contentPage = SITE_PATH . "vistas" == false) ( trigger_error ("Diseño `. " . $ this->layouts . "` no existe.", E_USER_NOTICE); devuelve falso; if (file_exists($contentPage) == false) ( trigger_error ("Plantilla `" . $nombre. "` no existe.", E_USER_NOTICE); falso retorno;

) foreach ($this->vars as $key => $value) ( $$key = $value; ) include ($pathLayout); ) )
Si lee atentamente el código, probablemente se dará cuenta de que para mostrar las páginas usamos la plantilla first_layouts y la vista (mostrar) index.php; le di su código un poco más arriba. Todo lo que nos queda es crear el archivo de plantilla first_layouts. Coloquémoslo en la carpeta /views/layouts/first_layouts.php

La plantilla contendrá el siguiente código:

encabezamiento

pie de página Eso es todo, esto completa la creación del "marco". Ahora tenemos lo mejor estructura simple
, que se basa en el patrón MVC. En este artículo no toqué el tema del trabajo con la base de datos, solo lo mencioné de pasada, ya que el artículo ya era largo. Describiré cómo trabajar con la base de datos directamente en el próximo artículo.

Bienvenido al segundo artículo sobre MVC y PHP. En él, discutiremos algunos principios que deberían guiarlo al utilizar la arquitectura MVC.

Enrutamiento y URL

Este artículo está terminado, puede descargar los archivos fuente en el archivo.

Implementar MVC con PHP en la web puede ser un poco más complicado. El primer problema está relacionado con el enrutamiento de URL. El enrutamiento de URL es uno de los aspectos que no se tuvo en cuenta cuando se desarrolló MVC. Entonces, ¿qué opciones tenemos para resolver el problema del enrutamiento de URL? Una de ellas es predefinir todas las URL que necesita la aplicación web. Y luego almacenarlos en el almacenamiento junto con los datos correspondientes que las plantillas "», « Modelos Representación " Y "» se cargan para cada página o sección.

Las URL se verán así:

ejemplo.com/index.php?page=about

ejemplo.com/index.php?page=portfolio

El ejemplo de MVC PHP carga un conjunto específico de " Entonces, ¿qué opciones tenemos para resolver el problema del enrutamiento de URL? Una de ellas es predefinir todas las URL que necesita la aplicación web. Y luego almacenarlos en el almacenamiento junto con los datos correspondientes que las plantillas "», « Modelos Representación " Y "" para la página solicitada. Si el parámetro de URL de la página es " acerca de”, se mostrará la página Acerca de. Si " portafolio”, se mostrará la página Portafolio.

Puede abrir el acceso a las definiciones de clases " Entonces, ¿qué opciones tenemos para resolver el problema del enrutamiento de URL? Una de ellas es predefinir todas las URL que necesita la aplicación web. Y luego almacenarlos en el almacenamiento junto con los datos correspondientes que las plantillas "», « Modelos Representación " Y "", y permitir que las URL definan sus parámetros. En el ejemplo de enrutamiento estático, recuperamos el ID de clase de una matriz que contiene los datos de enrutamiento provenientes del almacenamiento persistente. Reemplazar una matriz con elementos convierte el enrutamiento estático en enrutamiento dinámico.

Puede crear secciones o páginas creando relaciones entre " Modelo», « Envío Representación Controlador" Por ejemplo:

producción(); )

Nuestra nueva URL se verá así:

example.com/index.php?controller=controllername;model=modelname&view=viewname&action=actionname

La variable URL actual le dice al sistema qué función llamar " Controlador" Cuando esta función pasa datos a " Modelo", también envía parte de los datos que indican cuál" Actuación Representación Controlador"Necesita ser descargado.

Podría ser una variable de URL de evento, una variable separada o datos recopilados por el controlador. No lo olvide, " Controlador"nunca debe cargar datos ni transferirlos directamente a" Actuación"; solo debe interactuar con "Modelo» y entrada del usuario.

Sin embargo, con el enrutamiento dinámico " Controlador"Puede obtener más funciones que con uno estático. El enrutamiento dinámico puede considerarse como una modificación de la arquitectura MVC tradicional. Sin embargo, si se implementa correcta y efectivamente, " Controlador" puede convertirse en un elemento más importante que con el enrutamiento estático.

Agregar un controlador frontal permitirá que su sistema cargue particiones dinámicamente según lo que necesite.

SECO (No te repitas) y patrones

Los principios DRY establecen: " Cada dato debe presentarse en el sistema una vez, de forma inequívoca y clara."El objetivo de DRY es expandir y explorar todas las formas posibles disponibles para los desarrolladores para hacer que un sistema sea lo más dinámico y optimizado posible. DRY implica que si necesita escribir el mismo fragmento de código en muchos lugares, en lugar de repetirlo código, cree un método separado y utilícelo cuando sea necesario.

Este enfoque optimiza el sistema e incluye capacidades de almacenamiento en caché para reducir el tiempo de procesamiento general.

Plantillas

Palabra " muestra" puede plantear algunas preguntas para aquellos que han trabajado anteriormente con marcos web MVC, ya que la mayoría de la gente equipara el patrón con " Envío" Como comentamos anteriormente, esto no es correcto desde la perspectiva de la arquitectura MVC tradicional.

Idealmente " Actuación" debe procesar los datos después de recibirlos de " Entonces, ¿qué opciones tenemos para resolver el problema del enrutamiento de URL? Una de ellas es predefinir todas las URL que necesita la aplicación web. Y luego almacenarlos en el almacenamiento junto con los datos correspondientes que las plantillas "" Por tanto, tiene sentido organizar todo para que el componente " Actuación» simplemente seleccionó una plantilla y pasó datos a esta plantilla.

Aquí hay un ejemplo simple de cómo una vista carga una plantilla y le pasa datos:

" . $this->model->tstring ".

"; require_once($este->modelo->plantilla); ) ) El nombre de la plantilla

La plantilla PHP MVC se pasa a través de " Modelo", al cual se le puede asignar una plantilla dependiendo de lo que sea específico de cada uno" Actuación" Este método de plantilla le permite crear sistemas eficientes y extensibles al brindar la capacidad de separar el desarrollo de back-end y front-end. Este es el objetivo principal de MVC.

Conclusión

Traducción del artículo " El patrón MVC y PHP. Parte 2» fue preparado por el amable equipo del proyecto Creación de sitios web de la A a la Z.

Muchas personas comienzan a escribir un proyecto para trabajar con una sola tarea, sin implicar que pueda convertirse en un sistema de gestión multiusuario, por ejemplo, contenido o, Dios no lo quiera, producción. Y todo parece genial y genial, todo funciona, hasta que empiezas a comprender que el código que se escribe consiste enteramente en muletas y código duro. El código se mezcla con diseño, consultas y muletas, a veces incluso ilegible. surge problema urgente: al agregar nuevas funciones, es necesario jugar con este código durante mucho tiempo, recordando "¿qué estaba escrito allí?" y maldicete en el pasado.

Es posible que incluso hayas oído hablar de patrones de diseño e incluso hayas hojeado estos maravillosos libros:

E. Gamma, R. Helm, R. Johnson, J. Vlissides “Técnicas objetivas diseño orientado. Patrones de diseño";
M. Fowler "Arquitectura de aplicaciones de software empresarial".

Y muchos, impertérritos ante los enormes manuales y documentación, intentaron estudiar cualquiera de los marcos modernos y, ante la complejidad de su comprensión (debido a la presencia de muchos conceptos arquitectónicos hábilmente vinculados entre sí), pospusieron el estudio y el uso de herramientas modernas “en un segundo plano”.

Este artículo será útil principalmente para principiantes. De todos modos, espero que en un par de horas puedas hacerte una idea de implementaciones MVC patrón que subyace a todos los marcos web modernos, y también obtiene "alimento" para una mayor reflexión sobre "cómo hacerlo". Al final del artículo hay una selección. Enlaces útiles, que también te ayudará a comprender en qué consisten los frameworks web (además de MVC) y cómo funcionan.

Es poco probable que los programadores PHP experimentados encuentren algo nuevo en este artículo, ¡pero sus comentarios y comentarios sobre el texto principal serán de gran ayuda! Porque Sin teoría la práctica es imposible, y sin práctica la teoría es inútil, luego primero habrá un poco de teoría y luego pasaremos a la práctica. Si ya está familiarizado con el concepto MVC, puede omitir la sección teórica e ir directamente a la práctica.

1. Teoría

El patrón MVC describe una forma sencilla de estructurar una aplicación, cuyo propósito es separar la lógica empresarial de la interfaz de usuario. Como resultado, la aplicación es más fácil de escalar, probar, mantener y, por supuesto, implementar.

Veamos el diagrama conceptual del patrón MVC (en mi opinión, este es el más buen esquema por lo que he visto):

en arquitectura modelo MVC proporciona datos y reglas de lógica de negocios, la vista es responsable de interfaz de usuario, y el controlador proporciona interacción entre el modelo y la vista.

Un flujo típico de una aplicación MVC se puede describir de la siguiente manera:

Cuando un usuario visita un recurso web, el script de inicialización crea una instancia de la aplicación y la inicia para su ejecución.
Esto muestra la vista, digamos pagina de inicio sitio.
La aplicación recibe una solicitud del usuario y determina el controlador y la acción solicitados. En el caso de la página principal, se realiza la acción predeterminada ( índice).
La aplicación crea una instancia del controlador y ejecuta el método de acción,
que, por ejemplo, contiene llamadas a modelos que leen información de la base de datos.
Después de esto, la acción crea una vista con los datos obtenidos del modelo y muestra el resultado al usuario.

Modelo- contiene la lógica empresarial de la aplicación e incluye métodos de muestreo (pueden ser métodos ORM), procesamiento (por ejemplo, reglas de validación) y suministro de datos específicos, lo que a menudo lo hace muy denso, lo cual es bastante normal.
El modelo no debe interactuar directamente con el usuario. Todas las variables relacionadas con la solicitud del usuario deben procesarse en el controlador.
El modelo no debe generar HTML u otro código de visualización que pueda cambiar según las necesidades del usuario. Dicho código debe procesarse en vistas.
El mismo modelo, por ejemplo: el modelo de autenticación de usuario se puede utilizar tanto en la parte de usuario como en la parte administrativa de la aplicación. En este caso se puede tomar codigo general en una clase separada y heredar de ella, definiendo métodos específicos para subaplicaciones en sus descendientes.

Vista- se utiliza para configurar la visualización externa de los datos recibidos del controlador y del modelo.
Las vistas contienen marcado HTML y pequeñas inserciones de código PHP para recorrer, formatear y mostrar datos.
No debe acceder directamente a la base de datos. Esto es lo que deberían hacer los modelos.
No debería funcionar con datos obtenidos a partir de una solicitud de usuario. Esta tarea debe ser realizada por el controlador.
Puede acceder directamente a las propiedades y métodos de un controlador o modelos para obtener datos listos para la salida.
Las vistas generalmente se dividen en una plantilla común, que contiene marcas comunes a todas las páginas (por ejemplo, un encabezado y pie de página) y partes de la plantilla que se utilizan para mostrar la salida de datos del modelo o mostrar formularios de entrada de datos.

Controlador- el pegamento que conecta modelos, vistas y otros componentes en una aplicación funcional. El responsable del tratamiento es responsable de procesar las solicitudes de los usuarios. El controlador no debe contener consultas SQL. Es mejor mantenerlos en modelos. El controlador no debe contener HTML ni otro tipo de marcado. Vale la pena ponerlo a la vista.
En una aplicación MVC bien diseñada, los controladores suelen ser muy delgados y contienen sólo unas pocas docenas de líneas de código. Lo que no se puede decir sobre los Inspectores Gordos Estúpidos (SFC) en CMS Joomla. La lógica del controlador es bastante típica y la mayor parte se transfiere a clases base.
Los modelos, por el contrario, son muy gruesos y contienen la mayor parte del código relacionado con el procesamiento de datos, porque La estructura de datos y la lógica empresarial que contiene suelen ser bastante específicas de una aplicación en particular.

1.1. Controlador frontal y controlador de página

En la mayoría de los casos, la interacción del usuario con una aplicación web se produce haciendo clic en enlaces. Mire ahora la barra de direcciones de su navegador: recibió este texto desde este enlace. Otros enlaces, como los que se encuentran en el lado derecho de esta página, le proporcionarán contenido diferente. Por tanto, el enlace representa un comando específico para la aplicación web.

Espero que ya hayas notado que diferentes sitios pueden tener formatos completamente diferentes para construir la barra de direcciones. Cada formato puede mostrar la arquitectura de una aplicación web. Aunque no siempre es así, en la mayoría de los casos es un hecho claro.

Consideremos dos opciones para la barra de direcciones, que muestran algo de texto y un perfil de usuario.

Primera opción:

www.ejemplo.com/article.php?id=3
www.ejemplo.com/user.php?id=4

Aquí, cada script es responsable de ejecutar un comando específico.

Segunda opción:

www.ejemplo.com/index.php?article=3
www.ejemplo.com/index.php?user=4

Y aquí todas las llamadas ocurren en un escenario. index.php.

Puede ver el enfoque de múltiples puntos de contacto en los foros de phpBB. La navegación por el foro se realiza mediante un script. verforo.php, ver tema vía vertopic.php etc. El segundo enfoque, con acceso a través de un único archivo de script físico, se puede ver en mi CMS MODX favorito, donde todos los accesos pasan por index.php.

Estos dos enfoques son completamente diferentes. El primero es típico del patrón Page Controller y el segundo enfoque lo implementa el patrón Front Controller. El controlador de página es bueno para sitios con una lógica bastante simple. A su vez, el controlador de solicitudes consolida todas las actividades de procesamiento de solicitudes en un solo lugar, lo que le brinda capacidades adicionales que pueden permitirle implementar tareas más complejas que las que normalmente resuelve el controlador de páginas. No entraré en detalles de la implementación del controlador de página, solo diré que en la parte práctica será el controlador de solicitudes (algo similar) el que se desarrollará.

1.2. Enrutamiento de URL

El enrutamiento de URL le permite configurar su aplicación para aceptar solicitudes de URL que no coinciden archivos reales aplicaciones, y también utilizan CNC, que son semánticamente significativas para los usuarios y preferidas para la optimización de motores de búsqueda.

Por ejemplo, para una página normal que muestra un formulario comentario, la URL podría verse así:
http://www.example.com/contacts.php?action=feedback

Código de procesamiento aproximado en este caso:
cambiar ($_GET ["acción"]) (caso "acerca de": require_once ("acerca de.php"); // página "Acerca de nosotros" romper ; caso "contactos": require_once ("contactos.php");// página "Contactos" romper ; caso "comentarios": require_once("comentarios.php");
// página "Comentarios"

romper ;
predeterminado: require_once ("página404.php"); // salto de página "404"; )

Creo que casi todo el mundo ha hecho esto antes.

Con un motor de enrutamiento de URL, puede configurar su aplicación para aceptar solicitudes como esta para mostrar la misma información:
http://www.example.com/contacts/feedback

Aquí los contactos representan el controlador y los comentarios son el método del controlador de contactos que muestra el formulario de comentarios, etc. Volveremos a esta cuestión en la parte práctica.

También vale la pena saber que los enrutadores de muchos marcos web le permiten crear rutas URL personalizadas (especifique qué significa cada parte de la URL) y reglas para procesarlas.

Ahora tenemos suficientes conocimientos teóricos para pasar a la práctica.
2. Practica index.php Primero, creemos la siguiente estructura de archivos y carpetas: De cara al futuro, diré que las clases principales Modelo, Vista y Controlador se almacenarán en la carpeta principal. Sus hijos se almacenarán en los directorios de controladores, modelos y vistas. Archivo

Este es el punto de entrada a la aplicación. Archivo
arranque.php
inicia la descarga de la aplicación, conectando todos los módulos necesarios, etc.

Iremos de forma secuencial; Abramos el archivo index.php y rellénelo con el siguiente código: De cara al futuro, diré que las clases principales Modelo, Vista y Controlador se almacenarán en la carpeta principal.:
ini_set("display_errors", 1); require_once "aplicación/bootstrap.php"; No debería haber ninguna pregunta aquí.
A continuación, pasemos inmediatamente a la driza. require_once "núcleo/model.php"; require_once "núcleo/view.php"; require_once "núcleo/controlador.php"; require_once "núcleo/ruta.php"; Ruta::inicio();//iniciar el enrutador

Las primeras tres líneas incluirán archivos del kernel que actualmente no existen. Las últimas líneas incluyen el archivo con la clase de enrutador y lo lanzan para su ejecución llamando

método estático comenzar.:
2.1. Implementación de un enrutador de URL
Por ahora, desviémonos de la implementación del patrón MVC y pasemos al enrutamiento. El primer paso que debemos hacer es escribir el siguiente código en index.php.htaccess

RewriteEngine en RewriteCond %(REQUEST_FILENAME) !-f RewriteCond %(REQUEST_FILENAME) !-d RewriteRule .* index.php [L] Este código redirigirá el procesamiento de todas las páginas a al directorio principal. En este archivo describiremos la clase Ruta, que ejecutará métodos de controlador, que a su vez generarán la vista de página.

Contenido del archivo route.php

ruta de clase ( estático inicio de función() ( // controlador y acción predeterminada$controller_name = "Principal"; $nombre_acción = "índice"; $rutas = explotar("/" , $_SERVER ["REQUEST_URI" ]); //obtiene el nombre del controlador if (!empty ($rutas)) ( $nombre_controlador = $rutas ; ) //obtiene el nombre de la acción if (!empty ($rutas )) ( $nombre_acción = $rutas ; ) // agregar prefijos$nombre_modelo = "Modelo_".$nombre_controlador; $nombre_controlador = "Controlador_".$nombre_controlador; $nombre_acción = "acción_" .$nombre_acción ; // conecta el archivo con la clase de modelo (puede que no haya un archivo de modelo)$model_file = strtolower($model_name)..php"; $model_path = "aplicación/modelos/".$model_file; if (file_exists($model_path)) (incluye "aplicación/modelos/".$model_file;) // conecta el archivo con la clase de controlador$controller_file = strtolower($controller_name )..php"; $controller_path = "aplicación/controladores/" .$controller_file; if (file_exists($controller_path)) (incluye "aplicación/controladores/".$controller_file;) else ( /* sería correcto lanzar una excepción aquí, pero para simplificarlo, redireccionaremos inmediatamente a la página 404 */ Ruta::ErrorPage404(); ) // crear un controlador$controlador = nuevo $nombre_controlador; $acción = $nombre_acción; si (method_exists($controlador, $acción)) ( // llama a la acción del controlador$controlador ->$acción(); ) demás ( // también sería más prudente lanzar una excepción aquí Ruta::ErrorPage404(); ) ) función PáginaError404() ($host = "http://" .$_SERVER ["HTTP_HOST" ]."/" ; encabezado ("HTTP/1.1 404 no encontrado"); encabezado("Estado: 404 No encontrado"); encabezado("Ubicación:".$host ."404" ); ) )

Observo que la clase implementa una lógica muy simplificada (a pesar del voluminoso código) y puede incluso tener problemas de seguridad. Esto se hizo intencionalmente, porque... Escribir una clase de enrutamiento completa merece al menos un artículo aparte. Veamos los puntos principales...

El elemento de matriz global $_SERVER["REQUEST_URI"] contiene dirección completa por el cual el usuario contactó.
Por ejemplo: ejemplo.ru/contacts/feedback

Usando la función explotar La dirección se divide en componentes. Como resultado, obtenemos el nombre del controlador, en el ejemplo dado, este es controlador contactos y el nombre de la acción, en nuestro caso - comentario.

A continuación, se conectan el archivo del modelo (puede que falte el modelo) y el archivo del controlador, si lo hay, y finalmente, se crea una instancia del controlador y se llama a la acción, nuevamente, si se describió en la clase del controlador.

Así, al dirigirse a, por ejemplo, la dirección:
ejemplo.com/portfolio
o
ejemplo.com/portfolio/index
El enrutador realizará las siguientes acciones:

incluirá el archivo model_portfolio.php de la carpeta de modelos, que contiene la clase Model_Portfolio;
incluirá el archivo controlador_portfolio.php de la carpeta de controladores, que contiene la clase Controlador_Portfolio;
creará una instancia de la clase Controller_Portfolio y llamará a la acción predeterminada, action_index, descrita en ella.

Si el usuario intenta acceder a la dirección de un controlador inexistente, por ejemplo:
ejemplo.com/ufo
luego será redirigido a la página "404":
ejemplo.com/404
Lo mismo ocurrirá si el usuario accede a una acción que no está descrita en el controlador.

2.2. Volvamos a la implementación de MVC.

Vamos a carpeta principal y agregue tres archivos más al archivo route.php: modelo.php, view.php y controlador.php

Permítanme recordarles que contendrán clases base, que ahora comenzaremos a escribir.

Contenido del archivo modelo.php
modelo de clase ( público función obtener_datos() ( } }
La clase modelo contiene un único método de recuperación de datos vacío, que se anulará en las clases descendientes. Cuando creemos clases descendientes todo quedará más claro.

Contenido del archivo ver.php
vista de clase ( //público $template_view; // aquí puede especificar la vista general predeterminada. función generar ( $content_view, $template_view, $datos = nulo) { /* if(is_array($data)) ( // convierte elementos de la matriz en variables extract($data); ) */ incluya "aplicación/vistas/".$template_view; ) )
No es difícil adivinar que el método generar destinado a formar una vista. Se le pasan los siguientes parámetros:

$content_file - vistas que muestran el contenido de la página;
$template_file — plantilla común a todas las páginas;
$data es una matriz que contiene elementos de contenido de la página. Generalmente se completa en el modelo.

La función de inclusión conecta dinámicamente una plantilla general (vista) dentro de la cual se incrustará la vista.
para mostrar el contenido de una página específica.

En nuestro caso, la plantilla general contendrá encabezado, menú, barra lateral y pie de página, y el contenido de la página estará contenido en un formulario separado. Nuevamente, esto se hace por simplicidad.

Contenido del archivo controlador.php
controlador de clase ( modelo $ público; vista pública $; función __construcción() ($this ->vista = nueva Vista(); ) ) )
Método índice_acción- esta es la acción llamada por defecto; la anularemos al implementar clases descendientes.

2.3. Implementación de clases descendientes Modelo y Controlador, creación de Vistas

¡Ahora comienza la diversión! Nuestro sitio web de tarjetas de presentación constará de las siguientes páginas:

hogar
Servicios
portafolio
Contactos
Y también - la página "404"

Cada página tiene su propio controlador de la carpeta de controladores y una vista de la carpeta de vistas. Algunas páginas pueden usar un modelo o modelos de la carpeta de modelos.

En la figura anterior, el archivo está resaltado por separado. plantilla_vista.php es una plantilla que contiene marcas comunes a todas las páginas. En el caso más sencillo podría verse así:
<html lang="ru" > <cabeza > <metacharset="utf-8"> <título > hogartítulo > cabeza > <cuerpo > $vista_contenido; ?> cuerpo > HTML >
Para darle al sitio un aspecto presentable, diseñamos plantilla css e integrarlo en nuestro sitio web cambiando la estructura del marcado HTML y Conexiones CSS y archivos JavaScript:
<enlace rel ="hoja de estilo" tipo ="text/css" href ="/css/style.css" /> <script src="/js/jquery-1.6.2.js" tipo="texto/javascript" >guión >
Al final del artículo, en la sección “Resultado”, hay un enlace a un repositorio de GitHub con un proyecto en el que se han dado pasos para integrar una plantilla sencilla.

2.3.1. Creando la página principal

Empecemos con el controlador. controlador_principal.php, aquí está su código:
clase Controller_Main extiende el controlador ( función índice_acción() ($this ->view->generate("main_view.php", "template_view.php"); ) )
en método generar una instancia de la clase Vista, se pasan los nombres de los archivos de la plantilla general y la vista con el contenido de la página.
Además de la acción de índice, el controlador puede, por supuesto, contener otras acciones.

Archivo con vista general miramos antes. Considere el archivo de contenido vista_principal.php:
<h1 >¡Bienvenido!h1 > <p> <img src="/images/office-small.jpg" align="izquierda" > <un href = "/" > EQUIPO OLOLOSHAun >- un equipo de especialistas de primer nivel en el campo del desarrollo de sitios web con muchos años de experiencia en la colección de máscaras mexicanas, estatuas de bronce y piedra de la India y Ceilán, bajorrelieves y esculturas creadas por maestros de África Ecuatorial hace cinco o seis siglos. ..p>
Contiene marcado simple sin llamadas PHP.
Para mostrar la página principal, puede utilizar una de las siguientes direcciones:

métodos de bibliotecas que implementan la abstracción de datos. Por ejemplo, métodos de la biblioteca PEAR MDB2;
métodos ORM;
métodos para trabajar con NoSQL;
y etc.

modelo_portfolio.php

clase Model_Portfolio extiende el modelo (

función obtener_datos() (

"Sitio promocional de la cerveza oscura Dunkel del fabricante alemán Löwenbraü, producida en Rusia por la empresa cervecera SUN InBev."

"Catálogo en ruso teléfonos chinos Empresa Zopo basada en sistema operativo Android y accesorios."

) ) La clase de controlador del modelo está contenida en el archivo, aquí está su código:
controlador_cartera.php función __construcción() ( clase Controller_Portfolio extiende el controlador ( función índice_acción() ($this ->modelo = nuevo Model_Portfolio(); $this ->vista = nueva Vista(); )
$datos = $this ->modelo->get_data(); $this ->view->generate("portfolio_view.php", "template_view.php", $datos); ) ) a una variable datos se escribe la matriz devuelta por el método obtener datos
que vimos antes. generar Luego, esta variable se pasa como parámetro del método.

, que también contiene: el nombre del archivo con la plantilla general y el nombre del archivo que contiene la vista con el contenido de la página. La vista que contiene el contenido de la página está en el archivo..

portafolio

Enlace de GitHub: https://github.com/vitalyswipe/tinymvc/zipball/v0.1

Pero en esta versión esbocé las siguientes clases (y sus tipos correspondientes):
Controller_Login en el que se genera una vista con un formulario para ingresar nombre de usuario y contraseña, luego de completarlo se realiza el procedimiento de autenticación y, si tiene éxito, se redirige al usuario al panel de administración.

La autenticación y la autorización son un tema diferente, por lo que no se analizan aquí, pero solo se proporciona el enlace que figura arriba para que tenga un punto de partida.

Pero no siempre es recomendable utilizar frameworks web como Yii o Kohana, que constan de varios cientos de archivos, al desarrollar aplicaciones web simples (por ejemplo, sitios de tarjetas de presentación). Ahora podemos crear un hermoso modelo MVC para no mezclar código Php, Html, CSS y JavaScript en un solo archivo.

Este artículo es más un punto de partida para aprender CMF que un ejemplo de algo realmente correcto que puede utilizar como base para su aplicación web. Quizás incluso te haya inspirado y ya estés pensando en escribir tu propio microframework o CMS basado en MVC. Pero, antes de reinventar la próxima rueda con “blackjack y putas”, piénselo de nuevo: ¡¿tal vez sería más razonable dirigir sus esfuerzos al desarrollo y ayuda a la comunidad de un proyecto ya existente?!

P.D.: El artículo fue reescrito teniendo en cuenta algunos comentarios dejados en los comentarios. La crítica resultó muy útil. A juzgar por la respuesta: comentarios, MP y la cantidad de usuarios que agregaron la publicación a favoritos, la idea de escribir esta publicación resultó no ser tan mala. Desafortunadamente, no es posible tener en cuenta todos los deseos y escribir más y con más detalle debido a la falta de tiempo... pero tal vez esos misteriosos individuos que rechazaron la versión original lo hagan. Buena suerte con tus proyectos!

5. Una selección de enlaces útiles sobre el tema.

Popular en la categoría:

Cómo fusionar capas en Photoshop en una o combinarlas en un grupo...

leer

Transferir contactos a un nuevo teléfono Android

leer

Samsung Galaxy se reinicia solo - Soluciones Galaxy Note...

leer

Características clave de Kaspersky Rescue Disk

leer

MacBook no se conecta a wifi MacBook no ve...

leer

Cómo ganar dinero con WebMoney

leer

Tableta "Supra": opiniones de clientes

leer

Ubicaciones de barcos en tiempo real

leer

Los mejores programas para Android Grabar llamadas desde...

leer

Eliminar a los no seguidores en Twitter

leer

Conexión a Internet en una computadora portátil: todo lo posible...

leer

Samsung Galaxy S IV es el nuevo buque insignia...

leer

Arriba

Todos los proyectos de la siguiente tabla son ficticios, así que ni siquiera intentes seguir los enlaces proporcionados.	Año	Proyecto
Descripción	" .$fila ["Año" ]."	" .$fila ["Sitio" ]."