| Paquete | Nivel superior |
| Clase | public final class Namespace |
| Herencia | Namespace  Object |
| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9, Flash Lite 4 |
- Espacios de nombres de objetos XML Los espacios de nombre se asocian a un prefijo de espacio de nombres con un identificador de recurso uniforme (URI) que identifica el espacio de nombres. El prefijo es una cadena empleada para hacer referencia al espacio de nombres dentro de un objeto XML. Si el prefijo no está definido, se genera un prefijo automáticamente cuando el XML se convierte en una cadena.
- Espacio de nombres para diferenciar métodos Los espacios de nombres permiten diferenciar métodos con el mismo nombre para realizar tareas diferentes. Si dos métodos tienen el mismo nombre pero espacios de nombres diferentes, podrán realizar tareas distintas.
- Espacios de nombres para control de acceso Los espacios de nombres pueden utilizarse para controlar el acceso a un grupo de propiedades y métodos de una clase. Si sitúa las propiedades y los métodos en un espacio de nombres privado, éstos resultarán inaccesibles para cualquier código que no tenga acceso a dicho espacio de nombres. Puede conceder acceso al grupo de propiedades y métodos pasando el espacio de nombres a otras clases, métodos o funciones.
Esta clase muestra dos formas del método constructor porque cada forma acepta parámetros diferentes.
Esta clase (junto con las clases XML, XMLList y QName) implementa potentes normas de gestión de XML definidas en la especificación ECMAScript para XML (E4X) (ECMA-357 edición 2).
Más información
Elementos de API relacionados
Propiedades públicas
Ocultar propiedades públicas heredadas
Mostrar propiedades públicas heredadas| Propiedad | Definido por | ||
|---|---|---|---|
 | constructor : Object
Una referencia a la clase de objeto o función constructora para una instancia de objeto determinada. | Object | |
| prefix : String
El prefijo del espacio de nombres. | Namespace | ||
| uri : String
Identificador uniforme de recurso (URI) del espacio de nombres. | Namespace | ||
Métodos públicos
| Método | Definido por | ||
|---|---|---|---|
Crea un objeto Namespace conforme a los valores de los parámetros prefixValue y uriValue. | Namespace | ||
Crea un objeto Namespace. | Namespace | ||
|
Indica si un objeto tiene definida una propiedad especificada. | Object | |
|
Indica si hay una instancia de la clase Object en la cadena de prototipo del objeto especificado como parámetro. | Object | |
|
Indica si existe la propiedad especificada y si es enumerable. | Object | |
|
Establece la disponibilidad de una propiedad dinámica para operaciones de bucle. | Object | |
|
Devuelve la representación de cadena de este objeto, con formato según las convenciones específicas de configuración regional. | Object | |
Equivalente a la propiedad Namespace.uri. | Namespace | ||
Devuelve el valor URI del objeto especificado. | Namespace | ||
Información sobre propiedades
prefix | propiedad |
uri | propiedad |
Información sobre constructores
Namespace | () | Información sobre |
public function Namespace(prefixValue:*, uriValue:*)| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9 |
Crea un objeto Namespace conforme a los valores de los parámetros prefixValue y uriValue. Este constructor requiere ambos parámetros.
El valor del parámetro prefixValue se asigna a la propiedad prefix de la siguiente forma:
- Si se pasa
undefined,prefixse define comoundefined. - Si el valor es un nombre XML válido, conforme a lo que determine la función
isXMLName(), se convertirá en una cadena y se asignará a la propiedadprefix. - Si el valor no es un nombre XML válido, la propiedad
prefixse define comoundefined.
El valor del parámetro uriValue se asigna a la propiedad uri de la siguiente forma:
- Si se pasa un objeto QName, la propiedad
urise establece con el valor de la propiedaduridel objeto QName. - En caso contrario, el parámetro
uriValuese convierte en una cadena y se asigna a la propiedaduri.
Nota: esta clase muestra dos entradas de método constructor porque cada forma acepta parámetros diferentes. El constructor se comporta de forma diferente dependiendo del tipo y el número de argumentos pasados, como se detalla en cada entrada. ActionScript 3.0 no admite la sobrecarga de métodos o constructores.
ParámetrosprefixValue:* — El prefijo que debe utilizarse para el espacio de nombres.
| |
uriValue:* — Identificador uniforme de recurso (URI) del espacio de nombres.
|
Namespace | () | Información sobre |
public function Namespace(uriValue:*)| Versión del lenguaje: | ActionScript 3.0 |
| Versiones de motor de ejecución: | AIR 1.0, Flash Player 9 |
Crea un objeto Namespace. Los valores asignados a las propiedades uri y prefix del nuevo objeto Namespace dependen del tipo de valor pasado al parámetro uriValue:
- Si no se pasa ningún valor, las propiedades
prefixyurise definen con una cadena vacía. - Si el valor es un objeto Namespace, se creará una copia del objeto.
- Si el valor es un objeto QName, la propiedad
urise establece con la propiedaduridel objeto QName.
Nota: esta clase muestra dos entradas de constructor porque cada forma acepta parámetros diferentes. El constructor se comporta de forma diferente dependiendo del tipo y el número de parámetros pasados, como se detalla en cada entrada. ActionScript 3.0 no admite la sobrecarga de métodos o constructores.
ParámetrosuriValue:* — Identificador uniforme de recurso (URI) del espacio de nombres.
|
Información sobre métodos
toString | () | método |
valueOf | () | método |
Ejemplos Cómo utilizar este ejemplo
NamespaceExample.as
El siguiente ejemplo ilustra cómo trabajar con espacios de nombres definidos en objetos XML. Esto se consigue con los pasos siguientes:
- El ejemplo define tres objetos Namespace, cada uno con un URI exclusivo que define un espacio de nombres.
- El ejemplo define una variable XML llamada
myXMLy la asigna al valor devuelto porgetRSS(). El métodogetRSS()define un objeto XML que contiene diversos espacios de nombres y devuelve el objeto XML. - El ejemplo declara y evalúa una variable Array mediante la llamada al método
parseRSS()conmyXMLtransferido. EnparseRSS(), el espacio de nombres XML predeterminado se define comorssy el ejemplo define una variable XMLList mediante la asignación de la lista de objetositemdemyXML. Se crea un conjunto y se llena con varios nodos demyXML.item. Después se devuelve el conjunto. - Los elementos del conjunto se imprimen con un bucle
fory tres llamadas atrace().
package {
import flash.display.Sprite;
public class NamespaceExample extends Sprite {
private var rss:Namespace = new Namespace("http://purl.org/rss/1.0/");
private var rdf:Namespace = new Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
private var dc:Namespace = new Namespace("http://purl.org/dc/elements/1.1/");
public function NamespaceExample() {
var myXML:XML = getRSS();
var rssItems:Array = parseRSS(myXML);
var len:uint = rssItems.length;
for (var i:uint; i < len; i++) {
trace(rssItems[i].title);
trace(rssItems[i].creator);
trace(rssItems[i].date);
// Adobe Flash Developer Center
// Adobe
// 2005-08-08
// Flex Developer Center
// Adobe
// 2005-10-16
}
}
private function parseRSS(rssXML:XML):Array {
default xml namespace = rss;
var items:XMLList = rssXML.item;
var arr:Array = new Array();
var len:uint = items.length();
for (var i:uint; i < len; i++) {
arr.push({title:items[i].title, creator:items[i].dc::creator, date:items[i].dc::date});
}
return arr;
}
private function getRSS():XML {
var myXML:XML = <rdf:RDF
xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#"
xmlns="http://purl.org/rss/1.0/"
xmlns:dc="http://purl.org/dc/elements/1.1/"
>
<channel rdf:about="http://www.xml.com/cs/xml/query/q/19">
<title>Test RSS</title>
<link>http://www.adobe.com/</link>
<description>This is a test RSS document.</description>
<language>en-us</language>
<items>
<rdf:Seq>
<rdf:li rdf:resource="http://www.adobe.com/devnet/flash/"/>
<rdf:li rdf:resource="http://www.adobe.com/devnet/flex/"/>
</rdf:Seq>
</items>
</channel>
<item rdf:about="http://www.adobe.com/devnet/flash/">
<title>Adobe Flash Developer Center</title>
<link>http://www.adobe.com/devnet/flash/</link>
<description>Welcome to the Flash Developer Center</description>
<dc:creator>Adobe</dc:creator>
<dc:date>2005-08-08</dc:date>
</item>
<item rdf:about="http://www.adobe.com/devnet/flex/">
<title>Flex Developer Center</title>
<link>http://www.adobe.com/devnet/flex/</link>
<description>Welcome to the Flex Developer Center</description>
<dc:creator>Adobe</dc:creator>
<dc:date>2005-10-16</dc:date>
</item>
</rdf:RDF>;
return myXML;
}
}
}
Namespace_2_Example.as
El siguiente ejemplo ilustra cómo se pueden utilizar los espacios de nombres para distinguir métodos que tienen el mismo nombre pero realizan tareas distintas. En este ejemplo, tres métodos llamados
hello() residen en espacios de nombres independientes; cada uno devuelve una cadena distinta cuando se le llama.
package {
import flash.display.Sprite;
public class Namespace_2_Example extends Sprite {
public function Namespace_2_Example() {
var vocab:MultilingualVocabulary = new MultilingualVocabulary();
trace(vocab.hello()); // hello
var languages:Array = vocab.getLanguages();
for (var i:uint; i < languages.length; i++) {
var ns:Namespace = languages[i];
if (ns != null) {
trace(ns.toString() + ": " + vocab.ns::hello());
// hello
// MultilingualVocabulary:Hawaiian: aloha
// MultilingualVocabulary:French: bon jour
}
}
}
}
}
class MultilingualVocabulary {
public namespace French;
public namespace Hawaiian;
private var languages:Array;
public function MultilingualVocabulary() {
languages = new Array(Hawaiian, French);
}
public function hello():String {
return "hello";
}
Hawaiian function hello():String {
return "aloha";
}
French function hello():String {
return "bon jour";
}
public function getLanguages():Array {
return languages;
}
}
Namespace_3_Example.as
El siguiente ejemplo utiliza nombres de espacios de nombres para seleccionar un valor de variable adecuado. Muestra cómo guardar un valor de espacio de nombres en una variable y utilizar dicha variable para referirse a los objetos contenidos en el espacio de nombres.
El ejemplo define espacios de nombres y colores que se corresponden con los estados de ratón de un botón rectangular. Cada vez que se dibuja el botón, el ejemplo aplica el color adecuado (out es rojo; over es amarillo; down es blanco) haciendo referencia a la variable bgcolor del espacio de nombres correspondiente (out, over, down).
package {
import flash.display.Sprite;
public class Namespace_3_Example extends Sprite {
public function Namespace_3_Example() {
addChild(new StateButton("Press Me."));
}
}
}
import flash.display.Sprite;
import flash.text.TextField;
import flash.events.Event;
import flash.events.MouseEvent;
class StateButton extends Sprite{
private namespace out;
private namespace over;
private namespace down;
private var label:TextField;
private var labelTxt:String;
private var ns:Namespace;
out var bgColor:Number = 0xFF0000;
over var bgColor:Number = 0xFFFF00;
down var bgColor:Number = 0xFFFFFF;
public function StateButton(str:String) {
buttonMode = true;
labelTxt = str;
ns = out;
draw();
addLabel();
addListeners();
}
private function addLabel():void {
label = new TextField();
label.text = labelTxt;
label.width = 50;
label.height = 20;
label.mouseEnabled = false;
addChild(label);
}
private function addListeners():void {
addEventListener(MouseEvent.MOUSE_UP, mouseOverHandler);
addEventListener(MouseEvent.MOUSE_OUT, mouseOutHandler);
addEventListener(MouseEvent.MOUSE_OVER, mouseOverHandler);
addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
}
private function mouseOutHandler(e:Event):void {
ns = out;
draw();
}
private function mouseOverHandler(e:Event):void {
ns = over;
draw();
}
private function mouseDownHandler(e:Event):void {
ns = down;
draw();
}
private function draw():void {
this.graphics.clear();
this.graphics.beginFill(ns::bgColor);
this.graphics.drawRect(0, 0, 60, 20);
}
}
Tue Jun 12 2018, 02:12 PM Z