nsIURI

Imagen:traduccion-pendiente.png Esta página está traduciéndose a partir del artículo nsIURI, razón por la cual puede haber algunos errores sintácticos o partes sin traducir. Puedes colaborar continuando con la traducción

nsIURI es un interfaz para un identificador de recursos uniforme con soporte de internacionalización, que ofrece atributos que permiten la configuración y filtrado de componentes de URI y métodos para le ejecución de operaciones básicas en URI´s. Para detalles vea los siguientes RFC´s:

RFC2396: La especificación de URI
RFC3490: Internacionalizando los nombres de dominios en aplicaciones (IDNA)
RFC3987: Identificadores de recursos internacionalizados

Las subclases de nsIURI, tales como nsIURL , imponen estructura adicional sobre la URI.

nsIURI se define en netwerk/base/public/nsIURI.idl . Es encriptable y se ha mantenido congelada desde Mozilla 1.0.0 .

Heredada de: nsISupports

Para crear un objeto nsIURI, debes usar el método newURI() de nsIIOService, como este:

view plain print ?

function makeURI(aURL, aOriginCharset, aBaseURI) {
var ioService = Components.classes["@mozilla.org/network/io-service;1"]
.getService(Components.interfaces.nsIIOService);
return ioService.newURI(aURL, aOriginCharset, aBaseURI);
}

Nota: Esta es la única forma correcta de crear un objeto nsIURI.

Componentes de un URI

Vista rápida del método

nsIURI clone()

boolean equals(in nsIURI other);

boolean schemeIs(in string scheme);

AUTF8String resolve(in AUTF8String relativePath);

Atributos

Atributo	Tipo	Descripción
`spec`	`nsACString` (UTF-8)	Retorna un cadena en representación de la URI. Al usar `spec` causa que la nueva spec sea evaluada usando las reglas que tiene actualmente el el esquema de la URI. Si la cadena no puede ser analizada como una URI, aparece un `NS_ERROR_MALFORMED_URI`. (error de URI malformada). Advertencia: Ya que la comprobación de la cadena se ha hecho usando el esquema de la URI actual, el uso de spec para un URI con un esquema diferente producirá resultados incorrectos. Por lo tanto, únicamente las implementaciones del manejador de protocolo debieran hacer esto. Si la URI almacena información de la newURI() de la interfaz de `nsIIOService` que la creó, una cadena además a la analizada, el comportamiento de esta información cuando el atributo spec es establecido, no está definido.
`prePath`	`sololectura nsACString` (UTF-8)	La `prePath` retorna la cadena antes de la ruta(como en "scheme://user:password@host:port"). Esto es muy útil para sesiones de autenticación o administración. Nota: Algunos caracteres pueden ser códigos de escape.
`scheme`	`nsACString (US-ASCII)`	La `scheme` es el protocolo al cual esta URI se refiere. El scheme está restringido a los caractéres de la US-ASCII por RFC2396. Advertencia: Al usar esto fuera de una implementación de manejador de protocolo es muy desalentador, una vez establecido generalmente lleva a obtener resultados impredecibles.
`userPass`	`nsACString` (UTF-8)	El "username:password" (o nombre de usuario sólo si el valor no contiene una':'). Nota: Algunos caracteres pueden ser códigos de escape.
`username`	`nsACString` (UTF-8)	El nombre de usuario opcional, suponiendo que la preHost consiste en "username:password". Nota: Algunos caracteres pueden ser códigos de escape.
`password`	`nsACString` (UTF-8)	La contraseña opcional, suponiendo que la preHost consiste en "usuario:contraseña". Nota: Algunos caracteres pueden ser códigos de escape.
`hostPort`	`nsACString` (UTF-8)	El "servidor:puerto" parte de la URI (o simplemente el servidor, si el puerto es -1). Nota: Los caracteres no son códigos de escape.
`host`	`nsACString` (UTF-8)	El servidor es el nombre de dominio de Internet a los que se refiere este URI. Podría ser una dirección literal IPv4 (o IPv6). Si está soportada, podría ser un nombre de dominio no-ASCII internacionalizado. Nota: Los caracteres no son códigos de escape.
`port`	`PRInt32`	El puerto de URI's. Un valor de puerto de -1 corresponde al puerto por defecto del protocolo (por ejemplo, -1 implica el puerto 80 para HTTP URIs).
`path`	`nsACString` (UTF-8)	La ruta, que típicamente incluye al menos una de las principales '/' (aunque también puede estar vacío, dependiendo del protocolo). Nota: Algunos caracteres pueden ser códigos de escape.
`asciiSpec`	`readonly nsACString` (US-ASCII)	La especificación URI con una codificación compatible con ASCII. La porción de host sigue la especificación del proyecto de IDNA. Otras partes son URL con caracteres de escape por las normas de RFC2396. El resultado es estrictamente ASCII.
`asciiHost`	`readonly nsACString` (US-ASCII)	El servidor URI con una codificación compatible con ASCII. Sigue la especificación del proyecto de IDNA para convertir los nombres de dominio internacionalizados (UTF-8) a ASCII para la compatibilidad con la infraestructura de Internet existente.
`originCharset`	`readonly nsACString`	El juego de caracteres del documento del que se originó este URI. Un valor vacío implica UTF-8. Si este valor es algo distinto de UTF-8 a continuación, los componentes de URI (por ejemplo, spec, prePath, nombre de usuario, etc) son totalmente URL de escape. De lo contrario, los componentes de URI pueden contener caracteres sin escape multibyte UTF-8 .

netwerk/base/public/nsIURI.idlScriptable

Please add a summary to this article.

Last changed in Gecko 1.0.0

Código de interfaz

[scriptable, uuid(07a22cc0-0ce5-11d3-9331-00104ba0fd40)]
interface nsIURI : nsISupports
{
  attribute AUTF8String spec;
  readonly attribute AUTF8String prePath;
  attribute ACString scheme;
  attribute AUTF8String userPass;
  attribute AUTF8String username;
  attribute AUTF8String password;
  attribute AUTF8String hostPort;
  attribute AUTF8String host;
  attribute long port;
  attribute AUTF8String path;

  boolean equals(in nsIURI other);
  boolean schemeIs(in string scheme);
  nsIURI clone();
  AUTF8String resolve(in AUTF8String relativePath);

  readonly attribute ACString asciiSpec;
  readonly attribute ACString asciiHost;
  readonly attribute ACString originCharset;
};

Esencialmente URI son nombres estructurados para... cualquier cosa. Este interfaz ofrece métodos para crear y cuestionar los componentes básicos de un URI. Las sub clases, incluida ofrecen mayor estructura a los URI. Esta interfaz sigue las especificaciones Berners-Lee en RFC 2396, donde se definen las URI básicas como:

ftp://user:[email protected]:12345/path/leaf

Componente	Valore en el ejemplo
`scheme`	`ftp`
`userPass`	`user:password`
`host`	`example.org`
`port`	`12345`
`path`	`/path/leaf`
`prePath`	`ftp://user:[email protected]:12345`

Métodos

equals()

boolean equals (in nsIURI other);

Compara la URI actual con otra, retornando true si las dos representan el mismo sitio.

Nota: Es más que un comparación de cadena, ya que dos cadenas URI distintas pueden representar el mismo sitio. P.e.: Esta comparación devolverá true https://example.com:80/ == https://example.com/

schemeIs()

boolean schemeIs(in string scheme);

Una optimización para hacer chequeos de esquema sin pedir los usuarios de nsIURI a GetScheme, con esto se ahorran asignaciones y liberaciones extra de memoria. Retorna True si el esquema coincide (se ingnoran mayúsculas o minúsculas)

clone()

nsIURI clone();

Clona la URI, retornando un nuevo objeto nsIURI

Para algunos protocolos, esto es más que una simple optimización. Por ejemplo, en MacOS X, la especificación de una dirección de fichero no implica necesariamente la identificación exclusiva de un archivo, ya que dos volúmenes podrían tener el mismo nombre.

resolve()

AUTF8String resolve(in AUTF8String relativePath);

Este método resuelve una cadena uri relativa usando esta URI como base.

Nota: Algunas implementaciones puede que no tengan el concepto de URI relativo.

Attributes

Attribute	Type	Description
`spec`	`nsACString` (UTF-8)	Devuelve una representación de cadena de la URI. Configura las spec causada con la nueva spec para ser analizada, inicializa la URI.
`prePath`	`readonly nsACString` (UTF-8)	El prePath (eg. scheme://user:password@host:port) retorna la cadena de caracteres que se encuentran antes del path. Esto es útil para la autenticación o para el manejo de sesiones. Some characters may be escaped.
`scheme`	`nsACString (US-ASCII)`	El Esquema es el protocolo al cual la URI se refiere. El Esquema está restringido al conjunto de caracteres US-ASCII definido por el RFC2396.
`userPass`	`nsACString` (UTF-8)	La combinación nombre_de_usuario:contraseña (username:password) (o nombre_de_usuario sólo si el valor no contiene ':'). Some characters may be escaped.
`username`	`nsACString` (UTF-8)	The optional username, assuming the preHost consists of username:password. Some characters may be escaped.
`password`	`nsACString` (UTF-8)	The optional password, assuming the preHost consists of username:password. Some characters may be escaped.
`hostPort`	`nsACString` (UTF-8)	La combinación host:puerto (host:port) (o simplemente el host, si el puerto es -1). Characters are NOT escaped.
`host`	`nsACString` (UTF-8)	El host es el nombre de dominio de internet al cual se refiere la URI. Puede ser una dirección IPv4 o IPv6. Si es soportado puede ser un nombre de dominio internacionalizado no-ASCII. Characters are NOT escaped.
`port`	`PRInt32`	Si el valor del puerto es -1 esto corresponde con el puerto por defecto para el protocolo (ejm. -1 implica que se usa el puerto 80 para las URI http).
`path`	`nsACString` (UTF-8)	The path, typically including at least a leading '/' (but may also be empty, depending on the protocol). Some characters may be escaped.
`asciiSpec`	`readonly nsACString` (US-ASCII)	The URI spec with an ASCII compatible encoding. Host portion follows the IDNA draft spec. Other parts are URL-escaped per the rules of RFC2396. The result is strictly ASCII.
`asciiHost`	`readonly nsACString` (US-ASCII)	The URI host with an ASCII compatible encoding. Follows the IDNA draft spec for converting internationalized domain names (UTF-8) to ASCII for compatibility with existing internet infrasture.
`originCharset`	`readonly nsACString`	The charset of the document from which this URI originated. An empty value implies UTF-8. If this value is something other than UTF-8 then the URI components (e.g., spec, prePath, username, etc.) will all be fully URL-escaped. Otherwise, the URI components may contain unescaped multibyte UTF-8 characters.