XML Path Language (XPath)

XML Path Language (XPath)
Principal
Otras traducciones
Traducciones:
Nota sobre la traducción:
Este documento es una traducción al castellano de la
Recomendación
del W3C:
"XML Path Language (XPath) Version 1.0".
En este documento se han corregido los errores de la lista de errores
conocidos en la versión inglesa:
Sin embargo pueden haberse introducido otros errores, que son de la
exclusiva responsabilidad del traductor. Para cualquier comentario dirigirse
al autor de la traducción:
Juan Gómez
Duaso
Esta traducción ha sido publicada el 19 de octubre de 2001.
La
única
versión normativa de este documento es la
versión
original en inglés
que se encuentra en el sitio web del W3C.
Ninguna
parte del presente documento en castellano es normativa
aunque se
especifique lo contrario.
W3C
MIT
INRIA
Keio
),
Todos los Derechos Reservados. Son aplicables las reglas del W3C sobre
obligaciones
marcas
registradas
utilización
de documentos
licencias
de software
Lenguaje de Caminos XML (XPath)
Versión 1.0
Recomendación del W3C 16 Noviembre 1999
Esta versión:
(disponible en
XML
HTML
Última versión:
Versiones anteriores:
Editores:
James Clark

Steve DeRose (Inso Corp. y Brown University)

W3C
MIT
INRIA
Keio
),
Todos los Derechos Reservados. Son aplicables las reglas del W3C sobre
obligaciones
marcas
registradas
utilización
de documentos
licencias
de software
Resumen
XPath es un lenguaje para direccionar partes de un documento XML, diseñado
para ser utilizado tanto por XSL como por  XPointer.
Status de este documento
Este documento ha sido examinado por los miembros del  W3C y otras
partes interesadas y ha sido respaldado por el Director como una
Recomendación
del W3C. Es un documento estable y puede ser usado como material de
referencia  o citado como referencia normativa en otros documentos. El
papel del W3C al  hacer la Recomendación es atraer la atención hacia la
especificación  y promover su  general difusión. Esto mejora la
funcionalidad  e interoperabilidad de la Web.
La lista de errores conocidos en [la versión inglesa de] esta
especificación está disponible en
Se pueden enviar comentarios sobre esta especificación a
www-xpath-comments@w3.org
; se dispone de
archivos
de los comentarios.
La versión inglesa de esta especificación es la única versión normativa.
Sin embargo, para traducciones de este documento, véase
Se puede encontrar una lista actualizada de Recomendaciones del W3C y otros
documentos técnicos en
Esta especificación es un trabajo conjunto del Grupo de Trabajo de XSL y del
Grupo de Trabajo de Enlaces XML [XML Linking] y por  tanto es parte de
la
Actividad  de Estilo
del W3C
y de la
Actividad de XML del W3C
Tabla de contenidos
Introducción
Caminos de Localización
2.1
Pasos de Localización
2.2
Ejes
2.3
Pruebas de Nodo
2.4
Predicados
2.5
Sintaxis Abreviada
Expresiones
3.1
Fundamentos
3.2
Llamadas a funciones
3.3
Conjuntos de nodos
3.4
Booleanos
3.5
Números
3.6
Cadenas
3.7
Estructura Léxica
Biblioteca básica de funciones
4.1
Funciones de
conjuntos de nodos
4.2
Funciones de
cadenas
4.3
Funciones
booleanas
4.4
Funciones
numéricas
Modelo de datos
5.1
Nodo raíz
5.2
Nodos elemento
5.2.1
Identificadores
únicos
5.3
Nodos atributo
5.4
Nodos espacio de nombres
5.5
Nodos
instrucción de procesamiento
5.6
Nodos comentario
5.7
Nodos texto
Conformidad
Apéndices
Referencias
A.1
Referencias
normativas
A.2
Otras
Referencias
Correspondencias con el Conjunto de Información XML
(No-Normativo)
1 Introducción
XPath es el resultado de un esfuerzo para proporcionar  una sintaxis y
semántica comunes para  funcionalidades compartidas entre XSL
Transformations
[XSLT]
y XPointer
[XPointer]
.  El objetivo principal de  XPath es direccionar
partes de un documento XML
[XML]
.  Como soporte
para  este objetivo principal, también proporciona facilidades básicas
para  manipulación de cadenas, números y booleanos.  XPath utiliza
una  sintaxis compacta y no-XML para facilitar el uso de XPath dentro de
URIs y de valores de atributos XML.  XPath opera sobre la estructura
lógica  abstracta de un documento XML, más que en su sintaxis
superficial. XPath  obtiene su denominación por el uso que hace de una
notación  de caminos, como en los URLs, para navegar a través de la
estructura jerárquica  de un documento XML.
Además de su uso para direccionar, XPath esta diseñado  también de
modo que tiene un subconjunto natural que puede usarse para cotejar (comprobar
si un nodo encaja con un patrón o no); este uso de XPath está descrito en
XSLT
XPath modela un documento XML como un árbol de nodos. Hay diferentes tipos
de nodos, incluyendo nodos elemento, nodos atributo y  nodos texto. XPath
define un modo de calcular un
valor de cadena
para cada tipo de nodo. Algunos tipos de nodo también  tienen
nombres.  XPath es totalmente compatible con  XMLNamespaces
[XML
Names]
.  Así, el  nombre de un nodo se modela como un par
consistente en una parte local y  un (quizá nulo) URI de espacio de
nombres; esto se llama un
nombre expandido
El modelo de datos está descrito en detalle en
Modelo  de datos
La construcción sintáctica básica en XPath es la expresión.  Una
expresión se ajusta a la regla de producción
Expr
Las expresiones son evaluadas para producir un objeto, que tendrá uno de los
siguientes cuatro tipos básicos:
Conjunto de nodos (una colección desordenada de nodos sin duplicados)
booleano (verdadero o falso)
número (un número en punto flotante)
cadena (una secuencia de caracteres  UCS)
La evaluación de expresiones tiene lugar respecto  a un contexto.
XSLT y XPointer especifican como se determina el contexto  para las
expresiones XPath usadas en XSLT y XPointer respectivamente. El  contexto
consiste en:
Un nodo (
el
nodo contextual
un par de enteros positivos no nulos (
la
posición contextual
el
tamaño
contextual
un conjunto de asignaciones de  variables
una biblioteca de funciones
el conjunto de declaraciones de espacios de nombres aplicables a la
expresión
La posición contextual es siempre menor o igual que el tamaño contextual.
Las asignaciones de variables consisten en una correspondencia de nombres de
variable a valores de variable.  El valor de una variable es un objeto, que
puede ser de cualquiera de los tipos posibles para el valor de una expresión, y
puede también ser de tipos adicionales no especificados aquí.
La biblioteca de funciones consiste en una correspondencia  de nombres
de funciones a funciones.  Cada función toma cero  o más argumentos
y devuelve un único resultado.  Este documento  define una biblioteca
básica de funciones que todas las implementaciones  de XPath deben
soportar (véase
4 Biblioteca básica  de funciones
).Para
las funciones de la biblioteca básica  de funciones, los argumentos y el
resultado son de los cuatro tipos básicos.  Tanto  XSLT como XPointer
extienden XPath mediante la definición de funciones adicionales; algunas de
esas funciones operan sobre los cuatro  tipos básicos; otras operan sobre
tipos de datos adicionales definidos  por XSLT y XPointer.
Las declaraciones de espacios de nombres consisten en una correspondencia de
prefijos a URIs de espacios de nombres.
Las asignaciones de variables, biblioteca de funciones y declaraciones de
espacios de nombres utilizadas para evaluar una subexpresión son siempre las
mismas que las que se emplean para evaluar la expresión que la contiene.
EL nodo contextual, la posición contextual y el tamaño contextual utilizados
para evaluar una subexpresión son a veces diferentes de los que se emplean para
evaluar la expresión que la contiene. Varios tipos de expresiones cambian el
nodo contextual; solo los predicados cambian la posición contextual y el
tamaño contextual  ( véase
2.4Predicados
).
Al describir la evaluación de un tipo de expresión, siempre se hace constar
explícitamente si el nodo contextual, la posición contextual y el tamaño
contextual cambian para la evaluación de subexpresiones; si nada se dice sobre
el nodo contextual, la posición contextual y el tamaño contextual,
permanecerán inalterados en la evaluación de subexpresiones de ese tipo de
expresión.
Las expresiones XPath a menudo aparecen en atributos XML.  La gramática
especificada en esta sección se aplica al valor  del atributo tras la
normalización  XML1.0. Así, por ejemplo,  si la gramática usa el
caracter <, este no debe aparecer en el  código fuente XML como <
sino que debe ser  tratado conforme a  las reglas de XML 1.0
introduciéndolo, por ejemplo, como
<
Dentro de las expresiones, las cadenas literales se delimitan mediante
comillas simples o dobles, las cuales se emplean también para delimitar
atributos  XML. Para evitar que una marca de entrecomillado en una
expresión  sea interpretada por el procesador XML como terminador del
valor del atributo,  la marca de entrecomillado puede introducirse como una
referencia de caracter  (
"
'
).
Alternativamente,  la expresión puede usar comillas simples si el atributo
XML se delimita  con comillas dobles o  viceversa.
Un tipo importante de expresión es el camino de localización. Un camino de
localización selecciona un conjunto de nodos relativo al nodo de
contexto.  El resultado de evaluar una expresión que sea un camino de
localización es el conjunto de nodos seleccionados por el camino de
localización.  Los caminos de localización pueden contener recursivamente
expresiones utilizadas para filtrar conjuntos de nodos. Un camino de
localización se ajusta a la regla de producción
LocationPath
En la gramática que sigue, los no-terminales
QName
NCName
se definen en
[XML Names]
, y
se define en
[XML]
.  La gramática usa la misma notación
EBNF que
[XML]
(salvo que los símbolos gramaticales siempre
tienen iniciales en mayúsculas).
Las expresiones se analizan dividiendo primero la cadena de caracteres a
analizar en "tokens" y a continuación analizando la secuencia de
tokens resultante. Se puede usar libremente espacio en blanco entre
tokens.  El proceso de "tokenización" se describe en
3.7
Estructura Léxica
2 Caminos de Localización
Aunque los caminos de localización no son la construcción gramatical más
general en el lenguaje (un
LocationPath
es un
caso especial de
Expr
), son la construcción más
importante y se describirán por tanto en primer lugar.
Todo camino de localización se puede expresar utilizando una sintaxis
directa aunque algo verbosa. Hay también ciertas abreviaturas sintácticas que
permiten expresar casos frecuentes con concisión. Esta sección explicará la
semántica de los caminos de localización utilizando la sintaxis no abreviada.
La sintaxis abreviada será entonces explicada mostrando como se expande en la
sintaxis no abreviada (véase
2.5 Sintaxis abreviada
).
He aquí algunos ejemplos de caminos de localización utilizando la sintaxis
no abreviada:
child::para
selecciona los elementos
para
hijos del nodo contextual
child::*
selecciona todos los elementos hijos del nodo
contextual
child::text()
selecciona todos los nodos texto hijos del
nodo contextual
child::node()
selecciona todos los hijos del nodo
contextual, cualquiera que sea su tipo de nodo
attribute::name
selecciona el atributo
name
del nodo contextual
attribute::*
selecciona todos los atributos del nodo
contextual
descendant::para
selecciona los elementos
para
descendientes del nodo contextual
ancestor::div
selecciona todos los ancestros
div
del nodo contextual
ancestor-or-self::div
selecciona los ancestros
div
del nodo contextual y, si el nodo contextual es un elemento
div
, el nodo contextual también
descendant-or-self::para
selecciona los elementos
para
descendientes del nodo contextual y, si el nodo contextual es un
elemento
para
, el nodo contextual también
self::para
selecciona el nodo contextual si este es un
elemento
para
, en otro caso no selecciona nada
child::chapter/descendant::para
selecciona los
elementos
para
descendientes de los elementos
chapter
hijos del nodo contextual
child::*/child::para
selecciona todos los nietos
para
del nodo contextual
selecciona la raíz del documento (que es siempre el padre
del elemento de documento)
/descendant::para
selecciona todos los elementos
para
en el mismo documento que el nodo contextual
/descendant::olist/child::item
selecciona todos los
elementos
item
que tienen un padre
olist
y que
estén en el mismo documento que el nodo contextual
child::para[position()=1]
selecciona el primer hijo
para
del nodo contextual
child::para[position()=last()]
selecciona el último hijo
para
del nodo contextual
child::para[position()=last()-1]
selecciona el penúltimo
hijo
para
del nodo contextual
child::para[position()>1]
selecciona todos los hijos
para
del nodo contextual salvo el primero
following-sibling::chapter[position()=1]
selecciona el siguiente hermano
chapter
del nodo
contextual
preceding-sibling::chapter[position()=1]
selecciona el anterior hermano
chapter
del nodo contextual
/descendant::figure[position()=42]
selecciona el
cuadragésimo segundo elemento
figure
en el documento
/child::doc/child::chapter[position()=5]/child::section[position()=2]
selecciona la segunda
section
del quinto
chapter
del
elemento de documento
doc
child::para[attribute::type="warning"]
selecciona todos los hijos
para
del nodo contextual que tengan
un atributo
type
con valor
warning
child::para[attribute::type='warning'][position()=5]
selecciona el quinto hijo
para
del nodo contextual que tenga un
atributo
type
con valor
warning
child::para[position()=5][attribute::type="warning"]
selecciona el quinto hijo
para
del nodo contextual
si ese hijo tiene un atributo
type
con valor
warning
child::chapter[child::title='Introduction']
selecciona los hijos
chapter
del nodo contextual que
tengan uno o más hijos
title
con
string-value
igual a
Introduction
child::chapter[child::title]
selecciona los hijos
chapter
del nodo contextual que tengan uno o más hijos
title
child::*[self::chapter or self::appendix]
selecciona los hijos
chapter
appendix
del nodo contextual
child::*[self::chapter or self::appendix][position()=last()]
selecciona el último hijo
chapter
appendix
del
nodo contextual
Hay dos tipos de caminos de localización: caminos de localización relativos
y caminos de localización absolutos.
Un camino de localización relativo consiste en una secuencia de uno o más
pasos de localización separados por
.  Los pasos en un
camino de localización relativo se componen de izquierda a derecha. Cada paso
selecciona un conjunto de nodos relativos a un nodo contextual. Una secuencia
inicial de pasos se une al paso siguiente de la siguiente forma.  La
secuencia inicial de pasos selecciona un conjunto de nodos relativos a un nodo
de contexto. Cada nodo de ese conjunto se usa como nodo de contexto para el
siguiente paso. Los distintos conjuntos de nodos identificados por ese paso se
unen. El conjunto de nodos identificado por la composición de pasos es dicha
unión. Por ejemplo,
child::div/child::para
selecciona
los elementos
para
hijos de los elementos
div
hijos
del nodo contextual, o, en otras palabras, los elementos
para
nietos que tengan padres
div
Un camino de localización absoluto consiste en
seguido
opcionalmente por un camino de localización relativo.  Una
por si misma selecciona el nodo raíz del documento que contiene al nodo
contextual. Si es seguida por un camino de localización relativo, entonces el
camino de localización selecciona el conjunto de nodos que  seleccionaría
el camino de localización relativo relativo al nodo raíz del documento que
contiene al nodo contextual.
Location Paths
[1]
LocationPath
::=
RelativeLocationPath
AbsoluteLocationPath
[2]
AbsoluteLocationPath
::=
'/'
RelativeLocationPath
AbbreviatedAbsoluteLocationPath
[3]
RelativeLocationPath
::=
Step
RelativeLocationPath
'/'
Step
AbbreviatedRelativeLocationPath
2.1 Pasos de localización
Un paso de localización tiene tres partes:
un eje, que especifica la relación jerárquica entre los nodos
seleccionados por el paso de localización y el nodo contextual,
una prueba de nodo, que especifica el tipo de nodo y el
nombre-expandido
de los nodos seleccionados por el paso de localización, y
cero o más predicados, que usan expresiones arbitrarias para refinar
aún más el conjunto de nodos seleccionado por el paso de localización.
La sintaxis del paso de localización es el nombre de eje y prueba de nodo
separados por dos caracteres de dos puntos, seguido de cero o más expresiones,
cada una entre paréntesis cuadrados. Por ejemplo, en
child::para[position()=1]
child
es el nombre del eje,
para
es la prueba de
nodo y
[position()=1]
es un predicado.
El conjunto de nodos seleccionado por el paso de localización es el que
resulta de generar un conjunto de nodos inicial a partir del eje y prueba de
nodo, y a continuación filtrar dicho conjunto por cada uno de los predicados
sucesivamente.
El conjunto de nodos inicial se compone de los nodos que tengan la relación
con el nodo contextual que se especifica en el eje, y tengan el tipo de nodo
nombre-expandido
especificados por la
prueba de nodo. Por ejemplo, un paso de localización
descendant::para
selecciona los elementos
para
descendientes del nodo contextual:
descendant
especifica que cada nodo en el conjunto de nodos inicial debe ser un
descendiente del contexto;
para
especifica que cada nodo en el
conjunto de nodos inicial debe ser un elemento llamado
para
Los ejes disponibles se describen en
2.2 Ejes
. Las pruebas de nodo disponibles se describen en
2.3Pruebas
de nodos
. El significado de algunas pruebas de nodos depende del eje.
El conjunto de nodos inicial se filtra por el primer predicado para generar
un nuevo conjunto de nodos; este nuevo conjunto de nodos es entonces filtrado
usando el segundo predicado, y así sucesivamente. El conjunto de nodos final es
el conjunto de nodos seleccionado por el paso de localización. El eje afecta a
la forma en que se evalúa la expresión de cada predicado y, por tanto, la
semántica de un predicado se define con respecto a un eje. Véase
2.4
Predicados
Location Steps
[4]
Step
::=
AxisSpecifier
NodeTest
Predicate
AbbreviatedStep
[5]
AxisSpecifier
::=
AxisName
'::'
AbbreviatedAxisSpecifier
2.2 Ejes
Están disponibles los siguientes ejes:
El eje
child
contiene los hijos del nodo contextual
El eje
descendant
contiene los descendientes del nodo
contextual; un descendiente es un hijo o el hijo de un hijo, etc; de este
modo el eje descendant nunca contiene nodos atributo o espacio de nombres
El eje
parent
contiene el
padre
del nodo contextual, si lo hay
El eje
ancestor
contiene los ancestros del nodo contextual;
los ancestros del nodo contextual consisten en el
padre
del nodo contextual y el padre del padre, etc; así, el eje
ancestor siempre incluirá al nodo raíz, salvo que el nodo contextual sea
el nodo raíz
El eje
following-sibling
contiene todos los siguientes
hermanos del nodo contextual; si el nodo contextual es un nodo atributo o un
nodo espacio de nombres, el eje
following-sibling
está vacío
El eje
preceding-sibling
contiene todos los hermanos
precedentes del nodo contextual; si el nodo contextual es un nodo atributo o
un nodo espacio de nombres, el eje
preceding-sibling
está
vacío
El eje
following
contiene todos los nodos del mismo
documento que el nodo contextual que están después de este según el orden
del documento, excluyendo los descendientes y excluyendo nodos atributo y
nodos espacio de nombres
El eje
preceding
contiene todos los nodos del mismo
documento que el nodo contextual que están antes de este según el orden
del documento, excluyendo los ancestros y excluyendo nodos atributo y nodos
espacio de nombres
El eje
attribute
contiene los atributos del nodo contextual;
el eje estará vacío a no ser que el nodo contextual sea un elemento
El eje
namespace
contiene los nodos espacio de nombres
del nodo contextual; el eje estará vacío a no ser que el nodo contextual
sea un elemento
El eje
self
contiene simplemente el propio nodo contextual
El eje
descendant-or-self
contiene el nodo contextual y sus
descendientes
El eje
ancestor-or-self
contiene el nodo contextual y sus
ancestros; así, el eje ancestor-or-self siempre incluirá el nodo raíz
NOTA:
Los ejes
ancestor
descendant
following
preceding
self
particionan un documento (ignorando
los nodos atributo y espacio de nombres): no se superponen y juntos contienen
todos los nodos del documento.
Axes
[6]
AxisName
::=
'ancestor'
| 'ancestor-or-self'
| 'attribute'
| 'child'
| 'descendant'
| 'descendant-or-self'
| 'following'
| 'following-sibling'
| 'namespace'
| 'parent'
| 'preceding'
| 'preceding-sibling'
| 'self'
2.3 Pruebas de nodo
Cada eje tiene un
tipo principal de
nodo
. Si un eje puede contener elementos, entonces el tipo principal de nodo
es elemento; en otro caso, será el tipo de los nodos que el eje contiene. Así,
Para el eje attribute, el tipo de nodo principal es atributo.
Para el eje namespace,  el tipo de nodo principal es espacio de
nombres.
Para los demás ejes,  el tipo de nodo principal es elemento.
Una prueba de nodo que sea un
QName
(nombre calificado) es verdadera si y sólo si el tipo del nodo (véase
Modelo de Datos
) es el tipo principal de nodo y tiene un
nombre
expandido
igual al
nombre expandido
especificado por el
QName
. Por ejemplo,
child::para
selecciona los elementos
para
hijos del nodo contextual; si el nodo contextual no tiene ningún hijo
para
, seleccionará un conjunto de nodos vacío.
attribute::href
selecciona el atributo
href
del nodo contextual; si el nodo
contextual no tiene atributo
href
, seleccionará un conjunto de
nodos vacío.
Un
QName
en
la prueba de nodo se expande en un
nombre expandido
utilizando las declaraciones de espacio de nombres del contexto de la
expresión. Esta es la misma forma en que se hace la expansión para los nombres
de tipos de elemento en las etiquetas de inicio y fin salvo que el espacio de
nombres por defecto declarado con
xmlns
no se utiliza: si el
QName
no tiene prefijo, entonces el URI de espacio de nombres es nulo (esta es la
misma forma en que se expanden los nombres de atributos). Será un error que
el
QName
tenga
un prefijo para el cual no haya una declaración de espacio de nombres en el
contexto de la expresión.
Una prueba de nodo
es verdadera para cualquier nodo del tipo
principal de nodo. Por ejemplo,
child::*
seleccionará todo
elemento hijo del nodo contextual, y
attribute::*
seleccionará
todos los atributos del nodo contextual.
Una prueba de nodo puede tener la forma
NCName
:*
En este caso, el prefijo es expandido de la misma forma que con un
QName
, utilizando las declaraciones de espacio de nombres del contexto. Será un
error que no haya una declaración de espacio de nombres para el prefijo en el
contexto de la expresión. La prueba de nodo será verdadera para cualquier nodo
del tipo principal cuyo
expanded-name
tenga el
URI de espacio de nombres al qué el prefijo se expande, con independencia de la
parte local del nombre.
La prueba de nodo
text()
es verdadera para cualquier nodo de
texto. Por ejemplo,
child::text()
seleccionará los nodos de texto
hijos del nodo contextual. Análogamente, la prueba de nodo
comment()
es verdadera para cualquier nodo comentario, y la prueba de nodo
processing-instruction()
es verdadera para cualquier instrucción de procesamiento. La prueba
processing-instruction()
puede tener un argumento que sea
Literal
; en este
caso, será verdadera para cualquier instrucción de procesamiento que tenga un
nombre igual al valor del
Literal
Una prueba de nodo
node()
es verdadera para cualquier nodo de
cualquier tipo que sea.
[7]
NodeTest
::=
NameTest
NodeType
'(' ')'
| 'processing-instruction' '('
Literal
')'
2.4 Predicados
Los ejes están orientados hacia adelante o hacia atrás. Un eje que sólo
puede contener el nodo contextual o nodos que están a continuación del nodo
contextual según el
orden de documento
es un eje hacia adelante. Un eje que sólo puede contener el nodo contextual o
nodos que están antes del nodo contextual según el
orden
de documento
es un eje hacia atrás. Así, los ejes ancestor,
ancestor-or-self, preceding, y preceding-sibling son ejes hacia atrás; todos
los demás ejes son hacia adelante. Dado que el eje self siempre tendrá a lo
sumo un nodo, no supone ninguna diferencia que sea un eje hacia adelante o hacia
atrás.
La
posición de proximidad
de
un miembro de un conjunto de nodos con respecto a un eje se define como la
posición del nodo en el conjunto ordenado según el orden de documento si el
eje es hacia adelante y según el orden inverso de documento si el eje es hacia
atrás. La primera posición es 1.
Un predicado filtra un conjunto de nodos con respecto a un eje para producir
un nuevo conjunto de nodos. Por cada nodo en el conjunto de nodos a filtrar, la
PredicateExpr
es evaluada con dicho nodo como nodo contextual, con el número de nodos en el
conjunto de nodos como tamaño contextual, y con la
posición
de proximidad
del nodo en el conjunto de nodos respecto al eje como
posición contextual; si
PredicateExpr
se
evalúa como verdadera para ese nodo, el nodo se incluye en el nuevo conjunto de
nodos; en otro caso,  no se incluye.
Una
PredicateExpr
se evalúa evaluando
la
Expr
y convirtiendo el resultado en un
booleano. Si el resultado es un número, se convertirá en verdadero si el
número es igual a la posición contextual y se convertirá en falso en otro
caso; si el resultado no es un número, entonces el resultado se convertirá
igual que con una llamada a la función
boolean
Así un camino de localización
para[3]
es equivalente a
para[position()=3]
Predicates
[8]
Predicate
::=
'['
PredicateExpr
']'
[9]
PredicateExpr
::=
Expr
2.5 Sintaxis abreviada
He aquí algunos ejemplos de caminos de localización usando la sintaxis
abreviada:
para
selecciona los elementos
para
hijos del nodo contextual
selecciona todos los elementos hijos del nodo contextual
text()
selecciona todos los nodos texto hijos del nodo
contextual
@name
selecciona el atributo
name
del nodo
contextual
@*
selecciona todos los atributos del nodo contextual
para[1]
selecciona el primer hijo
para
del nodo contextual
para[last()]
selecciona el último hijo
para
del nodo contextual
*/para
selecciona todos los nietos
para
del
nodo contextual
/doc/chapter[5]/section[2]
selecciona la segunda
section
del quinto
chapter
del
doc
chapter//para
selecciona los elementos
para
descendientes de los elementos
chapter
hijos del nodo
contextual
//para
selecciona todos los descendientes
para
de la raíz del documento y por tanto selecciona todos los elementos
para
que estén en el mismo documento que el nodo contextual
//olist/item
selecciona todos los elementos
item
que estén en el mismo documento que el nodo contextual y tengan un padre
olist
selecciona el nodo contextual
.//para
selecciona los elementos
para
descendientes del nodo contextual
..
selecciona el padre del nodo contextual
../@lang
selecciona el atributo
lang
del padre
del nodo contextual
para[@type="warning"]
selecciona todos los hijos
para
del nodo contextual que tengan un atributo
type
con valor
warning
para[@type="warning"][5]
selecciona el quinto hijo
para
del nodo contextual que tenga un atributo
type
con valor
warning
para[5][@type="warning"]
selecciona el quinto hijo
para
del nodo contextual si dicho hijo tiene un atributo
type
con valor
warning
chapter[title="Introduction"]
selecciona los hijos
chapter
del nodo contextual que tengan uno o más hijos
title
con
valor de cadena
igual a
Introduction
chapter[title]
selecciona los hijos
chapter
del
nodo contextual que tengan uno o más hijos
title
employee[@secretary and @assistant]
selecciona todos los
hijos
employee
del nodo contextual que tengan un atributo
secretary
y un atributo
assistant
La abreviatura más importante es que
child::
puede ser
omitida en un paso de localización. A efectos prácticos,
child
es
el eje por defecto. Por ejemplo, un camino de localización
div/para
es abreviatura de
child::div/child::para
Hay también una abreviatura para atributos:
attribute::
puede
abreviarse como
. Por ejemplo, un camino de localización
para[@type="warning"]
es abreviatura de
child::para[attribute::type="warning"]
y por tanto selecciona hijos
para
con un atributo
type
con valor igual a
warning
//
es abreviatura de
/descendant-or-self::node()/
Por ejemplo,
//para
es abreviatura de
/descendant-or-self::node()/child::para
y por tanto seleccionará cualquier elemento
para
en el documento
(incluso un elemento
para
que sea el elemento de documento será
seleccionado por
//para
ya que el nodo elemento de documento es
hijo del nodo raíz);
div//para
es abreviatura de
child::div/descendant-or-self::node()/child::para
y por tanto seleccionará todos los descendientes
para
de hijos
div
NOTA:
El camino de localización
//para[1]
no
significa lo mismo que el camino de localización
/descendant::para[1]
. Este último selecciona el primer descendiente elemento
para
el primero selecciona todos los descendientes elementos
para
que
sean el primer hijo
para
de sus padres.
Un paso de localización
es abreviatura de
self::node()
Esto es particularmente útil en conjunción  con
//
. Por
ejemplo, el camino de localización
.//para
es abreviatura de
self::node()/descendant-or-self::node()/child::para
y por tanto seleccionará todos los descendientes elementos
para
del nodo contextual.
Análogamente, un paso de localización
..
es abreviatura de
parent::node()
Por ejemplo,
../title
es abreviatura de
parent::node()/child::title
y por tanto seleccionará los hijos
title
del padre del nodo
contextual.
Abbreviations
[10]
AbbreviatedAbsoluteLocationPath
::=
'//'
RelativeLocationPath
[11]
AbbreviatedRelativeLocationPath
::=
RelativeLocationPath
'//'
Step
[12]
AbbreviatedStep
::=
'.'
| '..'
[13]
AbbreviatedAxisSpecifier
::=
'@'?
3 Expresiones
3.1 Fundamentos
Una
VariableReference
se evalúa
como el valor al cual el nombre de variable está asignado en el conjunto de
asignaciones de variables en el contexto. Ocurre un error si el nombre de
variable no está asignado a ningún valor en el conjunto de asignaciones de
variables en el contexto de la expresión.
Pueden utilizarse paréntesis para agrupar.
[14]
Expr
::=
OrExpr
[15]
PrimaryExpr
::=
VariableReference
| '('
Expr
')'
Literal
Number
FunctionCall
3.2 Llamadas a funciones
Una expresión
FunctionCall
se evalúa
utilizando el
FunctionName
para
identificarla en la librería de funciones en el contexto de evaluación de la
expresión, evaluando cada uno de los
Argument
, convirtiendo cada argumento al tipo requerido por la función, y finalmente
llamando a la función, pasándole los argumentos convertidos. Ocurre un error
si el número de argumentos es erróneo o si un argumento no puede ser
convertido al tipo requerido. El resultado de la expresión
FunctionCall
es el resultado devuelto por la función.
Los argumentos se convierten al tipo cadena como si se aplicase la función
string
Los argumentos se convierten al tipo número como si se aplicase la función
number
. Los argumentos se convierten al tipo booleano como si se aplicase la función
boolean
. Un argumento que no sea de tipo conjunto de nodos no puede ser convertido a
conjunto de nodos.
[16]
FunctionCall
::=
FunctionName
'(' (
Argument
( ','
Argument
)* )? ')'
[17]
Argument
::=
Expr
3.3 Conjuntos de nodos
Puede usarse un camino de localización como expresión. La expresión
devuelve el conjunto de nodos seleccionados por el camino.
El operador
calcula la unión de sus operandos, que deben ser
conjuntos de nodos.
Se utilizan
Predicate
s para filtrar expresiones
del mismo modo que se usan en los caminos de localización. Ocurre un error si
la expresión a filtrar no se evalúa en un conjunto de nodos. El
Predicate
filtra el conjunto de nodos con respecto al eje child.
NOTA:
El significado de un
Predicate
depende crucialmente de cual es el eje aplicable. Por ejemplo,
preceding::foo[1]
devuelve el primer elemento
foo
en
orden inverso de
documento
, porque el eje que se aplica al predicado
[1]
es el
eje preceding; por el contrario,
(preceding::foo)[1]
devuelve el
primer elemento
foo
en
orden de documento
, porque el
eje que se aplica al predicado
[1]
es el eje child.
Los operadores
//
componen una expresión
y un camino de localización relativo. Ocurre un error si la expresión no se
evalúa en un conjunto de nodos. El operador
compone del
mismo modo que cuando
se utiliza en un camino de localización.
Al igual que en los caminos de localización,
//
es una abreviatura
de
/descendant-or-self::node()/
No hay ningún tipo de objeto que pueda ser convertido a conjunto de nodos.
[18]
UnionExpr
::=
PathExpr
UnionExpr
'|'
PathExpr
[19]
PathExpr
::=
LocationPath
FilterExpr
FilterExpr
'/'
RelativeLocationPath
FilterExpr
'//'
RelativeLocationPath
[20]
FilterExpr
::=
PrimaryExpr
FilterExpr
Predicate
3.4 Booleanos
Un objeto de tipo booleano puede tener uno de dos valores, verdadero o falso.
Una expresión
or
se evalúa evaluando cada operando y
convirtiendo su valor en booleano como si se aplicase la función
boolean
. El resultado es verdadero si alguno de los dos valores es
verdadero y falso en otro caso. El operando de la derecha no se evalúa si el
operando de la izquierda se evalúa como verdadero.
Una expresión
and
se evalúa evaluando  cada operando y
convirtiendo su valor en booleano como si se aplicase la función
boolean
. El resultado es verdadero si ambos valores son verdaderos y
falso en otro caso. El operando de la derecha no se evalúa si el operando de la
izquierda se evalúa como falso.
Una
EqualityExpr
(que no sea simplemente
una
RelationalExpr
) o una
RelationalExpr
(que no sea simplemente una
AdditiveExpr
) se
evalúan comparando los objetos que resultan de evaluar los dos operandos. La
comparación de los objetos resultantes se define en los tres párrafos
siguientes. Primero, las comparaciones que involucran conjuntos de nodos se
definen en términos de comparaciones que no los involucran; esto se define
uniformemente para
!=
<=
>=
. En segundo lugar, las comparaciones
que no involucran conjuntos de nodos se definen para
!=
En tercer lugar, las comparaciones que no involucran conjuntos de nodos se
definen para
<=
>=
Si los dos objetos a comparar son conjuntos de nodos, entonces la
comparación será verdadera si y sólo si hay un nodo en el primer conjunto de
nodos y un nodo en el segundo conjunto de nodos tales que el resultado de
realizar la comparación de los
valores de
cadena
de los dos nodos es verdadero. Si uno de los objetos a comparar es un
conjunto de nodos y el otro es un número, entonces la comparación será
verdadera si y sólo si hay un nodo en el conjunto tal que el resultado de
realizar la comparación entre el número a comparar y el resultado de convertir
el
valor de cadena
de dicho nodo en un número
utilizando la función
number
es
verdadero. Si un objeto a comparar es un conjunto de nodos y el otro es una
cadena, entonces la comparación será verdadera si y sólo si hay un nodo en el
conjunto de nodos tal que el resultado de realizar la comparación entre
el
valor de cadena
del nodo y la otra
cadena es verdadero. Si un objeto a comparar es un conjunto de nodos y el otro
es un booleano, entonces la comparación será verdadera si y sólo si el
resultado de realizar la comparación entre el booleano y el resultado de
convertir el conjunto de nodos en un booleano usando la función
boolean
es verdadero.
Cuando ninguno de los objetos a comparar es un conjunto de nodos y el
operador es
!=
, entonces los objetos se comparan
convirtiéndolos en un tipo común tal como sigue y comparándolos a
continuación. Si al menos un objeto a comparar es booleano, entonces ambos
objetos a comparar se convierten en booleanos como si se aplicase la función
boolean
. En otro caso, si al menos un objeto a comparar es un número, entonces ambos
objetos a comparar se convierten en números como si se aplicase la función
number
. En otro caso, ambos objetos a comparar se convierten en cadenas como si se
aplicase la función
string
. La
comparación
será verdadera si y sólo si los objetos son
iguales; la comparación
!=
será verdadera si y sólo si los
objetos no son iguales. Los números se comparan para la igualdad de acuerdo
con  IEEE 754
[IEEE 754]
. Dos booleanos son iguales
si ambos son verdaderos o ambos son falsos. Dos cadenas son iguales si y sólo
si consisten en la misma secuencia de caracteres UCS.
NOTA:
Si
$x
está asignada a un conjunto de nodos,
entonces
$x="foo"
no significa lo mismo que
not($x!="foo")
: la primera es verdadera si y sólo si
algún
nodo en
$x
tiene el valor de cadena
foo
; la segunda es verdadera si y sólo
si
todos
los nodos en
$x
tienen el valor de cadena
foo
Cuando ninguno de los objetos a comparar es un conjunto de nodos y el
operador es
<=
>=
entonces los objetos se comparan convirtiendo ambos objetos en números y
comparando los números de acuerdo con IEEE 754. La comparación
será verdadera si y sólo si el primer número es menor que el segundo. La
comparación
<=
será verdadera si y sólo si el primer número
es menor o igual que el segundo. La comparación
será
verdadera si y sólo si el primer número es mayor que el segundo. La
comparación
>=
será verdadera si y sólo si el primer número
es mayor o igual que el segundo.
NOTA:
Cuando una expresión XPath aparece en un documento XML,
cualquier operador
<=
debe ser
"escapado" de acuerdo con las reglas de  XML 1.0 usando, por
ejemplo,
<
<=
. En el siguiente
ejemplo el valor del atributo
test
es una expresión  XPath:
...
[21]
OrExpr
::=
AndExpr
OrExpr
'or'
AndExpr
[22]
AndExpr
::=
EqualityExpr
AndExpr
'and'
EqualityExpr
[23]
EqualityExpr
::=
RelationalExpr
EqualityExpr
'='
RelationalExpr
EqualityExpr
'!='
RelationalExpr
[24]
RelationalExpr
::=
AdditiveExpr
RelationalExpr
'<'
AdditiveExpr
RelationalExpr
'>'
AdditiveExpr
RelationalExpr
'<='
AdditiveExpr
RelationalExpr
'>='
AdditiveExpr
NOTA:
El efecto de la gramática de arriba es que el orden de
precedencia sea (de menor a mayor precedencia):
or
and
!=
<=
>=
y los operadores son todos asociativos por la izquierda. Por ejemplo,
> 2 > 1
es equivalente a
(3> 2) > 1
, que se
evalúa como falso.
3.5 Números
Un número representa un número de punto flotante. Un número puede tener
cualquier valor de doble precisión en formato de 64 bits IEEE 754
[IEEE
754]
. Estos incluyen un valor especial "Not-a-Number" (NaN),
infinitos positivo y negativo, y ceros positivo y negativo. Véase la
Section 4.2.3
de
[JLS]
para obtener un resumen de las
reglas clave del estándar  IEEE 754.
Los operadores numéricos convierten sus operandos en números como si se
aplicase la función
number
El operador
realiza la adición.
El operador binario
realiza la substracción. El operador
unario
realiza el cambio de signo. Debe notarse que
-0
se evalúa como cero negativo.
NOTA:
Dado que XML permite
en nombres, el operador
necesitará típicamente ser precedido por espacio en blanco. Por
ejemplo,
foo-bar
se evalúa como un conjunto de nodos conteniendo los elementos
hijo llamados
foo-bar
foo - bar
se evalúa como la
diferencia entre el resultado de convertir en número el
valor
de cadena
del primer elemento hijo
foo
y el resultado de
convertir en número el
valor de cadena
del
primer hijo
bar
El operador * realiza la multiplicación en punto flotante de acuerdo con
IEEE 754. Debe notarse que, si el resultado no es NaN, será positivo si y sólo
si ambos operandos tienen el mismo signo.
El operador
div
realiza la división en punto flotante de
acuerdo con IEEE 754. Debe notarse que, si el resultado no es NaN, será
positivo si y sólo si ambos operandos tienen el mismo signo.
El operador
mod
devuelve el resto de una división con
truncamiento (división entera). Por ejemplo,
5 mod 2
devuelve
5 mod -2
devuelve
-5 mod 2
devuelve
-1
-5 mod -2
devuelve
-1
NOTA:
Este operador es el mismo que el operador
en
Java y ECMAScript.
NOTA:
Esta operación no es la misma que la operación remainder de
IEEE 754, la cual devuelve el resto de una división con redondeo.
Numeric Expressions
[25]
AdditiveExpr
::=
MultiplicativeExpr
AdditiveExpr
'+'
MultiplicativeExpr
AdditiveExpr
'-'
MultiplicativeExpr
[26]
MultiplicativeExpr
::=
UnaryExpr
MultiplicativeExpr
MultiplyOperator
UnaryExpr
MultiplicativeExpr
'div'
UnaryExpr
MultiplicativeExpr
'mod'
UnaryExpr
[27]
UnaryExpr
::=
UnionExpr
| '-'
UnaryExpr
3.6 Cadenas
Las cadenas consisten en una secuencia de cero o más caracteres, donde los
caracteres se definen según la Recomendación XML
[XML]
. Un
caracter individual en  XPath se corresponde pues con un único caracter
abstracto  Unicode con un único valor escalar Unicode correspondiente
(véase
[Unicode]
); esto no es lo mismo que un valor de
código Unicode de 16 bits: La representación codificada en Unicode de un
caracter abstracto con valor escalar Unicode mayor que U+FFFF es un par de
valores de código Unicode de 16 bits (un par substituto). En muchos lenguajes
de programación, una cadena se representa mediante una secuencia de valores de
código Unicode de 16 bits; las implementaciones de  XPath en tales
lenguajes deberán preocuparse de asegurar que un par substituto sea
correctamente tratado como un  solo caracter XPath.
NOTA:
En Unicode puede haber dos cadenas que deberían ser tratadas
como idénticas a pesar de consistir en distintas secuencias de caracteres
abstractos Unicode. Por ejemplo, algunos caracteres acentuados se pueden
representar tanto  de forma precompuesta como descompuesta.  Por
consiguiente, las expresiones XPath pueden devolver resultados inesperados a
no ser que los caracteres en la expresión XPath y en el documento XML se
hayan normalizado a una forma canónica. Véase
[Character
Model]
3.7 Estructura Léxica
En la "tokenización", siempre se devuelve el token más largo
posible.
Para facilitar la lectura, se pueden utilizar espacios en blanco en las
expresiones aunque no estén explícitamente permitidos por la gramática; Se
puede añadir libremente
ExprWhitespace
en las
expresiones antes o después de cualquier
ExprToken
Las siguientes reglas especiales de "tokenización" se deben
aplicar en el orden especificado para romper la ambigüedad de la gramática de
la expresión
ExprToken
Si existe un token anterior y este no es
::
o un
Operator
, entonces un
se deberá reconocer como un
MultiplyOperator
y un
NCName
se
deberá reconocer como un
OperatorName
Si el caracter que sigue a un
QName
(quizá tras la interposición de
ExprWhitespace
) es
, entonces el token se deberá reconocer como un
NodeType
o un
FunctionName
Si los dos caracteres siguientes a un
NCName
(quizá tras la interposición de
ExprWhitespace
) son
::
, entonces el token se deberá reconocer como un
AxisName
En otro caso, el token no se deberá reconocer como un
MultiplyOperator
un
OperatorName
, un
NodeType
un
FunctionName
, o un
AxisName
Expression Lexical Structure
[28]
ExprToken
::=
'(' | ')' | '[' | ']' | '.' | '..' | '@' | ',' | '::'
NameTest
NodeType
Operator
FunctionName
AxisName
Literal
Number
VariableReference
[29]
Literal
::=
'"' [^"]* '"'
| "'" [^']* "'"
[30]
Number
::=
Digits
('.'
Digits
?)?
| '.'
Digits
[31]
Digits
::=
[0-9]+
[32]
Operator
::=
OperatorName
MultiplyOperator
| '/' | '//' | '|' | '+' |'-' | '=' | '!=' | '<' | '<=' | '>'
| '>='
[33]
OperatorName
::=
'and' | 'or' | 'mod' | 'div'
[34]
MultiplyOperator
::=
'*'
[35]
FunctionName
::=
QName
NodeType
[36]
VariableReference
::=
'$'
QName
[37]
NameTest
::=
'*'
NCName
':' '*'
QName
[38]
NodeType
::=
'comment'
| 'text'
| 'processing-instruction'
| 'node'
[39]
ExprWhitespace
::=
4 Biblioteca básica de funciones
En esta sección se describen funciones que las implementaciones de XPath
deben incluir siempre en la biblioteca de funciones que se usa para evaluar
expresiones.
Cada función en la biblioteca se especifica utilizando un prototipo de
función, que da el tipo devuelto, el nombre de la función y el tipo de los
argumentos. Si un tipo de argumento es seguido por un signo de interrogación,
entonces el argumento es opcional; en otro caso, el argumento es obligatorio.
4.1 Funciones de conjuntos de
nodos
Function:
number
last
()
La función
last
devuelve un
número igual al
tamaño contextual
del
contexto de evaluación de la expresión.
Function:
number
position
()
La función
position
devuelve un
número igual a la
posición contextual
del contexto de evaluación de la expresión.
Function:
number
count
node-set
La función
count
devuelve el número de
nodos en el conjunto de nodos argumento.
Function:
node-set
id
object
La función
id
selecciona elementos
mediante su identificador único (véase
5.2.1
Identificadores únicos
). Cuando el argumento de
id
es de tipo conjunto de nodos, entonces el resultado es la unión de
los resultados de aplicar
id
a los
valores
de cadena
de cada uno de los nodos en el conjunto de nodos argumento. Cuando
el argumento de
id
es de cualquier otro tipo,
el argumento se convierte en cadena como si se aplicase la función
string
la cadena es dividida en una lista de tokens separados por espacios en blanco
(el espacio en blanco es cualquier secuencia de caracteres que se ajuste a la
regla de producción
) ; el
resultado es un conjunto de nodos conteniendo los elementos en el mismo
documento que el nodo contextual que tengan un identificador único igual a
alguno de los tokens de la lista.
id("foo")
selecciona el elemento con identificador
único
foo
id("foo")/child::para[position()=5]
selecciona el
quinto hijo
para
del elemento con identificador único
foo
Function:
string
local-name
node-set
?)
La función
local-name
devuelve la parte local del
nombre expandido
del nodo, en el conjunto de nodos argumento, que es el primero en
orden
de documento
. Si el conjunto de nodos argumento es vacío o el primer nodo
no tiene
nombre expandido
, se devuelve una
cadena vacía. Si se omite el argumento, toma por defecto un conjunto de nodos
con el nodo contextual como único miembro.
Function:
string
namespace-uri
node-set
?)
La función
namespace-uri
devuelve el URI del espacio de nombres del
nombre
expandido
del nodo, en el conjunto de nodos argumento, que es el primero
en
orden de documento
. Si el conjunto de
nodos argumento es vacío, el primer nodo no tiene
nombre
expandido
, o el URI del espacio de nombres del
nombre
expandido
es nulo, se devuelve una cadena vacía. Si se omite el argumento,
toma por defecto un conjunto de nodos con el nodo contextual como único
miembro.
NOTA:
La cadena devuelta por la función
namespace-uri
será vacía excepto para nodos elemento y nodos atributo.
Function:
string
name
node-set
?)
La función
name
devuelve una
cadena conteniendo un
QName
que representa el
nombre expandido
del nodo, en
el conjunto de nodos argumento, que es el primero en
orden
de documento
. El
QName
debe representar al
nombre expandido
con
respecto a las declaraciones de espacio de nombres con efecto sobre el nodo cuyo
nombre expandido
se está representando. Este
será, típicamente, el
QName
que aparecía en la fuente XML. Esto no es necesariamente así si hay
declaraciones de espacio de nombres, con efecto sobre el nodo, que asocien
múltiples prefijos con el mismo espacio de nombres. Sin embargo, las
implementaciones pueden incluir información sobre el prefijo original en su
representación de los nodos; en este caso, la implementación puede asegurarse
de que la cadena devuelta sea siempre la misma que el
QName
utilizado en la fuente XML. Si el conjunto de nodos argumento es vacío o el
primer nodo no tiene
nombre expandido
, se
devuelve una cadena vacía. Si se omite el argumento, toma por defecto un
conjunto de nodos con el nodo contextual como único miembro.
NOTA:
La cadena devuelta por la función
name
será la misma que la cadena devuelta por la función
local-name
salvo para nodos elemento y nodos atributo.
4.2 Funciones de cadenas
Function:
string
string
object
?)
La función
string
convierte un objeto
en cadena del siguiente modo:
Un conjunto de nodos se convierte en cadena devolviendo el
valor
de cadena
del nodo, en el conjunto de nodos, que es el primero en
orden
de documento
. Si el conjunto de nodos es vacío, se devuelve una cadena
vacía.
Un número se convierte en cadena del siguiente modo
NaN se convierte en la cadena
NaN
el cero positivo se convierte en la cadena
el cero negativo se convierte en la cadena
el infinito positivo se convierte en la cadena
Infinity
el infinito negativo se convierte en la cadena
-Infinity
Si el número es un entero, el número se representa en forma decimal
como un
Number
sin punto decimal ni ceros
a la izquierda, precedido con un signo menos (
) si el
número es negativo
En otro caso,  el número se representa en forma decimal como un
Number
incluyendo el punto decimal con al menos
un dígito antes del punto decimal y al menos un dígito después del
punto decimal, precedido por un signo menos (
) si el
número es negativo; no debe haber ceros a la izquierda antes del punto
decimal salvo quizá el dígito obligatorio inmediatamente anterior al
punto decimal; a continuación del dígito obligatorio tras el punto
decimal deberá haber tantos, pero sólo tantos, dígitos adicionales
como sean necesarios para distinguir singularmente el número de todos
los demás valores numéricos en IEEE 754.
El valor falso booleano se convierte en la cadena
false
. El
valor verdadero booleano se convierte en la cadena
true
Un objeto de un tipo distinto de los cuatro tipos básicos se convierte
en cadena de una forma dependiente del tipo en cuestión.
Si se omite el argumento, toma por defecto un conjunto de nodos con el nodo
contextual como único miembro.
NOTA:
La función
string
no está pensada para convertir
números en cadenas para su presentación al usuario. La función
format-number
y el elemento
xsl:number
en
[XSLT]
proporcionan esta funcionalidad.
Function:
string
concat
string
string
string
*)
La función
concat
devuelve la
concatenación de sus argumentos.
Function:
boolean
starts-with
string
string
La función
starts-with
devuelve
verdadero si la primera cadena argumento empieza con la segunda cadena
argumento, y  devuelve falso en otro caso.
Si el segundo argumento es la cadena vacía, entonces se devuelve verdadero.
Function:
boolean
contains
string
string
La función
contains
devuelve
verdadero si la primera cadena argumento contiene a la segunda cadena argumento,
y devuelve falso en otro caso.
Si el segundo argumento es la cadena vacía, entonces se devuelve verdadero.
Function:
string
substring-before
string
string
La función
substring-before
devuelve la subcadena de la primera cadena argumento que precede a la primera
aparición de la segunda cadena argumento en la primera cadena argumento, o la
cadena vacía si la primera cadena argumento no contiene a la segunda cadena
argumento. Por ejemplo,
substring-before("1999/04/01","/")
devuelve
1999
Si el segundo argumento es la cadena vacía, entonces se devuelve la cadena
vacía.
Function:
string
substring-after
string
string
La función
substring-after
devuelve la subcadena de la primera cadena argumento que sigue a la primera
aparición de la segunda cadena argumento en la primera cadena argumento, o la
cadena vacía si la primera cadena argumento no contiene a la segunda cadena
argumento. Por ejemplo,
substring-after("1999/04/01","/")
devuelve
04/01
, y
substring-after("1999/04/01","19")
devuelve
99/04/01
Si el segundo argumento es la cadena vacía, entonces se devuelve la primera
cadena argumento.
Function:
string
substring
string
number
number
?)
La función
substring
devuelve la
subcadena del primer argumento que comienza en la posición especificada en el
segundo argumento y tiene la longitud especificada en el tercer argumento. Por
ejemplo,
substring("12345",2,3)
devuelve
"234"
Si no se especifica el tercer argumento, devuelve la subcadena que comienza en
la posición especificada en el segundo argumento y continúa hasta el final de
la cadena. Por ejemplo,
substring("12345",2)
devuelve
"2345"
Más exactamente, se considera que cada caracter en la cadena (véase
3.6
Strings
) tiene una posición numérica: la posición del primer
caracter es 1, la posición del segundo caracter es 2 y así sucesivamente.
NOTA:
Esto difiere de Java y ECMAScript, en donde el método
String.substring
trata la posición del primer caracter como 0.
La subcadena devuelta contiene aquellos caracteres cuya posición es mayor o
igual que el valor redondeado del segundo argumento y, si se ha especificado un
tercer argumento, menor que la suma de los valores redondeados del segundo y
tercer argumento; las comparaciones y la suma utilizadas en lo anterior siguen
las reglas del estándar IEEE754; el redondeo se realiza como si se aplicase la
función
round
. Los siguientes ejemplos
ilustran varios casos inusuales:
substring("12345", 1.5, 2.6)
devuelve
"234"
substring("12345", 0, 3)
devuelve
"12"
substring("12345", 0 div 0, 3)
devuelve
""
substring("12345", 1, 0 div 0)
devuelve
""
substring("12345", -42, 1 div 0)
devuelve
"12345"
substring("12345", -1 div 0, 1 div 0)
devuelve
""
Function:
number
string-length
string
?)
La función
string-length
devuelve el número de caracteres en la cadena (véase
3.6
Cadenas
). Si se omite el argumento, toma por defecto el nodo
contextual convertido en cadena, es decir, el
valor
de cadena
del nodo contextual.
Function:
string
normalize-space
string
?)
La función
normalize-space
devuelve la cadena argumento con el espacio en blanco normalizado mediante la
eliminación del que se encuentra al principio y al final y la substitución de
secuencias de caracteres de espacio en blanco por un solo espacio. Los
caracteres de espacio en blanco son los mismos que se permiten en la regla de
producción
de XML. Si se
omite el argumento, toma por defecto el nodo contextual convertido en
cadena  es decir, el
valor de cadena
del
nodo contextual.
Function:
string
translate
string
string
string
La función
translate
devuelve la
cadena primer argumento con las apariciones de caracteres del segundo argumento
substituidas por los caracteres en las posiciones correspondientes de la tercera
cadena argumento. Por ejemplo,
translate("bar","abc","ABC")
devuelve la cadena
BAr
. Si hay un caracter en la segunda cadena
argumento sin caracter en la posición correspondiente en la tercera cadena
argumento (debido a que la segunda cadena argumento es más larga que la tercera
cadena argumento), entonces las apariciones de dicho caracter en la primera
cadena argumento son eliminadas. Por ejemplo,
translate("--aaa--","abc-","ABC")
devuelve
"AAA"
. Si un caracter aparece más de una vez en
la segunda cadena argumento, entonces la primera aparición determina el
caracter de reemplazo. Si la cadena tercer argumento es más larga que la cadena
segundo argumento, entonces los caracteres extra son ignorados.
NOTA:
La función
translate
no
es una solución suficiente para la conversión entre mayúsculas y
minúsculas en todos los idiomas. Una futura versión de XPath podría aportar
funciones adicionales para esa conversión.
4.3 Funciones Booleanas
Function:
boolean
boolean
object
La función
boolean
convierte su
argumento en booleano como sigue:
un número es verdadero si y sólo si no es ni cero positivo o negativo
ni NaN
un conjunto de nodos es verdadero si y sólo si es no vacío
una cadena es verdadera si y sólo si su longitud no es cero
un objeto de un tipo distinto a los cuatro tipos básicos se convierte en
booleano de una forma dependiente de dicho tipo
Function:
boolean
not
boolean
La función
not
devuelve verdadero si su
argumento es falso, y falso en otro caso.
Function:
boolean
true
()
La función
true
devuelve verdadero.
Function:
boolean
false
()
La función
false
devuelve falso.
Function:
boolean
lang
string
La función
lang
devuelve verdadero o
falso dependiendo de si el lenguaje del nodo contextual tal como se especifica
por los atributos
xml:lang
es el mismo que, o es un sublenguaje de,
el lenguaje especificado por la cadena argumento. El lenguaje del nodo
contextual se determina por el valor del atributo
xml:lang
en el
nodo contextual, o, si el nodo contextual no tiene atributo
xml:lang
, por el valor del atributo
xml:lang
en el ancestro más cercano
del nodo contextual que tenga atributo
xml:lang
. Si no hay tal
atributo, entonces
lang
devuelve falso. Si
hay tal atributo, entonces
lang
devuelve
verdadero si el valor del atributo es igual al argumento ignorando mayúsculas y
minúsculas, o si hay algún sufijo empezando con
tal que
el valor del atributo es igual al argumento ignorando dicho sufijo en el valor
del atributo e ignorando mayúsculas y minúsculas. Por ejemplo,
lang("en")
devolvería verdadero si el nodo contextual fuese alguno de estos cinco
elementos: