Cada variable en la ruta puede tener un valor predeterminado y para eso se usa el segundo parámetro del constructor de Zend_Controller_Router_Route. Este parámetro es un array con claves que representan nombres de variables y con valores como los predeterminados deseados:

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

La ruta anterior coincidirá con URLs como http://domain.com/archive/2005 y http://example.com/archive. En el último caso la variable year tendrá un valor predeterminado inicial de 2006.

Este ejemplo resultará en la inyección de una variable year en el objeto request. Dado que no hay información de enrutamiento presente (no se definen parámetros de controller y action), la aplicación se despachará al controlador y método de acción predeterminados (ambos definidos en Zend_Controller_Dispatcher_Abstract). Para hacerlo más útil, debe proporcionar un controller y una action válidos como valores predeterminados de la ruta:

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

Esta ruta resultará entonces en el despacho al método showAction() de la clase ArchiveController.

Se puede añadir un tercer parámetro al constructor de Zend_Controller_Router_Route donde pueden establecerse los requisitos de las variables. Estos se definen como partes de una expresión regular:

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

Con una ruta definida como la anterior, el enrutador la hará coincidir solo cuando la variable year contenga datos numéricos, por ejemplo http://domain.com/archive/2345. Una URL como http://example.com/archive/test no coincidirá y el control pasará a la siguiente ruta de la cadena en su lugar.

La ruta estándar admite segmentos traducidos. Para usar esta característica, debe definir al menos un traductor (una instancia de Zend_Translate) mediante una de las siguientes formas:

Por defecto, se usará el locale especificado en la instancia de Zend_Translate. Para sobrescribirlo, se establece (una instancia de Zend_Locale o una cadena de locale) de una de las siguientes maneras:

Los segmentos traducidos se dividen en dos partes. Los segmentos fijos se prefijan con un único signo @, y se traducirán al locale actual al ensamblar y se revertirán al ID del mensaje al volver a coincidir. Los segmentos dinámicos se prefijan con :@. Al ensamblar, el parámetro dado se traducirá y se insertará en la posición del parámetro. Al coincidir, el parámetro traducido de la URL se revertirá al ID del mensaje nuevamente.

	IDs de mensaje y archivo de idioma separado
	Ocasionalmente un ID de mensaje que desea usar en una de sus rutas ya se usa en un script de vista o en algún otro lugar. Para tener control total sobre URLs seguras, debería usar un archivo de idioma separado para los mensajes usados en la ruta.

La siguiente es la forma más simple de preparar la ruta estándar para el uso de segmentos traducidos:

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

// Set the current locale for the translator
$translator->setLocale('en');

// Set it as default translator for routes
Zend_Controller_Router_Route::setDefaultTranslator($translator);

Este ejemplo demuestra el uso de segmentos estáticos:

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

// Assemble the URL in default locale: archive
$route->assemble(array());

// Assemble the URL in german: archiv
$route->assemble(array());

Puede usar los segmentos dinámicos para crear una versión traducida similar a una ruta module:

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

// Assemble the URL in default locale: archive/index/foo/bar
$route->assemble(array('controller' => 'archive', 'foo' => 'bar'));

// Assemble the URL in german: archiv/uebersicht/foo/bar
$route->assemble(array('controller' => 'archive', 'foo' => 'bar'));

También puede mezclar segmentos estáticos y dinámicos:

// Create the route
$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);

// Assemble the URL in default locale: archive/month/5
$route->assemble(array('mode' => 'month', 'value' => '5'));

// Assemble the URL in german: archiv/monat/5
$route->assemble(array('mode' => 'month', 'value' => '5', '@locale' => 'de'));

Para encadenar rutas juntas en un archivo de configuración, hay parámetros adicionales para la configuración de estas. El enfoque más simple es usar el parámetro chains. Este es simplemente una lista de rutas, que se encadenarán con la ruta padre. Ni la ruta padre ni la ruta hija se añadirán directamente al enrutador, solo la ruta encadenada resultante. El nombre de la ruta encadenada en el enrutador será el nombre de la ruta padre y el nombre de la ruta hija concatenados con un guion (-) por defecto. Una configuración simple en XML se vería así:

<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>

Esto resultará en las tres rutas www-language-index, www-language-imprint y users-language-profile que solo coincidirán en función del hostname y la ruta misc, que coincidirá con cualquier hostname.

La forma alternativa de crear una ruta encadenada es mediante el parámetro chain, que solo puede usarse directamente con el tipo de ruta chain, y que también solo funciona en el nivel raíz:

<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>

También puede dar el parámetro chain como array en lugar de separar las rutas con una coma:

<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>

Cuando configure rutas chain con Zend_Config y desee que el separador de nombre de la cadena sea diferente de un guion, necesita especificar este separador por separado:

$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

Para habilitar Zend_Rest_Route para toda una aplicación, constrúyala sin parámetros de configuración y añádala como la ruta predeterminada en el controlador frontal:

$front     = Zend_Controller_Front::getInstance();
$restRoute = new Zend_Rest_Route($front);
$front->getRouter()->addRoute('default', $restRoute);

	Nota
	Si Zend_Rest_Route no puede hacer coincidir un módulo, controlador o acción válidos, devolverá FALSE y el enrutador intentará coincidir usando la siguiente ruta en el enrutador.

Para habilitar Zend_Rest_Route para módulos específicos, constrúyala con un array de nombres de módulos como el tercer argumento del constructor:

$front     = Zend_Controller_Front::getInstance();
$restRoute = new Zend_Rest_Route($front, array(), array('product'));
$front->getRouter()->addRoute('rest', $restRoute);

Para habilitar Zend_Rest_Route para controladores específicos, añada un array de nombres de controladores como el valor de cada elemento del array de módulo.

$front     = Zend_Controller_Front::getInstance();
$restRoute = new Zend_Rest_Route($front, array(), array(
    'product' => array('ratings')
));
$front->getRouter()->addRoute('rest', $restRoute);

Para usar Zend_Rest_Route desde un archivo de configuración INI, use un parámetro de tipo de ruta y establezca las opciones de configuración:

routes.rest.type = Zend_Rest_Route
routes.rest.defaults.controller = object
routes.rest.mod = project,user

La opción 'type' designa el tipo de configuración de enrutamiento RESTful. La opción 'defaults' se usa para especificar módulo, controlador y/o acciones predeterminados personalizados para la ruta. Todas las demás opciones en el grupo de configuración se tratan como nombres de módulos RESTful, y sus valores son nombres de controladores RESTful. El ejemplo de configuración define Mod_ProjectController y Mod_UserController como controladores RESTful.

Luego use el método addConfig() del objeto router Rewrite:

$config = new Zend_Config_Ini('path/to/routes.ini');
$router = new Zend_Controller_Router_Rewrite();
$router->addConfig($config, 'routes');

Para ayudar o guiar el desarrollo de controladores para su uso con Zend_Rest_Route, haga que sus controladores extiendan de Zend_Rest_Controller. Zend_Rest_Controller define las 5 operaciones más comúnmente necesarias para recursos RESTful en forma de métodos de acción abstractos.