XPath es un lenguaje para direccionar partes de un documento XML, diseñado
para ser utilizado tanto por XSL como por XPointer.
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 http://www.w3.org/1999/11/REC-xpath-19991116-errata.
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 http://www.w3.org/Style/XSL/translations.html.
Se puede encontrar una lista actualizada de Recomendaciones del W3C y otros
documentos técnicos en http://www.w3.org/TR.
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.
1 Introducción
2 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
3 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
4 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
5 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
6 Conformidad
Apéndices
A Referencias
A.1 Referencias
normativas
A.2 Otras
Referencias
B 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 [5
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 y 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 (" o ').
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
y NCName
se definen en [XML Names], y S
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 y appendix
del nodo contextual
-
child::*[self::chapter or self::appendix][position()=last()]
selecciona el último hijo chapter o 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
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
y 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
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 y 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 [5
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.
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
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
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.
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 Arguments
, 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.
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 Predicates 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 / y // 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.
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 =, !=, <=,<
, >= y >. En segundo lugar, las comparaciones
que no involucran conjuntos de nodos se definen para = y !=.
En tercer lugar, las comparaciones que no involucran conjuntos de nodos se
definen para <= ,<, >= y >.
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 = o !=, 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 <=, <, >= o >,
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 < o <= debe ser
"escapado" de acuerdo con las reglas de XML 1.0 usando, por
ejemplo,< y <=. En el siguiente
ejemplo el valor del atributo test es una expresión XPath:
<xsl:if test="@value < 10">...</xsl:if>
NOTA: El efecto de la gramática de arriba es que el orden de
precedencia sea (de menor a mayor precedencia):
y los operadores son todos asociativos por la izquierda. Por ejemplo, 3
> 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 1
-
5 mod -2 devuelve 1
-
-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
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
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: numberlast()
La función last devuelve un
número igual al tamaño contextual del
contexto de evaluación de la expresión.
Function: numberposition()
La función position devuelve un
número igual a la posición contextual
del contexto de evaluación de la expresión.
Function: numbercount(node-set
)
La función count devuelve el número de
nodos en el conjunto de nodos argumento.
Function: node-setid(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 S) ; 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.
Function: stringlocal-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: stringnamespace-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: stringname(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: stringstring(
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 0
-
el cero negativo se convierte en la cadena 0
-
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: stringconcat(string,
string, string*)
La función concat devuelve la
concatenación de sus argumentos.
Function: booleanstarts-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: booleancontains(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: stringsubstring-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: stringsubstring-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: stringsubstring(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: numberstring-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: stringnormalize-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 S 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: stringtranslate(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: booleanboolean(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: booleannot(boolean)
La función not devuelve verdadero si su
argumento es falso, y falso en otro caso.
Function: booleantrue()
La función true devuelve verdadero.
Function: booleanfalse()
La función false devuelve falso.
Function: booleanlang(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:
<para xml:lang="en"/>
<div xml:lang="en"><para/></div>
<para xml:lang="EN"/>
<para xml:lang="en-us"/>
4.4 Funciones numéricas
Function: numbernumber(object?)
La función number convierte su
argumento en un número como sigue:
-
una cadena que consista en espacio en blanco opcional seguido de un signo
menos opcional seguido de un Number seguido
de espacio en blanco se convierte en el número IEEE 754 que esté más
próximo (según la regla de redondeo al mas cercano de IEEE 754) al valor
matemático representado por la cadena; cualquier otra cadena se convierte
en NaN
-
el valor booleano verdadero se convierte en 1; el valor booleano falso se
convierte en 0
-
Un conjunto de nodos se convierte primero en cadena como si se aplicase
la función string y a continuación
se convierte de la misma forma que los argumentos de tipo cadena
-
Un objeto de un tipo distinto de los cuatro tipos básicos se convierte
en número de una forma dependiente de dicho tipo
Si se omite el argumento, toma por defecto un conjunto de nodos con el nodo
contextual como único miembro.
NOTA: La función number
no debería ser usada para la conversión de datos numéricos que aparezcan en
un elemento de un documento XML a no ser que el elemento sea de un tipo que
represente datos numéricos en un formato independiente de los lenguajes (que
sería típicamente transformado en un formato específico de un lenguaje para
su presentación al usuario). Además, la función number
no puede ser usada salvo que el formato independiente de los lenguajes que
utiliza el elemento sea consistente con la sintaxis de XPath para Number.
Function: numbersum(node-set)
La función sum devuelve la suma, a lo
largo de todos los nodos del conjunto de nodos argumento, del resultado de
convertir los valores de cadena de los nodos en
números.
Function: numberfloor(number)
La función floor devuelve el mayor
(más cercano al infinito positivo) número que no sea mayor que el argumento y
que sea entero.
Si el argumento es NaN entonces se devuelve NaN. Si el argumento es el
infinito positivo, entonces se devuelve el infinito positivo. Si el argumento es
el infinito negativo, entonces se devuelve el infinito negativo. Si el argumento
es el cero positivo, entonces se devuelve el cero positivo. Si el argumento es
el cero negativo, entonces se devuelve el cero negativo. Si el argumento es
mayor que cero, pero menor que 1, entonces se devuelve el cero positivo.
Function: numberceiling(number)
La función ceiling devuelve el menor
(más cercano al infinito negativo) número que no sea menor que el argumento y
que sea entero.
Si el argumento es NaN entonces se devuelve NaN. Si el argumento es el
infinito positivo, entonces se devuelve el infinito positivo. Si el argumento es
el infinito negativo, entonces se devuelve el infinito negativo. Si el argumento
es el cero positivo, entonces se devuelve el cero positivo. Si el argumento es
el cero negativo, entonces se devuelve el cero negativo. Si el argumento es
menor que cero, pero mayor que -1, entonces se devuelve el cero negativo.
Function: numberround(number)
La función round devuelve el número
que esté más próximo al argumento y que sea entero. Si hay dos números en
esas condiciones, entonces devuelve el más cercano al infinito positivo. Si el
argumento es NaN, entonces se devuelve NaN. Si el argumento es el infinito
positivo, entonces se devuelve el infinito positivo. Si el argumento es el
infinito negativo, entonces se devuelve el infinito negativo. Si el argumento es
el cero positivo, entonces se devuelve el cero positivo. Si el argumento es el
cero negativo, entonces se devuelve el cero negativo. Si el argumento es menor
que cero, pero mayor o igual que -0.5, entonces se devuelve el cero
negativo.
NOTA: Para estos dos últimos caso, el resultado de llamar a la
función round no es el mismo que
el resultado de añadir 0.5 y a continuación llamar a la función floor.
5 Modelo de datos
XPath opera sobre un documento XML considerándolo como un árbol. Esta
sección describe la forma en que XPath modela un documento XML como un árbol.
Este modelo es solamente conceptual y no impone ninguna implementación en
particular. La relación entre este modelo y el Conjunto de Información XML [XML
Infoset] se describe en [B XML Information Set Mapping
].
Los documentos XML sobre los que opera XPath deben ser acordes con la
Recomendación de Espacios de Nombres XML [XML Names].
El árbol contiene nodos. Hay siete tipos de nodos:
Para cada tipo de nodo, hay una forma de
determinar un valor de cadena para los nodos de ese tipo. Para
algunos tipos de nodo, el valor de cadena es parte del nodo; para otros tipos de
nodo, el valor de cadena se calcula a partir del valor de cadena de nodos
descendientes.
NOTA: Para nodos elemento y nodos raíz, el valor de cadena de un nodo
no es lo mismo que la cadena devuelta por el método DOMnodeValue
(véase [DOM]).
Algunos tipos de nodo tienen también
un nombre expandido, que es un par formado por una parte local y un
URI de espacio de nombres. La parte local es una cadena. EL URI de espacio de
nombres es o bien nulo o bien una cadena. Un namespace
name especificado en una declaración de espacio de nombres de un documento
XML, es una referencia URI tal como se define en [RFC2396];
Esto implica que puede tener un identificador de fragmento y puede ser relativo.
El componente URI de espacio de nombres de un nombre
expandido depende de la implementación si el nombre
expandido es la expansión de un QName
cuyo prefijo se declara en una declaración de espacio de nombres con un nombre
de espacio de nombres que es un URI relativo (con o sin identificador de
fragmento). Una expresión XPath que dependa del valor del componente URI de
espacio de nombres de uno de tales nombres
expandidos no es interoperable. Dos nombres
expandidos son iguales si tienen la misma parte local, y o bien ambos tienen
un URI de espacio de nombres nulo o bien ambos tienen URIs de espacio de nombres
no nulos que son iguales.
Hay una ordenación, el orden de
documento, definida sobre todos los nodos del documento correspondiente con
el orden en que el primer caracter de la representación XML de cada nodo
aparece en la representación XML del documento tras la expansión de las
entidades generales. Así, el nodo raíz será el primer nodo. Los nodos
elemento aparecen antes de sus hijos. Por tanto, el orden de documento ordena
los nodos elemento en el orden de aparición de sus etiquetas de apertura en el
XML (tras la expansión de entidades). Los nodos atributo y los nodos espacio de
nombres de un elemento aparecen antes que los hijos del elemento. Los nodos
espacio de nombres aparecen por definición antes que los nodos atributo. El
orden relativo de los nodos espacio de nombres depende de la implementación. El
orden relativo de los nodos atributo depende de la implementación.
El Orden inverso de documento es el inverso del orden
de documento.
Los nodos raíz y los nodos elemento tienen una lista ordenada de nodos hijo.
Los nodos nunca comparten un hijo: si un nodo no es el mismo nodo que otro,
entonces ninguno de los hijos del primer nodo será el mismo nodo que ninguno de
los hijos del otro nodo. Todos los nodos salvo el nodo
raíz tienen exactamente un padre, que es o bien un nodo elemento o
bien el nodo raíz. Un nodo raíz o un nodo elemento es el padre de cada uno de
sus nodos hijo. Los descendientes de un nodo
son los hijos del nodo y los descendientes de los hijos del nodo.
5.1 Nodo Raíz
El nodo raíz es la raíz del árbol. No aparecen nodos raíz salvo como
raíz del árbol. El nodo elemento del elemento de documento es hijo del nodo
raíz. El nodo raíz tiene también como hijos los nodos instrucción de
procesamiento y comentario correspondientes a las instrucciones de procesamiento
y comentarios que aparezcan en el prólogo y tras el fin del elemento de
documento.
El valor de cadena del nodo raíz es la
concatenación de los valores de cadena de
todos los nodos texto descendientes del nodo raíz
en orden de documento.
El nodo raíz no tiene nombre expandido.
5.2 Nodos elemento
Hay un nodo elemento por cada elemento en el documento. Los nodos elemento
tienen un nombre expandido calculado
expandiendo el QName
del elemento especificado en la etiqueta de acuerdo con la Recomendación de
Espacios de Nombres XML [XML Names]. El URI de espacio
de nombres del nombre expandido del elemento
será nulo si el QName
no tiene prefijo y no hay un espacio de nombres por defecto aplicable.
NOTA: En la notación del Apéndice A.3 de [XML
Names], la parte local del nombre expandido se corresponde con el atributo
type del elemento ExpEType; El URI de espacio de
nombres del nombre expandido se corresponde con el atributo ns
del elemento ExpEType, y es nulo si el atributo ns
del elemento ExpEType es omitido.
Los hijos de un nodo elemento son los nodos elemento, nodos comentario, nodos
instrucción de procesamiento y nodos texto que contiene. Las referencias de
entidades tanto a entidades internas como externas son expandidas. Las
referencias de caracteres son resueltas.
El valor de cadena de un nodo elemento es la
concatenación de los valores de cadena de todos
los nodos texto descendientes del nodo elemento en
orden de documento.
5.2.1 Identificadores únicos
Los nodos elemento pueden tener un identificador único (ID). Este es el
valor del atributo que se declara en el DTD como de tipo ID. No
puede haber dos elementos en un documento con el mismo ID. Si un procesador XML
informa de la existencia de dos elementos de un documento con el mismo ID (lo
cuales posible sólo si el documento es no valido) entonces el segundo
elemento en orden de documento debe ser tratado como si no tuviese ID.
NOTA: Si un documento no tiene DTD, entonces ningún elemento del
documento tendrá ID.
5.3 Nodos atributo
Cada nodo elemento tiene asociado un conjunto de nodos atributo; el elemento
es el padre de cada uno de esos nodos atributo;
sin embargo, los nodos atributo no son hijos de su elemento padre.
NOTA: Esto es distinto de lo que ocurre en el DOM, que no se refiere a
los elementos que llevan un atributo como padres del atributo (véase [DOM]).
Los elementos nunca comparten nodos atributo: Si dos nodos elemento son
distintos, entonces ninguno de los nodos atributo del primer elemento será el
mismo nodo que ningún nodo atributo del otro nodo elemento.
NOTA: El operador = comprueba si dos nodos tienen el mismo
valor, no si son el mismo nodo. Así, atributos de dos elementos
diferentes pueden ser comparados como iguales utilizando =, a
pesar de que no son el mismo nodo.
Un atributo tomado por defecto se trata igual que uno especificado. Si un
atributo se había declarado para el tipo del elemento en la DTD, aunque el
valor por defecto se había declarado como #IMPLIED , y el atributo
no fue especificado en el elemento, entonces el conjunto de nodos atributo del
elemento no contendrá un nodo para el atributo.
Algunos atributos, tal como xml:lang y xml:space,
tienen la semántica de ser aplicables a todos los elementos que sean
descendientes del elemento que lleva el atributo, salvo que sean redefinidos por
una instancia del mismo atributo en otro elemento descendiente. Sin embargo,
esto no afecta a donde aparecen los nodos atributo en el árbol: un elemento
tiene nodos atributo correspondientes únicamente a atributos explícitamente
especificados en la etiqueta de apertura o etiqueta de elemento vacío de dicho
elemento o que fueron explícitamente declarados en la DTD con un valor por
defecto.
Los nodos atributo tienen un nombre expandido
y un valor de cadena. El nombre
expandido se calcula expandiendo el QName
especificado en la etiqueta en el documento XML de acuerdo con la Recomendación
de Espacios de Nombres XML [XML Names]. El URI de
espacio de nombres del nombre del atributo será nulo si el QName
del atributo no tiene prefijo.
NOTA: En la notación del Apéndice A.3 de [XML
Names] , la parte local del nombre expandido se corresponde con el
atributo name del elemento ExpAName; el URI de
espacio de nombres del nombre expandido se corresponde con el atributo ns
del elemento ExpAName, y es nulo si el atributo ns
del elemento ExpAName es omitido.
Los nodos atributo tienen un valor de cadena.
El valor de cadena es el valor normalizado tal
como se especifica en la Recomendación XML [XML]. Un
atributo cuyo valor normalizado es una cadena de longitud cero no es tratado de
una forma especial: da lugar a un nodo atributo cuyo valor
de cadena es una cadena de longitud cero.
NOTA: Para atributos por defecto es posible que la declaración tenga
lugar en una DTD externa o una entidad de parámetro externa. La
Recomendación XML no impone a los procesadores XML la lectura de DTDs
externas o parámetros externos salvo que el procesador incluya validación.
Una hoja de estilo u otro mecanismo que asuma que el árbol XPath contiene
valores de atributos por defecto declarados en una DTD externa o entidad de
parámetro podría no funcionar con algunos procesadores XML no validadores.
No hay nodos atributo correspondientes a atributos que declaran espacios de
nombres (véase [XML Names]).
5.4 Nodos espacio de nombres
Cada elemento tiene un conjunto asociado de nodos espacio de nombres, uno
para cada uno de los distintos prefijos de espacio de nombres con efecto sobre
el elemento (incluyendo el prefijo xml, que está implícitamente
declarado según la Recomendación de Espacios de Nombres XML [XML
Names]) y uno para el espacio de nombres por defecto si hay alguno con
efecto sobre el elemento. El elemento es el padre de
cada uno de los nodos espacio de nombres; sin embargo, los nodos espacio de
nombres no son hijos de su elemento padre. Los elementos nunca comparten nodos
espacio de nombres: Si dos nodos elemento son distintos, entonces ninguno de los
nodos espacio de nombres del primer elemento será el mismo nodo que ningún
nodo espacio de nombres del otro nodo elemento. Esto significa que los elementos
tendrán un nodo espacio de nombres:
-
para cada atributo del elemento cuyo nombre empiece por xmlns:;
-
para cada atributo de un elemento ancestro cuyo nombre empiece por xmlns:
salvo que el propio elemento o un ancestro más cercano redeclaren el
prefijo;
-
para atributos xmlns, si el elemento o alguno de sus
ancestros tienen dicho atributo y el valor del atributo en el más
cercano de los elementos que lo tienen es no vacío
NOTA: Un atributo xmlns=""
"desdeclara" el espacio de nombres por defecto (véase [XML
Names]).
Los nodos espacio de nombres tienen un nombre
expandido: la parte local es el prefijo de espacio de nombres (este es
vacío si el nodo espacio de nombres corresponde al espacio de nombres por
defecto); el URI de espacio de nombres es siempre nulo.
El valor de cadena de un nodo espacio de
nombres es el URI de espacio de nombres que se está asociando al prefijo de
espacio de nombres; si el nombre de espacio de nombres que aparece en la
declaración de espacio de nombres del documento XML es un URI relativo (con o
sin identificador de fragmento), entonces el valor de
cadena depende de la implementación. Una expresión XPath que dependa
del valor de cadena de uno de tales nodos
de espacio de nombres no es interoperable.
5.5 Nodos instrucción
de procesamiento
Hay un nodo instrucción de procesamiento para cada instrucción de
procesamiento, salvo para aquellas que aparezcan dentro de la declaración de
tipo de documento.
Las instrucciones de procesamiento tienen un nombre
expandido: la parte local es el destinatario de la instrucción de
procesamiento; el URI de espacio de nombres es nulo. El valor
de cadena de un nodo instrucción de procesamiento es la parte de la
instrucción de procesamiento que sigue al destinatario y todo el espacio en
blanco. No incluye la terminación ?>.
NOTA: La declaración XML no es una instrucción de procesamiento. En
consecuencia, no hay nodo instrucción de procesamiento correspondiente a
ella.
5.6 Nodos comentario
Hay un nodo comentario para cada comentario, salvo para aquellos que
aparezcan dentro de la declaración de tipo de documento.
El valor de cadena de los comentarios es el
contenido del comentario sin incluir el inicio <!-- ni la
terminación -->.
Los nodos comentario no tienen nombre
expandido.
5.7 Nodos texto
Los datos de caracter se agrupan en nodos texto. En cada nodo texto se
agrupan todos los datos de caracter que sea posible: un nodo texto nunca tiene
un hermano inmediatamente anterior o siguiente que sea nodo texto. El valor
de cadena de los nodos texto son los datos de caracter. Los nodos texto
siempre tienen al menos un caracter.
Cada caracter en una sección CDATA se trata como datos de caracter. Así, <![CDATA[<]]>
en el documento fuente será tratado igual que <. Ambos
darán lugar a un único caracter < en un nodo texto en el
árbol. Por tanto, una sección CDATA se trata como si <![CDATA[
y ]]> se quitasen y cada aparición de < y &
fuese reemplazada por < y &
respectivamente.
NOTA: Cuando un nodo texto que contiene un caracter <
se escribe como XML, el caracter < debe ser escapado
mediante, por ejemplo, el uso de <, o incluyéndolo en una
sección CDATA.
Los caracteres dentro de comentarios, instrucciones de procesamiento y
valores de atributos no producen nodos texto. Los finales de línea en entidades
externas se normalizan como #xA tal como se especifica en la Recomendación XML [XML].
El espacio en blanco fuera del elemento de documento no produce nodos de texto.
Los nodos de texto no tienen nombre expandido
.
6 Conformidad
XPath está diseñado principalmente para ser un componente que puede ser
utilizado por otras especificaciones. Por consiguiente, XPath confía a las
especificaciones que lo usan (tales como [XPointer] y [XSLT])
la especificación de criterios de conformidad de las implementaciones de XPath
y no define ningún criterio de conformidad para implementaciones de XPath
independientes.
A Referencias
A.1 Referencias Normativas
- IEEE 754
- Institute of Electrical and Electronics Engineers. IEEE Standard for
Binary Floating-Point Arithmetic. ANSI/IEEE Std 754-1985.
- RFC2396
- T. Berners-Lee, R. Fielding y L. Masinter. Uniform Resource Identifiers
(URI): Generic Syntax. IETF RFC 2396. Véase http://www.ietf.org/rfc/rfc2396.txt.
- XML
- World Wide Web Consortium. Extensible Markup Language (XML) 1.0.
W3C Recommendation. Véase http://www.w3.org/TR/1998/REC-xml-19980210
- XML Names
- World Wide Web Consortium. Namespaces in XML. W3C Recommendation.
Véase http://www.w3.org/TR/REC-xml-names
A.2 Otras Referencias
- Character Model
- World Wide Web Consortium. Character Model for the World Wide Web.W3C
Working Draft. Véase http://www.w3.org/TR/WD-charmod
- DOM
- World Wide Web Consortium. Document Object Model (DOM) Level 1
Specification. W3C Recommendation. Véase http://www.w3.org/TR/REC-DOM-Level-1
- JLS
- J. Gosling, B. Joy y G. Steele. The Java Language Specification .
Véase http://java.sun.com/docs/books/jls/index.html
.
- ISO/IEC 10646
- ISO (International Organization for Standardization). ISO/IEC
10646-1:1993, Information technology -- Universal Multiple-Octet Coded
Character Set(UCS) -- Part 1: Architecture and Basic Multilingual Plane.
International Standard. Véase http://www.iso.ch/cate/d18741.html
.
- TEI
- C.M. Sperberg-McQueen, L. Burnard Guidelines for Electronic Text
Encoding and Interchange. Véase http://etext.virginia.edu/TEI.html
.
- Unicode
- Unicode Consortium. The Unicode Standard. Véase http://www.unicode.org/unicode/standard/standard.html.
- XML Infoset
- World Wide Web Consortium. XML Information Set. W3C Working
Draft.Véase
http://www.w3.org/TR/xml-infoset
- XPointer
- World Wide Web Consortium. XML Pointer Language (XPointer). W3C
Working Draft. Véase http://www.w3.org/TR/WD-xptr
- XQL
- J. Robie, J. Lapp, D. Schach. XML Query Language (XQL).
Véase
http://www.w3.org/TandS/QL/QL98/pp/xql.html
- XSLT
- World Wide Web Consortium. XSL Transformations (XSLT). W3C
Recommendation. Véase http://www.w3.org/TR/xslt
B Correspondencias con el Conjunto de Información
XML (No-Normativo)
Los nodos del modelo de datos de XPath se pueden derivar de los items de
información proporcionados por el Conjunto de Información XML [XML
Infoset] del siguiente modo:
NOTA: Una nueva versión del XML Information Set Working
Draft, que reemplazará a la versión del 17 de Mayo, estaba próxima a
completarse en el momento en que se completó la preparación de esta versión
de XPath y se esperaba que fuese publicada al mismo tiempo o poco después de
la publicación de esta versión de XPath. La correspondencia se da respecto a
esta nueva versión del XML Information Set Working Draft. Si la nueva
versión del XML Information Set Working no ha sido aún publicada, los
miembros del W3C pueden consultar la versión interna del grupo de trabajo http://www.w3.org/XML/Group/1999/09/WD-xml-infoset-19990915.html(
members only).
-
El nodo raíz proviene del item de información documento. Los hijos del
nodo raíz provienen de las propiedades children y children -
comments.
-
Los nodos elemento provienen de items de información elemento. Los hijos
de un nodo elemento provienen de las propiedades children y children
- comments. Los atributos de un nodo elemento provienen de la propiedad attributes.
Los espacios de nombres de un nodo elemento provienen de la propiedad in-scope
namespaces. La parte local de un nombre
expandido del nodo elemento proviene de la propiedad local name.
El URI de espacio de nombres del nombre
expandido del nodo elemento proviene de la propiedad namespace URI.
El ID del nodo elemento proviene de la propiedad children del
item de información atributo en la propiedad attributes que tenga
una propiedad attribute type igual a ID.
-
Los nodos atributo provienen de items de información atributo. La parte
local del nombre expandido del nodo atributo
proviene de la propiedad local name. El URI de espacio de nombres del
nombre expandido del nodo atributo proviene
de la propiedad namespace URI. El valor de
cadena del nodo proviene de concatenar la propiedad character code
de cada miembro de la propiedad children.
-
Los nodos de texto provienen de la secuencia de uno o más items de
información de caracter consecutivos. El valor
de cadena del nodo proviene de concatenar la propiedad character code
de cada uno de los items de información de caracter.
-
Los nodos instrucción de procesamiento provienen de items de
información instrucción de procesamiento. La parte local del nombre
expandido del nodo proviene de la propiedad target. (La parte URI
de espacio de nombres del nombre expandido
del nodo es nula.) El valor de cadena del
nodo proviene de la propiedad content. No hay nodos instrucción de
procesamiento correspondientes a items instrucción de procesamiento
que sean hijos del item de información declaración de tipo de documento.
-
Los nodos comentario provienen de items de información comentario. El valor
de cadena del nodo proviene de la propiedad content. No hay nodos
comentario correspondientes a items de información comentario que sean
hijos del item de información declaración de tipo de documento.
-
Los nodos espacio de nombres provienen de items de información
declaración de espacio de nombres. La parte local del nombre
expandido del nodo proviene de la propiedad prefix. (La parte URI
de espacio de nombres del nombre expandido
del nodo es nula.) El valor de cadena del
nodo proviene de la propiedad namespace URI.
Traducciones: