Zend_Controller_Router_Route es la ruta standard del framework. Combina la facilidad de uso con la flexibilidad para la definición de rutas. Cada ruta consiste fundamentalmente en el mapeo de la URL (de partes estáticas y dinámicas (variables)) y puede ser iniciada con valores predeterminados así como con requisitos variables.

Imaginemos que nuestra aplicación ficticia necesitará algunas páginas informativas sobre los autores del contenido. Queremos ser capaces de apuntar nuestro navegador web a http://domain.com/author/martel para ver la información sobre este muchacho "martel". La ruta para esa funcionalidad podría parecerse a:

$route = new Zend_Controller_Router_Route(
    'author/:username',
    array(
        'controller' => 'profile',
        'action'     => 'userinfo'
    )
);

$router->addRoute('user', $route);

El primer parámetro en el constructor Zend_Controller_Router_Route es una definición de ruta que será acompañada de una URL . Las definiciones de ruta consisten en partes estáticas y dinámicas separadas por el caracter barra ('/'). Las partes estáticas son simples textos: author . Las partes dinámicas, llamadas variables, se marcan anteponiendo dos puntos (:) al nombre de la variable :username .

Este ejemplo de ruta debería ser coincidente cuando apunta su navegador a http://domain.com/author/martel , en cuyo caso todas sus variables se inyectan al objeto Zend_Controller_Request y quedando accesibles en ProfileController . Las variables devueltas por este ejemplo pueden ser representadas como el siguiente array de pares clave/valor:

$values = array(
    'username'   => 'martel',
    'controller' => 'profile',
    'action'     => 'userinfo'
);

Después, Zend_Controller_Dispatcher_Standard debe invocar al método userinfoAction() de su clase ProfileController (en el módulo por defecto) basado en estos valores. Allí se podrán acceder a todas las variables mediante los métodos Zend_Controller_Action::_getParam() o Zend_Controller_Request::getParam() :

public function userinfoAction()
{
    $request = $this->getRequest();
    $username = $request->getParam('username');

    $username = $this->_getParam('username');
}

La definición de ruta puede contener uno o más caracteres especiales - un comodín - representado por el símbolo '*'. Se utiliza para reunir parámetros al igual que el valor de ruta por defecto del Módulo (var => pares de valores definidos en la URI ). La siguiente ruta imita más o menos el comportamiento de la ruta del Módulo:

$route = new Zend_Controller_Router_Route(
    ':module/:controller/:action/*',
    array('module' => 'default')
);
$router->addRoute('default', $route);

$route = new Zend_Controller_Router_Route(
    'archive/:year',
    array('year' => 2006)
);
$router->addRoute('archive', $route);

$route = new Zend_Controller_Router_Route(
    'archive/:year',
    array(
        'year'       => 2006,
        'controller' => 'archive',
        'action'     => 'show'
    )
);
$router->addRoute('archive', $route);

$route = new Zend_Controller_Router_Route(
    'archive/:year',
    array(
        'year'       => 2006,
        'controller' => 'archive',
        'action'     => 'show'
    ),
    array('year' => '\d+')
);
$router->addRoute('archive', $route);

// Prepare el traductor
$translator = new Zend_Translate('array', array(), 'en');
$translator->addTranslation(array('archive' => 'archiv',
                                  'year'    => 'jahr',
                                  'month'   => 'monat',
                                  'index'   => 'uebersicht'),
                            'de');

// Establecer el "locale" actual para el traductor
$translator->setLocale('en');

// Establecerlo como traductor por defecto para las rutas
Zend_Controller_Router_Route::setDefaultTranslator($translator);

// Crear la ruta
$route = new Zend_Controller_Router_Route(
    '@archive',
    array(
        'controller' => 'archive',
        'action'     => 'index'
    )
);
$router->addRoute('archive', $route);

// Ensamblar la URL en el locale actual por defecto: archive
$route->assemble(array());

// Ensamblar la URL en alemán: archiv
$route->assemble(array());

// Crear la ruta
$route = new Zend_Controller_Router_Route(
    ':@controller/:@action/*',
    array(
        'controller' => 'index',
        'action'     => 'index'
    )
);
$router->addRoute('archive', $route);

// Ensamblar la URL en el "locale" por defecto: archive/index/foo/bar
$route->assemble(array('controller' => 'archive', 'foo' => 'bar'));

// Ensamblar la URL en alemán: archiv/uebersicht/foo/bar
$route->assemble(array('controller' => 'archive', 'foo' => 'bar'));

// Crear la ruta
$route = new Zend_Controller_Router_Route(
    '@archive/:@mode/:value',
    array(
        'mode'       => 'year'
        'value'      => 2005,
        'controller' => 'archive',
        'action'     => 'show'
    ),
    array('mode'  => '(month|year)'
          'value' => '\d+')
);
$router->addRoute('archive', $route);

// Ensamblar la URL en el "locale" por defecto: archive/month/5
$route->assemble(array('mode' => 'month', 'value' => '5'));

// Ensamblar la URL en alemán: archiv/monat/5
$route->assemble(array('mode' => 'month', 'value' => '5', '@locale' => 'de'));

Los ejemplos sobre todo usan rutas dinámicas -- rutas que contienen patrones contra los cuales comparar. A veces, sin embargo, una ruta en particular pareciera estar seteada en piedra, y ejecutar el motor de expresiones regulares sería excesivo. La respuesta a esta situación es utilizar rutas estáticas:

$route = new Zend_Controller_Router_Route_Static(
    'login',
    array('controller' => 'auth', 'action' => 'login')
);
$router->addRoute('login', $route);

La ruta anterior se comparará con una URL de http://domain.com/login , y hará un dispatch a AuthController::loginAction() .

$front->setParam('useDefaultControllerAlways', true);

Además de los tipos de ruta estáticos y por defecto, también está disponible el tipo de ruta Expresión Regular. Esta ruta ofrece más potencia y flexibilidad que los otros, pero a costa de un ligero aumento en la complejidad. Al mismo tiempo, debería ser más rápido que la standard Route.

Al igual que la standard Route, esta ruta tiene que ser inicializada con una definición de ruta y algunos valores predeterminados. Vamos a crear un archivo ruta como un ejemplo, similar al previamente definido, sólo que esta vez usaremos la ruta Regex:

$route = new Zend_Controller_Router_Route_Regex(
    'archive/(\d+)',
    array(
        'controller' => 'archive',
        'action'     => 'show'
    )
);
$router->addRoute('archive', $route);

Cada sub-patrón regex definido será inyectado al objeto solicitud. Con nuestro ejemplo anterior, después de un matching exitoso http://domain.com/archive/2006 , el valor resultante del array puede verse como:

$values = array(
    1            => '2006',
    'controller' => 'archive',
    'action'     => 'show'
);

Puede obtener el contenido de los sub-patrones definidos por la forma habitual:

public function showAction()
{
    $request = $this->getRequest();
    $year    = $request->getParam(1); // $year = '2006';
}

Sin embargo, esta ruta no funciona exactamente igual que su contraparte standard route dado que el valor por defecto para 'year' todavía no se ha establecido. Y lo que puede ser no tan evidente es que tendremos un problema con una barra final incluso si declaramos por defecto el año y hacemos opcional al sub-patrón. La solución es hacer que toda la parte del año sea opcional junto con la barra pero capturar solo la parte numérica:

$route = new Zend_Controller_Router_Route_Regex(
    'archive(?:/(\d+))?',
    array(
        1            => '2006',
        'controller' => 'archive',
        'action'     => 'show'
    )
);
$router->addRoute('archive', $route);

Ahora, ocupemósnos del problema que probablemente haya notado. Utilizar claves basadas en enteros para los parámetros no es una solución fácilmente manejable y puede ser potencialmente problemática a largo plazo. Y aquí es donde entra el tercer parámetro. Este parámetro es un array asociativo que representa un mapa de sub-patrones regex a nombres de clave de parámetros. Trabajemos en nuestro ejemplo más fácil:

$route = new Zend_Controller_Router_Route_Regex(
    'archive/(\d+)',
    array(
        'controller' => 'archive',
        'action' => 'show'
    ),
    array(
        1 => 'year'
    )
);
$router->addRoute('archive', $route);

Esto resultaraá en los siguientes valores inyectados a la solicitud:

$values = array(
    'year'       => '2006',
    'controller' => 'archive',
    'action'     => 'show'
);

El mapa puede ser definido en cualquier dirección para hacer que funcione en cualquier ambiente. Las claves pueden contener nombres de variables o índices de sub-patrones:

$route = new Zend_Controller_Router_Route_Regex(
    'archive/(\d+)',
    array( ... ),
    array(1 => 'year')
);

// O

$route = new Zend_Controller_Router_Route_Regex(
    'archive/(\d+)',
    array( ... ),
    array('year' => 1)
);

Observe que el índice numérico en los valores del Request ahora han desaparecido y en su lugar se muestra una variable nombrada. Por supuesto que puede mezclar variables nombradas y numéricas si lo desea:

$route = new Zend_Controller_Router_Route_Regex(
    'archive/(\d+)/page/(\d+)',
    array( ... ),
    array('year' => 1)
);

Lo que resultará en una mezcla de valores disponibles en la solicitud. Como ejemplo, la URL http://domain.com/archive/2006/page/10 resultará con los siguientes valores:

$values = array(
    'year'       => '2006',
    2            => 10,
    'controller' => 'archive',
    'action'     => 'show'
);

Dado que los patrones regex no pueden invertirse fácilmente, tendrá que preparar una URL inversa si desea usar un ayudante de URL o incluso un método de ensamble de esta clase. Este path inverso está representado por un string parseable por sprintf() y se define como el cuarto parámetro del constructor:

$route = new Zend_Controller_Router_Route_Regex(
    'archive/(\d+)',
    array( ... ),
    array('year' => 1),
    'archive/%s'
);

Todo esto es algo que ya fue posible de hacer por medio de un objeto de ruta estandard, por lo tanto podría preguntarese: ¿cuál es la ventaja de utilizar la ruta Regex?. Principalmente, le permite describir cualquier tipo de URL sin restricción alguna. Imagínese que tiene un blog y desea crear URLs como: http://domain.com/blog/archive/01-Using_the_Regex_Router.html , y que tiene que descomponer el último elemento del path 01-Using_the_Regex_Router.html , en un ID de artículo y en el título o descripción del artículo; esto no es posible con el standard route. Con la ruta Regex, puede hacer algo como la siguiente solución:

$route = new Zend_Controller_Router_Route_Regex(
    'blog/archive/(\d+)-(.+)\.html',
    array(
        'controller' => 'blog',
        'action'     => 'view'
    ),
    array(
        1 => 'id',
        2 => 'description'
    ),
    'blog/archive/%d-%s.html'
);
$router->addRoute('blogArchive', $route);

Como puede ver, esto añade una enorme cantidad de flexibilidad por encima del standard route.

Zend_Controller_Router_Route_Hostname es la ruta del framework en el servidor. Funciona similarmente a la standard route, pero funciona con el nombre del host de la URL llamada, en lugar del path.

Vamos a usar el ejemplo de la standard route y ver cómo se vería con un nombre basado en host. En lugar de llamar al usuario mediante un path, quisiéramos que un usuario pueda llamar a http://martel.users.example.com para ver la información acerca del usuario "martel".

$hostnameRoute = new Zend_Controller_Router_Route_Hostname(
    ':username.users.example.com',
    array(
        'controller' => 'profile',
        'action'     => 'userinfo'
    )
);

$plainPathRoute = new Zend_Controller_Router_Route_Static('');

$router->addRoute('user', $hostnameRoute->chain($plainPathRoute);

El primer parámetro del constructor en Zend_Controller_Router_Route_Hostname es una definición de ruta que será comparada con el nombre del host. Las definiciones de ruta consisten en partes estáticas y dinámicas separadas por el carácter punto ('.'). Las partes dinámicas, llamadas variables, se marcan anteponiendo dos puntos (':') al nombre de la variable: :username . Las partes estáticas son simplemente texto: user .

Las rutas del nombre del host pueden, pero nunca deben ser utilizadas así. La razón detrás de esto es que la ruta del nombre del host solamente, concordaría con cualquier path. Entonces, lo que tiene que hacer es encadenar una ruta del path a la ruta del nombre del host. Esto se hace como en el ejemplo llamando a $hostnameRoute->chain($pathRoute); . Haciendo esto, $hostnameRoute no se modifica, pero devuelve una nueva ruta ( Zend_Controller_Router_Route_Chain ), que luego puede ser entregada al router.

Zend_Controller_Router_Route_Chain es una ruta que permite encadenar juntas a múltiples rutas. Esto le permite encadenar hostname/rutas y rutas de paths, o múltiples paths de rutas por ejemplo. El encadenamiento puede hacerse programáticamente o dentro de un archivo de configuración.

Cuando el encadenamiento se realiza prográmaticamente, hay dos maneras de archivarlo. La primera consiste en crear una nueva instancia Zend_Controller_Router_Route_Chain y entones llamar al método chain() varias veces con todas las rutas que deberían encadenarse juntas. La otra forma es tomar la primera ruta, por ejemplo, la ruta del nombre del host, y llamar al método chain() con la ruta que debería ser anexada a ella. Esto no modificará la ruta del nombre del host, pero devolverá una nueva instancia de Zend_Controller_Router_Route_Chain , teniendo entonces a ambas rutas encadenadas juntas:

// Crear dos rutas
$hostnameRoute = new Zend_Controller_Router_Route_Hostname(...);
$pathRoute     = new Zend_Controller_Router_Route(...);

// Primera manera, encadenarlas con chain route
$chainedRoute = new Zend_Controller_Router_Route_Chain();
$chainedRoute->chain($hostnameRoute)
             ->chain($pathRoute);

// Segunda manera, encadenarlas directamente
$chainedRoute = $hostnameRoute->chain($pathRoute);

Cuando las rutas se encadenan juntas, su separador es una barra ('/'). Pueden haber casos cuando quiera tener un separador diferente:

// Crear dos rutas
$firstRoute  = new Zend_Controller_Router_Route('foo');
$secondRoute = new Zend_Controller_Router_Route('bar');

// Encadenarlas juntas con un separador diferente
$chainedRoute = $firstRoute->chain($secondRoute, '-');

// Ensamblar la ruta: "foo-bar"
echo $chainedRoute->assemble();

<routes>
    <www type="Zend_Controller_Router_Route_Hostname">
        <route>www.example.com</route>
        <chains>
            <language type="Zend_Controller_Router_Route">
                <route>:language</route>
                <reqs language="[a-z]{2}">
                <chains>
                    <index type="Zend_Controller_Router_Route_Static">
                        <route></route>
                        <defaults module="default" controller="index"
                                  action="index" />
                    </index>
                    <imprint type="Zend_Controller_Router_Route_Static">
                        <route>imprint</route>
                        <defaults module="default" controller="index"
                                  action="index" />
                    </imprint>
                </chains>
            </language>
        </chains>
    </www>
    <users type="Zend_Controller_Router_Route_Hostname">
        <route>users.example.com</route>
        <chains>
            <profile type="Zend_Controller_Router_Route">
                <route>:username</route>
                <defaults module="users" controller="profile" action="index" />
            </profile>
        </chains>
    </users>
    <misc type="Zend_Controller_Router_Route_Static">
        <route>misc</route>
    </misc>
</routes>

<routes>
    <www type="Zend_Controller_Router_Route_Chain">
        <route>www.example.com</route>
    </www>
    <language type="Zend_Controller_Router_Route">
        <route>:language</route>
        <reqs language="[a-z]{2}">
    </language>
    <index type="Zend_Controller_Router_Route_Static">
        <route></route>
        <defaults module="default" controller="index" action="index" />
    </index>
    <imprint type="Zend_Controller_Router_Route_Static">
        <route>imprint</route>
        <defaults module="default" controller="index" action="index" />
    </imprint>

    <www-index type="Zend_Controller_Router_Route_Chain">
        <chain>www, language, index</chain>
    </www-index>
    <www-imprint type="Zend_Controller_Router_Route_Chain">
        <chain>www, language, imprint</chain>
    </www-imprint>
</routes>

<routes>
    <www-index type="Zend_Controller_Router_Route_Chain">
        <chain>www</chain>
        <chain>language</chain>
        <chain>index</chain>
    </www-index>
    <www-imprint type="Zend_Controller_Router_Route_Chain">
        <chain>www</chain>
        <chain>language</chain>
        <chain>imprint</chain>
    </www-imprint>
</routes>

$config = new Zend_Config(array(
    'chainName' => array(
        'type'   => 'Zend_Controller_Router_Route_Static',
        'route'  => 'foo',
        'chains' => array(
            'subRouteName' => array(
                'type'     => 'Zend_Controller_Router_Route_Static',
                'route'    => 'bar',
                'defaults' => array(
                    'module'      => 'module',
                     'controller' => 'controller',
                     'action'     => 'action'
                )
            )
        )
    )
));

// Set separator before adding config
$router->setChainNameSeparator('_separator_')

// Add config
$router->addConfig($config);

// The name of our route now is: chainName_separator_subRouteName
echo $this->_router->assemble(array(), 'chainName_separator_subRouteName');

// The proof: it echoes /foo/bar