• Author / Uploaded
• Hiram Alberto Bustos Rojas

• Categories
• Poco
• Entero
• Teoría de la computación
• Datos de computadora
• Matemáticas discretas

Citation preview

Los operadores simbólicos son caracteres que especifican cómo combinar, comparar o modificar los valores de una expresión.

Aritmético +

suma

Suma expresiones numéricas.

--

decremento

Resta 1 del operando.

/

división

Divide expression1 entre expression2.

++

incremento

Suma 1 a una expresión.

%

módulo

Calcula el resto de expression1 dividido entre expression2.

*

multiplicación

Multiplica dos expresiones numéricas.

-

resta

Se emplea para negar o restar. Asignación de compuesto aritmético

+=

asignación de suma

Asigna a expression1 el valor de expression1 + expression2.

/=

asignación de división

Asigna a expression1 el valor de expression1 / expression2.

%=

asignación de módulo

Asigna a expression1 el valor de expression1 % expression2.

*=

asignación de multiplicación

Asigna a expression1 el valor de expression1 * expression2.

-=

asignación de resta

Asigna a expression1 el valor de expression1 expression2. Asignación

=

asignación

Asigna el valor de expression2 (el operando de la derecha) a la variable, elemento de matriz o propiedad de expression1. Modo bit

&

AND en modo bit

Convierte expression1 y expression2 en enteros de 32 bits sin signo, y ejecuta una operación Boolean AND en cada bit de los parámetros integer.

>

desplazamiento a la derecha en modo bit

Convierte expression y shiftCount en enteros de 32 bits y desplaza todos los bits de expression a la derecha el número de posiciones especificado por el entero resultante de la conversión de shiftCount.

Es igual al operador de desplazamiento a la derecha en desplazamiento a la modo bit (>>), con la diferencia de que no conserva el >>> derecha en modo bit sin signo de la expresión original porque los bits a la signo izquierda se rellenan siempre con 0. ^

Convierte expression1 y expression2 en enteros de 32 bits sin signo y coloca un 1 en cada posición de bit donde los correspondientes bits de expression1 o expression2, pero no ambas, sean 1.

XOR en modo bit

Asignación de compuesto en modo bit &=

asignación AND en modo bit

asignación y >= derecha en modo bit sin expression. signo ^=

asignación XOR en modo bit

Asigna a expression1 el valor de expression1 ^ expression2. Comentario

/*..*/

delimitador de comentario en bloque

Delimita una o varias líneas de comentarios de script.

//

delimitador de comentario de línea

Indica el principio de un comentario de script. Comparación

==

igualdad

Comprueba la igualdad de dos expresiones.

>

mayor que

Compara dos expresiones y determina si expression1 es

mayor que expression2; si lo es, el resultado es true. >=

mayor que o igual a

Compara dos expresiones y determina si expression1 es mayor o igual a expression2 (true) o expression1 es menor que expression2 (false).

!=

desigualdad

Prueba el contrario exacto del operador de igualdad (==).


200) || (start)) { trace("the logical OR test passed"); // the logical OR test passed }

El mensaje "the logical OR test passed" aparece porque una de las condiciones de la sentencia if se cumple (b > 200) El ejemplo siguiente demuestra cómo el uso de una llamada de función como segundo operando puede producir resultados imprevistos. Si la expresión a la izquierda del operador da como resultado true, ese resultado se devolverá sin evaluar la expresión a la derecha (no se llamará a la función fx2() ). function fx1():Boolean { trace("fx1 called"); return true; }

function fx2():Boolean { trace("fx2 called"); return true; } if (fx1() || fx2()) { trace("IF statement entered"); }

Véase también == (igualdad) != (desigualdad) && (AND lógico) &&= (asignación AND lógico) ||= (asignación OR lógico) ! (NOT lógico) === (igualdad estricta) !== (desigualdad estricta) ||= asignación OR lógicooperador Uso expression1 ||= expression2

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Asigna a expression1 el valor de expression1 || expression2. Por ejemplo, las dos sentencias siguientes son equivalentes: x ||= y; x = x || y;

Operandos expression1:* — Valor de cualquier tipo. expression2:* — Valor de cualquier tipo.

Resultado * — Un valor Boolean si ambos operandos son miembros del tipo de datos Boolean. En caso contrario, el resultado será el valor de cada expresión. Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente asigna un valor predeterminado a una variable declarada anteriormente llamada myVar. Esta técnica aprovecha la ventaja del hecho de que el operador lógico OR (||) devuelve el valor de expression1 si expression1 da como resultado true ; de lo contrario, devuelve el valor de expression2. Si myVar ya contiene un valor que da como resultado true, myVar permanece inalterable. Sin embargo, si myVar contiene un valor que da como resultado false, como los valores null, "" (cadena vacía) y undefined, entre otros, a myVar se le asigna el valor "default". myVar ||= "default";

Véase también

== (igualdad) != (desigualdad) || (OR lógico) && (AND lógico) &&= (asignación AND lógico) ! (NOT lógico) === (igualdad estricta) !== (desigualdad estricta) % módulooperador Uso expression1 % expression2

Versión del lenguaje: ActionScript 3.0 Versión del reproductor : Flash Player 9 Calcula el resto de expression1 dividido entre expression2. Si uno de los operandos es no numérico, el operador de módulo (%) intenta convertirlo en un número. El signo del resultado del módulo coincide con el signo del dividendo (el primer número). Por ejemplo, -4 % 3 y -4 % -3, ambos dan como resultado -1. Operandos expression1:Number — Número o expresión que da como resultado un número. Una

cadena que sólo contiene caracteres numéricos da como resultado un número. expression2:Number — Número o expresión que da como resultado un número. Una cadena que sólo contiene caracteres numéricos da como resultado un número. Resultado Number — El resultado de la operación aritmética. Ejemplo Cómo utilizar los ejemplos El siguiente ejemplo numérico utiliza el operador de módulo (%): trace(12 % 5); // 2 trace(4.3 % 2.1); // 0.0999999999999996 trace(4 % 4); // 0

El primer trace devuelve 2, en lugar de 12/5 o 2,4, porque el operador de módulo (%) sólo devuelve el resto. El segundo trace devuelve 0,0999999999999996 en lugar del previsto 0,1 debido a las limitaciones en la precisión de coma flotante del cálculo binario. Véase también / (división) Math.round() Operadores %= asignación de módulooperador Uso expression1 %= expression2

Versión del lenguaje: ActionScript 3.0

Versión del reproductor: Flash Player 9 Asigna a expression1 el valor de expression1 % expression2. Las dos sentencias siguientes son equivalentes: x %= y; x = x % y;

Operandos expression1:Number — Número o expresión que da como resultado un número. expression2:Number — Número o expresión que da como resultado un número.

Resultado Number — El resultado de la operación aritmética.

Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente asigna el valor 4 a la variable a: var a:Number = 14; var b:Number = 5; a %= b; trace(a); // 4

Véase también % (módulo) * multiplicaciónoperador Uso expression1 * expression2

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Multiplica dos expresiones numéricas. Si ambas expresiones son enteros, el producto es un entero. Si una o ambas expresiones son números de coma flotante, el producto es un número de coma flotante. Operandos expression1:Number — Número o expresión que da como resultado un número. expression2:Number — Número o expresión que da como resultado un número.

Resultado Number — Entero o número de coma flotante.

Ejemplo Cómo utilizar los ejemplos La sentencia siguiente multiplica los enteros 2 y 3 y da como resultado el entero 6: trace(2*3); // 6

Esta sentencia multiplica los números de coma flotante 2,0 y 3,1416 y da como resultado 6,2832, que es un número de coma flotante: trace(2.0 * 3.1416); // 6.2832

Véase también Operadores *= asignación de multiplicaciónoperador Uso expression1 *= expression2

Versión del lenguaje: ActionScript 3.0 Versión del reproductor : Flash Player 9 Asigna a expression1 el valor de expression1 * expression2. Por ejemplo, las dos expresiones siguientes son equivalentes: x *= y x = x * y

Operandos expression1:Number — Número o expresión que da como resultado un número. expression2:Number — Número o expresión que da como resultado un número.

Resultado Number — El valor de expression1 * expression2. Si una expresión no puede convertirse en un valor numérico, devuelve NaN (no es un número).

Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente asigna el valor 50 a la variable a: var a:Number = 5; var b:Number = 10; trace(a *= b); // 50

La segunda y tercera líneas del ejemplo siguiente calculan las expresiones de la parte derecha del signo igual y asignan los resultados a c y d: var i:Number = var c:Number = var d:Number = trace(c *= d);

5; 4 - 6; i + 2; // -14

Véase también * (multiplicación) :: calificador de nombresoperador Uso namespace::property namespace::method() namespace::xmlObject.property namespace::xmlObject.@attribute

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Identifica el espacio de nombres de una propiedad, un método, una propiedad XML o un atributo XML.

Operandos namespace:Object — El espacio de nombres identificador. propertyName:Object — La propiedad, el método, la propiedad XML o el atributo XML

que se va a identificar. Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente utiliza el operador :: para identificar dos métodos que tienen el mismo nombre en dos espacios de nombre diferentes: public class NamespaceExample extends Sprite { public namespace French; public namespace Hawaiian; public function NamespaceExample() { trace(Hawaiian::hello()); // aloha trace(French::hello()); // bonjour } Hawaiian function hello():String { return "aloha"; } French function hello():String { return "bonjour"; } }

El ejemplo siguiente utiliza el operador :: para identificar propiedades XML con espacios de nombre específicos: var soap:Namespace = new Namespace("http://schemas.xmlsoap.org/wsdl/soap/"); var w:Namespace = new Namespace("http://weather.example.org/forecast"); var myXML:XML =

Quito Ecuador 2006-01-14

; trace(myXML.soap::Body.w::forecast.w::city); // Quito

Véase también Clase Namespace Clase XML newoperador Uso new constructor(parameters)

Versión del reproductor : Flash Player 5

Crea una instancia de clase. El operador new puede utilizarse con una clase o una variable de tipo Class para crear la instancia de una clase. El operador new suele utilizarse con un objeto de clase para crear la instancia de una clase. Por ejemplo, la sentencia new Sprite() crea una instancia de la clase Sprite. El operador new también puede utilizarse para asociar una clase con un activo incorporado, que es un objeto externo, como una imagen, un sonido o una fuente compilada en un archivo SWF. Cada activo incorporado se representa mediante una clase de activo incorporado. Para obtener acceso a un activo incorporado, debe utilizar el operador new para crear una instancia de su clase asociada. Posteriormente, puede llamar a los métodos y las propiedades adecuados de la clase del activo incorporado para manipularlo. Si prefiere definir clases con objetos Function en lugar de la palabra clave class, puede utilizar el operador new para crear objetos basados en funciones constructoras. No debe confundir las funciones constructoras con los métodos constructores de una clase. Una función constructora es un objeto Function que se define con la palabra clave function, pero que no forma parte de una definición de clase. Si utiliza funciones constructoras para crear objetos, deberá utilizar la herencia de prototipo en lugar de la herencia de clase. Operandos constructor:* — Clase, función o variable que contiene un valor de tipo Class. parameters:* — Uno o varios parámetros separados por comas.

Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente crea la clase Book y utiliza el operador new para crear los objetos book1 y book2. class Book { var bName:String; var bPrice:Number; public function Book(nameParam:String, priceParam:Number){ bName = nameParam; bPrice = priceParam; } } var book1:Book = new Book("Confederacy of Dunces", 19.95); var book2:Book = new Book("The Floating Opera", 10.95); trace(book1); // [object Book] El ejemplo siguiente utiliza el operador new para crear una instancia de la clase Array con

18 elementos: var golfCourse:Array = new Array(18);

Véase también [] (acceso a matriz) Sentencia class Object.constructor

Object.prototype {} (inicializador de objeto) Métodos Temas avanzados {} inicializador de objetooperador Uso object = {name1 : value1, name2 : value2,... nameN : valueN}

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Crea un nuevo objeto y lo inicializa con los pares de propiedades name y value. Utilizar este operador equivale a usar la nueva sintaxis de new Object y llenar los pares de propiedades con el operador de asignación. El prototipo del objeto recién creado se denomina de forma genérica el objeto Object. Este operador se utiliza además para marcar bloques de código contiguo asociado con sentencias de control de flujo (for, while, if, else, switch) y funciones. Operandos object:Object — El objeto que se va a crear. name1,2,...N:Object — Los nombres de las propiedades. value1,2,...N:Object — Los valores correspondientes para cada una de las propiedades name.

Resultado Object — Un objeto Object.

Ejemplo Cómo utilizar los ejemplos La primera línea del código siguiente crea un objeto vacío utilizando el operador de inicializador de objeto ({}); la segunda línea crea un objeto nuevo empleando una función constructora: var object:Object = {}; var object:Object = new Object(); El siguiente ejemplo crea una account de objeto e inicializa las propiedades name, address, city, state, zip y balance con los valores correspondientes: var account:Object = {name:"Adobe Systems, Inc.", address:"601 Townsend Street", city:"San Francisco", state:"California", zip:"94103", balance:"1000"}; for (i in account) { trace("account."+i+" = "+account[i]); }

El ejemplo siguiente muestra cómo pueden anidarse los inicializadores de objeto y matriz entre sí: var person:Object = {name:"Gina Vechio", children:["Ruby", "Chickie", "Puppa"]};

El siguiente código utiliza la información del ejemplo anterior y produce el mismo resultado utilizando una función constructora: var person:Object = new Object(); person.name = "Gina Vechio";

person.children = new Array(); person.children[0] = "Ruby"; person.children[1] = "Chickie"; person.children[2] = "Puppa";

Véase también llaves (XML) Clase Object () paréntesisoperador Uso (expression1[, expression2]) (expression1, expression2) function(parameter1,..., parameterN)

Versión del lenguaje: ActionScript 3.0 Versión del reproductor : Flash Player 9 Ejecuta una operación de agrupación en uno o varios parámetros, lleva a cabo una evaluación secuencial de las expresiones o rodea uno o varios parámetros y los pasa como argumentos a una función que precede al paréntesis. Sintaxis 1: controla el orden de ejecución de los operadores. Los paréntesis sustituyen el orden de precedencia normal y pueden hacer que las expresiones entre paréntesis se evalúen primero. Cuando se anidan los paréntesis, el contenido de los paréntesis más interiores se evalúa antes que el contenido de los más exteriores. Sintaxis 2: da como resultado una serie de expresiones, separadas por comas, en una secuencia y devuelve el resultado de la expresión final. Sintaxis 3: rodea uno o varios parámetros y los pasa a la función que precede al paréntesis. Operandos expression1:Object — Expresión que puede incluir números, cadenas, variables o texto. expression2:Object — Expresión que puede incluir números, cadenas, variables o texto. function:Function — Función que se ejecutará sobre el contenido del paréntesis. parameter1...parameterN:Object — Una serie de parámetros que se ejecutará antes de

que se pasen los resultados como argumentos a la función que está fuera del paréntesis. Ejemplo Cómo utilizar los ejemplos Sintaxis 1: las sentencias siguientes muestran el uso de los paréntesis para controlar el orden de ejecución de las expresiones: trace((2 + 3) * (4 + 5)); trace(2 + (3 * (4 + 5))); trace(2 + (3 * 4) + 5); trace(2 + (3 * 4) + 5);

// // // //

45 29 19 19

Sintaxis 2: el ejemplo siguiente evalúa la función foo(), a continuación, la funciónbar() y devuelve el resultado de la expresión a + b:

var a:Number = 1; var b:Number = 2; function foo() { a += b; } function bar() { b *= 10; } trace((foo(), bar(), a + b)); // 23

Sintaxis 3: el ejemplo siguiente muestra el uso de paréntesis con funciones: var today:Date = new Date(); trace(today.getFullYear()); // outputs current year function traceParameter(param):void { trace(param); } traceParameter(2 * 2); // 4

Véase también paréntesis (XML) with Operadores ( ) paréntesis (XML)operador Uso myXML.(expression)

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Evalúa una expresión en una construcción XML ECMAScript para XML (E4X). Por ejemplo, myXML.(lastName == "Smith") identifica elementos XML con el nombre lastName y el valor "Smith". El resultado es un objeto XMLList. Operandos myXML:* — Un objeto XML o XMLList. expression:* — Expresión que define los elementos coincidentes. Resultado XMLList — El valor XMLList especificado con los paréntesis. Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente muestra cómo se utilizan los paréntesis para identificar elementos y atributos: var myXML:XML =

Joe Smith

Susan Jones



Anne Smith

; trace(myXML.employee.(lastName == "Smith")[email protected]()); // 42 // 44 trace(myXML.employee.(Number(@id) > 42)[email protected]()); // 43 // 44

Véase también Clase XML Clase XMLList / delimitador RegExpoperador Uso /pattern/flags

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Si se utiliza antes y después de caracteres, indica que los caracteres tienen un valor literal y se consideran una expresión regular (RegExp), no una variable, una cadena u otro elemento de ActionScript. Tenga en cuenta, no obstante, que dos caracteres de barra diagonal seguidos (//) indican el comienzo de un comentario. Operandos pattern:String — Secuencia de uno o varios caracteres que definen el patrón de la

expresión regular. flags:String — Una secuencia de cero o más de los siguientes caracteres: g (para el indicador global ), i (para el indicador ignoreCase ), s (para el indicador dotall ), x (para el indicador extended ). Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente utiliza caracteres de barra diagonal (/) para establecer el valor de una variable de tipo RegExp (se define el indicador i para omitir la distinción entre mayúsculas y minúsculas al establecer correspondencias): var myRegExp:RegExp = /foo-\d+/i; trace(myRegExp.exec("ABC Foo-32 def.")); // Foo-32

Véase también Clase RegExp === igualdad estrictaoperador

Uso expression1 === expression2

Versión del lenguaje: ActionScript 3.0 Versión del reproductor : Flash Player 9 Comprueba la igualdad de dos expresiones, pero no realiza la conversión automática de los datos. El resultado es true si ambas expresiones, incluidos sus tipos de datos, son iguales. El operador de igualdad estricta (===) es igual que el operador de igualdad (==) en tres aspectos:   

Los valores numéricos y Boolean se comparan por su valor y se consideran iguales si tienen el mismo valor. Las expresiones String son iguales si tienen el mismo número de caracteres y éstos son idénticos. Las variables que representan objetos, matrices y funciones se comparan por su referencia. Dos de estas variables son iguales si hacen referencia al mismo objeto, matriz o función. Dos matrices independientes nunca se consideran iguales, aunque tengan el mismo número de elementos.

El operador de igualdad estricta (===) difiere del operador de igualdad (==) sólo en dos aspectos: 



El operador de igualdad estricta sólo realiza la conversión automática de datos para los tipos numéricos Number, int y uint, mientras que el operador de igualdad realiza la conversión automática de datos para todos los tipos de datos simples. Al comparar null y undefined, el operador de igualdad estricta devuelve false.

El operador de igualdad estricta genera resultados diferentes en ActionScript 3.0 en comparación con ActionScript 2.0 en dos situaciones que implican datos simples (por ejemplo, var x:Number = 1) con objetos simples (por ejemplo, var x:Number = new Number(1)). Ello se debe a que ActionScript 3.0 elimina la distinción entre valores simples y objetos envolventes simples. En primer lugar, las comparaciones entre valores simples y objetos simples que contienen el mismo valor devuelven true en ActionScript 3.0, mientras que en versiones anteriores devuelven false. En versiones anteriores, el tipo de datos de un valor simple es Boolean, Number o String, mientras que el tipo de datos de un objeto simple es siempre Object y no Boolean, Number o String. Esta diferencia, a efectos prácticos, origina que el siguiente código devuelva false en la versiones anteriores de ActionScript porque los tipos de datos de los operandos no coinciden, mientras que el resultado es true en ActionScript 3.0 debido a que el tipo de datos de los valores simples es Boolean, Number, int, uint o String, independientemente de si están o no dentro de un objeto envolvente. var num1:Number = 1; var num2:Number = new Number(1);

trace(num1 === num2); // true in ActionScript 3.0, false in ActionScript 2.0

En segundo lugar, las comparaciones entre dos objetos simples que contienen el mismo valor devuelven true en ActionScript 3.0, mientras que en versiones anteriores devuelven false. var num1:Number = new var num2:Number = new trace(num1 == num2); 2.0 trace(num1 === num2); 2.0

Number(1); Number(1); // true in ActionScript 3.0, false in ActionScript // true in ActionScript 3.0, false in ActionScript

Ello se debe a que, en versiones anteriores de ActionScript, ambas variables pertenecen al tipo de datos Object, por lo que se comparan por referencia y el resultado es false tanto para la operación de igualdad como para la operación de igualdad estricta. Sin embargo, en ActionScript 3.0, ambas variables pertenecen al tipo de datos Number, por lo que se comparan por valor y el resultado es true, tanto para el operador de igualdad como para el operador de igualdad estricta. Operandos expression1:Object — Un número, cadena, valor Boolean, variable, objeto, matriz o función. expression2:Object — Un número, cadena, valor Boolean, variable, objeto, matriz o función. Resultado Boolean — El resultado Boolean de la comparación. Ejemplo Cómo utilizar los ejemplos El siguiente ejemplo muestra que la igualdad estricta (===) es lo mismo que la igualdad (==) cuando coinciden el valor y los tipos de datos: var string1:String = "5"; var string2:String = "5"; trace(string1 == string2); // true trace(string1 === string2); // true

El siguiente ejemplo muestra que el operador de igualdad estricta no convierte el tipo de datos String a Number, mientras que el operador de igualdad == sí lo hace: // The equality (==) operator converts 5 to "5", but the strict equality operator does not var string1:String = "5"; var num:Number = 5; trace(string1 == num); // true trace(string1 === num); // false

El siguiente ejemplo muestra que el operador de igualdad estricta no convierte valores Boolean a números, mientras que el operador de igualdad sí lo hace: var num:Number = 1; var bool:Boolean = true; trace(num == bool); // true trace(num === bool); // false

El siguiente ejemplo muestra que el operador de igualdad estricta convierte los tipos de datos int y uint var num1:Number = 1;

var num2:int = 1; var num3:uint = 1; trace(num1 === num2); // true trace(num1 === num3); // true

El siguiente ejemplo muestra que el operador de igualdad estricta considera null yundefined como diferentes, mientras que el operador de igualdad los considera iguales: trace(null == undefined); // true trace(null === undefined); // false

Véase también == (igualdad) != (desigualdad) && (AND lógico) ! (NOT lógico) || (OR lógico) !== (desigualdad estricta) !== desigualdad estrictaoperador Uso expression1 !== expression2

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Prueba el contrario exacto del operador de igualdad estricta (===). El operador de desigualdad estricta realiza lo mismo que el operador de desigualdad, con la diferencia de que sólo se convierten los tipos de datos int y uint. Si expression1 es igual a expression2 y sus tipos de datos son iguales, el resultado es false. El operador de desigualdad estricta (!==) es igual que el operador de desigualdad (!=) en tres aspectos:   

Los valores numéricos y Boolean se comparan por su valor y se consideran iguales si tienen el mismo valor. Las expresiones String son iguales si tienen el mismo número de caracteres y éstos son idénticos. Las variables que representan objetos, matrices y funciones se comparan por su referencia. Dos de estas variables son iguales si hacen referencia al mismo objeto, matriz o función. Dos matrices independientes nunca se consideran iguales, aunque tengan el mismo número de elementos.

El operador de desigualdad estricta difiere del operador de desigualdad (!=) sólo en dos aspectos: 

El operador de desigualdad estricta (!==) sólo realiza la conversión automática de datos para los tipos numéricos (Number, int y uint, mientras que el operador de



desigualdad (!=) realiza la conversión automática de datos para todos los tipos de datos simples. Al comparar null y undefined, el operador de desigualdad estricta (!==) devuelve true.

Operandos expression1:Object — Un número, cadena, valor Boolean, variable, objeto, matriz o

función. expression2:Object — Un número, cadena, valor Boolean, variable, objeto, matriz o

función. Resultado Boolean — El resultado Boolean de la comparación.

Ejemplo Cómo utilizar los ejemplos Los comentarios del código siguiente muestran el valor devuelto de operaciones que utilizan los operadores de igualdad (==), de igualdad estricta (===) y de desigualdad estricta !==: var s1:String = "5"; var s2:String = "5"; var s3:String = "Hello"; var n:Number = 5; var b:Boolean = true; trace(s1 == s2); // true trace(s1 == s3); // false trace(s1 == n); // true trace(s1 == b); // false trace(s1 === s2); // true trace(s1 === s3); // false trace(s1 === n); // false trace(s1 === b); // false trace(s1 !== s2); // false trace(s1 !== s3); // true trace(s1 !== n); // true trace(s1 !== b); // true

Véase también == (igualdad) != (desigualdad) && (AND lógico) ! (NOT lógico) || (OR lógico) === (igualdad estricta) " delimitador de cadenaoperador Uso "text"

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9

Si se utiliza antes y después de caracteres, indica que los caracteres tienen un valor literal y se consideran una cadena y no una variable, un valor numérico u otro elemento de ActionScript. Operandos text:String — Secuencia de cero o más caracteres.

Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente utiliza comillas (") para indicar que el valor de la variable yourGuess es la cadena literal "Prince Edward Island" y no el nombre de una variable. var yourGuess:String = "Prince Edward Island"; submit_btn.onRelease = function() { trace(yourGuess); }; // Prince Edward Island

Véase también Clase String Función String() - restaoperador Uso -expression expression1 - expression2

Versión del reproductor: Flash Player 9 Se emplea para negar o restar. Sintaxis 1: si se utiliza para negar, el operador invierte el signo de una expresión numérica. Sintaxis 2: si se utiliza para restar, el operador ejecuta una resta aritmética en dos expresiones numéricas, restando expression2 de expression1. Si ambas expresiones son enteros, la diferencia es un entero. Si una o ambas expresiones son números de coma flotante, la diferencia es un número de coma flotante. Operandos expression1:Number — Número o expresión que da como resultado un número. expression2:Number — Número o expresión que da como resultado un número.

Resultado Number — Entero o número de coma flotante.

Ejemplo Cómo utilizar los ejemplos Sintaxis 1: la sentencia siguiente invierte el signo de la expresión 2 + 3: trace(-(2 + 3)); // -5

Sintaxis 2: la sentencia siguiente resta el entero 2 del entero 5: trace(5 - 2); // 3

El resultado, 3, es un entero.

La sentencia siguiente resta el número de coma flotante 1,5 del número de coma flotante 3,25: trace(3.25 - 1.5); // 1.75

El resultado, 1.75, es un número de coma flotante. Véase también Operadores -= asignación de restaoperador Uso expression1 -= expression2

Versión del lenguaje: ActionScript 3.0 Versión del reproductor : Flash Player 9 Asigna a expression1 el valor de expression1 - expression2. Por ejemplo, las dos sentencias siguientes son equivalentes: x -= y ; x = x - y;

Las expresiones de cadenas deben convertirse a números; en caso contrario, el resultado es NaN (que no es número). Operandos expression1:Number — Número o expresión que da como resultado un número. expression2:Number — Número o expresión que da como resultado un número.

Resultado Number — El resultado de la operación aritmética.

Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente utiliza el operador de asignación de resta (-=) para restar 10 de 5 y asigna el resultado a la variable x: var x:Number = 5; var y:Number = 10; x -= y; trace(x); // -5

El ejemplo siguiente muestra cómo se convierten las cadenas en números: var x:String = "5"; var y:String = "10"; x -= y; trace(x); // -5

Véase también - (resta) : typeoperador

Uso [modifiers] var variableName:type function functionName():type {... } function functionName(parameter1:type,..., parameterN:type) [:type]{... }

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Se utiliza para asignar un tipo de datos; este operador especifica el tipo de variable, el tipo de devolución de función o el tipo de parámetro de función. Cuando se utiliza en una asignación o declaración de variable, este operador especifica el tipo de la variable; cuando se utiliza en una declaración o definición de función, este operador especifica el tipo de devolución de la función; cuando se utiliza con un parámetro de función en una definición de función, este operador especifica el tipo de variable que se espera para dicho parámetro. La comprobación de tipos siempre tiene lugar en tiempo de ejecución. Sin embargo, cuando el compilador se establece en modo estricto, todos los tipos se comprueban durante la compilación y se generan errores cuando hay una discordancia. Pueden producirse discordancias durante las operaciones de asignación, llamadas a funciones y eliminación de referencias a miembros de clase con el operador de punto (.). Los tipos que pueden utilizarse son todos los tipos de objetos nativos, clases e interfaces definidas y void. Los tipos nativos reconocidos son Boolean, Number, int, uint y String. También se admiten como tipos nativos todas las clases incorporadas. Si no asigna un tipo de datos, se considerará que la variable, el valor de devolución de la función o el parámetro de la función no tienen tipo asignado, lo que significa que el valor puede tener cualquier tipo de datos. Si desea dejar claro que su intención es utilizar un valor sin tipo asignado, puede emplear el carácter de asterisco (*) para la anotación del tipo. Cuando se utiliza como anotación de tipo, el carácter de asterisco equivale a dejar una variable, un tipo de devolución de función o un parámetro de función sin tipo asignado. Operandos variableName:* — Identificador de una variable. type:* — Tipo de datos nativo, nombre de clase definido o nombre de interfaz. functionName:Function — Identificador de una función. parameter:* — Identificador de un parámetro de función.

Ejemplo Cómo utilizar los ejemplos Sintaxis 1: el ejemplo siguiente declara una variable pública llamada userName cuyo tipo es String y le asigna una cadena vacía: var userName:String = "";

Sintaxis 2: el ejemplo siguiente muestra cómo especificar el tipo de devolución de una función definiendo una función llamada randomInt() que especifica su tipo de devolución como int: function randomInt(integer:int):int { return Math.round(Math.random()*integer);

} trace(randomInt(8));

Sintaxis 3: el ejemplo siguiente define una función llamada squareRoot() que toma un parámetro llamado val de tipo Number y devuelve la raíz cuadrada de val, también de tipo Number : function squareRoot(val:Number):Number { return Math.sqrt(val); } trace(squareRoot(121));

Véase también Sentencia function Sentencia var Operadores typeofoperador Uso typeof expression

Versión del lenguaje: ActionScript 3.0 Versión del reproductor : Flash Player 9 Evalúa expression y devuelve una cadena que especifica el tipo de datos de la expresión. El resultado está limitado a seis valores de cadena posibles: boolean, function, number, object, string y xml. Si aplica este operador a una instancia de una clase definida por el usuario, el resultado será la cadena object. El operador typeof se incluye para lograr compatibilidad retroactiva. Utilice el operador is para comprobar la compatibilidad de tipos. Operandos expression:Object — Objeto que se va a evaluar.

Resultado String — Una representación de cadena del tipo de expression. La tabla siguiente muestra los resultados del operador typeof en cada tipo de expresión.

Tipo de expresión Array Boolean Function int Number Object String uint XML XMLList

Resultado object boolean function number number object string number xml xml

Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente muestra el resultado de utilizar typeof en diversos objetos y valores: trace(typeof Array); // object trace(typeof Date); // object trace(typeof 3); // number

El ejemplo siguiente muestra que, en ActionScript 3.0, el tipo de datos de un objeto simple es el mismo independientemente de si se asigna un valor literal o se utiliza el operador new para crear un objeto. Esto ha cambiado con respecto a versiones anteriores de ActionScript, en las que el operador typeof devuelve object para la variable b: var a:String var b:String trace(typeof trace(typeof

= "sample"; = new String("sample"); a); // string b); // string

Véase también as instanceof is voidoperador Uso void expression

Versión del reproductor: Flash Player 9 Evalúa una expresión y, a continuación, descarta su valor, devolviendo undefined. El operador void se emplea a menudo en comparaciones que utilizan el operador == para comprobar valores no definidos. Operandos expression:Object — Expresión que se va a evaluar. Resultado * — El valor de undefined.

Véase también Descripción de los tipos de datos < > delimitador de etiqueta de literal XMLoperador Uso myXML= {content}

Versión del lenguaje: ActionScript 3.0 Versión del reproductor: Flash Player 9 Define una etiqueta XML en un literal XML. Utilice la barra diagonal / para definir la etiqueta de cierre.

Operandos myXML:* — Un objeto XML o XMLList. tagName:* — Expresión que da como resultado el nombre de una etiqueta XML. attributeName:* — Expresión que da como resultado el nombre de un atributo XML. attributeValue:* — Expresión que da como resultado el valor de un atributo XML. content:* — Expresión que da como resultado el contenido de una etiqueta XML. Ejemplo Cómo utilizar los ejemplos El ejemplo siguiente muestra cómo utilizar los operadores < y > al definir un literal XML: var x:XML = cola;

Véase también Clase XML Clase XMLList © 2004-2007 Adobe Systems Incorporated. Todos los derechos reservados. Fri Oct 12 2007, 2:49 AM GMT-07:00

Enviarme un mensaje de correo electrónico cuando se añadan comentarios a esta página | Informe de comentarios Página actual: http://livedocs.adobe.com/flash/9.0_es/ActionScriptLangRefV3/operators.html