ByteArray  - AS3

El número de bytes de datos disponibles para su lectura desde la posición actual del conjunto de bytes hasta el final del conjunto.

Utilice la propiedad bytesAvailable en combinación con los métodos de lectura cada vez que acceda a un objeto ByteArray para garantizar que los datos leídos son válidos.

Denota la codificación predeterminada del objeto para que la clase ByteArray lo utilice en una instancia nueva de ByteArray. Al crear una nueva instancia de ByteArray, la codificación de dicha instancia se inicia con el valor de defaultObjectEncoding. La propiedad defaultObjectEncoding se inicializa en ObjectEncoding.AMF3.

Cuando se escribe o se lee un objeto a partir de datos binarios, se utiliza el valor objectEncoding para determinar si se debe utilizar el formato de ActionScript 3.0, 2.0 ó 1.0. El valor es una constante de la clase ObjectEncoding.

Elementos de API relacionados

Cambia o lee el orden de bytes de los datos; puede ser Endian.BIG_ENDIAN o Endian.LITTLE_ENDIAN. El valor predeterminado es BIG_ENDIAN.

Elementos de API relacionados

Longitud del objeto ByteArray, expresada en bytes.

Si la longitud se establece en un valor mayor que la longitud actual, la parte derecha del conjunto se llenará con ceros.

Si la longitud se establece como un valor inferior a la longitud actual, el conjunto de bytes se trunca.

Se utiliza para determinar si se debe utilizar el formato ActionScript 3.0, 2.0 ó 1.0 al escribir o leer una instancia de ByteArray. El valor es una constante de la clase ObjectEncoding.

Elementos de API relacionados

Desplaza (o devuelve) la posición actual (expresada en bytes) del puntero del archivo al objeto ByteArray. Se trata del punto en el que se inicia la lectura de la siguiente llamada a un método de lectura o la escritura de un método de escritura.

Especifica si la memoria subyacente del conjunto de bytes es shareable (se puede compartir). En un conjunto de bytes compatible, todas las instancias de ByteArray de todos los programas de trabajo utilizan la misma memoria subyacente del sistema. El valor predeterminado es false e indica que la memoria subyacente no se comparte entre los programas de trabajo.

Esta propiedad también afecta a lo que hace el motor de ejecución con este conjunto de bytes si lo transfiere a otro programa de trabajo con el método Worker.setSharedProperty() o con el método MessageChannel.send():

• Not shareable: si esta propiedad es false, cuando se transfiere el conjunto de bytes a un programa de trabajo, el motor de ejecución crea una copia completa del conjunto de bytes, incluida la asignación de un nuevo segmento de memoria en el que almacenar el contenido duplicado del conjunto de bytes
• Shareable: si esta propiedad es true, cuando se transfiere el conjunto de bytes a un programa de trabajo, el motor de ejecución utiliza la misma memoria subyacente que el búfer de almacenamiento para el contenido de la instancia de ByteArray original y para la nueva instancia de ByteArray para el segundo programa de trabajo. En esencia, ambas instancias de ByteArray contienen una referencia al mismo conjunto de bytes subyacente.

La capacidad de acceder a un conjunto de bytes compartido desde diversos programas de trabajo al mismo tiempo puede provocar situaciones no deseadas en las que los dos programas de trabajo manipulen la memoria subyacente del conjunto de bytes al mismo tiempo. Puede recurrir a distintos mecanismos para controlar el acceso a la memoria compartida:

• los mecanismos de comparación e intercambio proporcionados por los métodos atomicCompareAndSwapIntAt() y atomicCompareAndSwapLength() de la clase ByteArray
• los mecanismos especializados proporcionados por las clases Mutex y Condition (en el paquete flash.concurrent)

Establecer esta propiedad en true solo afecta al siguiente código que transfiera este conjunto de bytes a un programa de trabajo. Una copia de este conjunto de bytes ya transferida a un programa de trabajo seguirá existiendo como copia independiente.

Si establece esta propiedad en false cuando previamente estaba definida como true, la memoria subyacente del conjunto de bytes se copiará inmediatamente en un nuevo segmento de la memoria del sistema. Seguidamente, la instancia de ByteArray utilizará la nueva memoria a partir de dicho punto. En consecuencia, la memoria subyacente de este conjunto de bytes ya no se compartirá con otros programas de trabajo incluso si se compartía previamente. Si posteriormente transfiere este conjunto de bytes a un programa de trabajo, su memoria subyacente se copiará como cualquier objeto ByteArray cuya propiedad shareable sea false.

El valor predeterminado es false.

Elementos de API relacionados

Crea una instancia de ByteArray que representa un conjunto empaquetado de bytes, de modo que es posible utilizar los métodos y propiedades de esta clase para mejorar el flujo y almacenamiento de los datos.

En una única operación atómica, compara un valor entero en este conjunto de bytes con otro valor entero y, si coinciden, intercambia los bytes por otro valor.

Este método está diseñado para su uso con un conjunto de bytes cuya memoria subyacente se comparte entre diversos programas de trabajo (la propiedad shareable de la instancia de ByteArray es true). Lleva a cabo la siguiente secuencia de pasos:

1. Lee un valor entero desde este conjunto de bytes comenzando en el índice (medido en bytes) especificado en el argumento byteIndex
2. Compara el valor real de este conjunto de bytes con el valor transferido en el argumento expectedValue
3. Si ambos valores son iguales, escribe el valor del argumento newValue en el conjunto de bytes en la ubicación especificada por el parámetro byteIndex y devuelve el valor contenido previamente en dichos bytes (el valor leído en el paso 1)
4. En caso contrario, el contenido del conjunto de bytes no cambia y el método devuelve el valor real leído en el conjunto de bytes

Todos estos pasos se llevan a cabo en una transacción de hardware atómica. De esta forma se garantiza que ninguna operación de otros programas de trabajo realiza cambios en el contenido del conjunto de bytes durante el proceso de comparación e intercambio.

Parámetros

Elementos de API relacionados

En una única operación atómica, compara la longitud de este conjunto de bytes con un valor proporcionado y, si coinciden, cambia la longitud de este conjunto de bytes.

Este método está diseñado para su uso con un conjunto de bytes cuya memoria subyacente se comparte entre diversos programas de trabajo (la propiedad shareable de la instancia de ByteArray es true). Hace lo siguiente:

1. Lee la propiedad length del entero de la instancia de ByteArray
2. Compara la longitud con el valor transferido en el argumento expectedLength
3. Si los dos valores son iguales, modifica la longitud del conjunto de bytes por la del valor transferido como argumento newLength, bien ampliando o reduciendo el tamaño del conjunto de bytes
4. En caso contrario, no se modifica el conjunto de bytes

Todos estos pasos se llevan a cabo en una transacción de hardware atómica. Esto garantiza que ninguna operación de otros programas de trabajo pueda modificar el contenido del conjunto de bytes durante la operación de comparación y cambio de tamaño.

Parámetros

Elementos de API relacionados

Borra el contenido del conjunto de bytes y restablece las propiedades length y position en 0. Al llamar a este método, se libera explícitamente la memoria utilizada por la instancia de ByteArray.

Comprime el conjunto de bytes. Se comprime todo el conjunto de bytes. Después de la llamada, la propiedad length de ByteArray se establece con la nueva longitud. La propiedad position se establece al final del conjunto de bytes.

Especifica un algoritmo de compresión transfiriendo un valor (definido en la clase CompressionAlgorithm) como el parámetro algorithm. Los algoritmos admitidos son los siguientes:

El formato de datos comprimidos zlib se describe en http://www.ietf.org/rfc/rfc1950.txt.

El algoritmo de compresión deflate se describ en http://www.ietf.org/rfc/rfc1951.txt.

El algoritmo de compresión lzma se describe en http://www.7-zip.org/7z.html.

El algoritmo de compresión deflate se utiliza en diversos formatos, como zlib, gzip, en algunas implementaciones de zip, etc. Cuando se comprien datos utilizando uno de estos formatos de compresión, además de almacenar la versión comprimida de los datos originales, los datos del formato compresión (por ejemplo, el archivo .zip) incluyen información de metadatos. Algunos ejemplos de los tipos de metadatos incluidos en los diversos formatos de archivo son el nombre de archivo, fecha y hora de modificación, tamaño del archivo original, comentarios opcionales, datos de suma de comprobación, etc.

Por ejemplo, cuando ByteArray se comprime utilizando el algoritmo zlib, el conjunto ByteArray resultante es estructura según en formato específico. Determinados bytes contienen metadatos sobre los datos comprimidos, y otros bytes contienen la versión comprimida de los datos originales de ByteArray. Tal como se define en la especificación del formato de datos comprimidos zlib, estos bytes (es decir, la parte que contiene la versión comprimida de los datos originales) se comprimen utilizando el algoritmo deflate. En consecuencia, dichos bytes son idénticos a los de la llamada a compress(air.CompressionAlgorithm.DEFLATE) en el objeto ByteArray original. Sin embargo, el resultado de compress( air.CompressionAlgorithm.ZLIB) incluye los metadatos adicionales, mientras que el resultado de compress( CompressionAlgorithm.DEFLATE) incluye solamente la versión comprimida de los datos ByteArray originales y nada más.

Para poder utilizar el formato deflate en la compresión de datos de una instancia de ByteArray en un formato concreto, como puede ser gzip o zip, no basta con llamar a compress( CompressionAlgorithm.DEFLATE). Se debe crear un conjunto ByteArray estructurado según la especificación del formato de comrpesión, incluidos los metadatos apropiados, así como los datos comprimidos obtenidos con el formato deflate. Del mismo modo, para poder descodificar datos comprimidos en formatos como gzip o zip, no basta con llamar a uncompress(CompressionAlgorithm.DEFLATE) en los datos. Primero se deben separar los metadatos de los datos comprimidos y, después, utilizar el formato deflate para descomprimirlos.

Parámetros

Elementos de API relacionados

Comprime el conjunto de bytes con el algoritmo de compresión deflate. Se comprime todo el conjunto de bytes.

Después de la llamada, la propiedad length de ByteArray se establece con la nueva longitud. La propiedad position se establece al final del conjunto de bytes.

El algoritmo de compresión deflate se describ en http://www.ietf.org/rfc/rfc1951.txt.

Para poder utilizar el formato deflate en la compresión de datos de una instancia de ByteArray en un formato concreto como puede ser gzip o zip, no basta con llamar a deflate(). Se debe crear un conjunto ByteArray estructurado según la especificación del formato de comrpesión, incluidos los metadatos apropiados, así como los datos comprimidos obtenidos con el formato deflate. Del mismo modo, para poder descodificar datos comprimidos en formatos como gzip o zip, no basta con llamar a inflate() en los datos. Primero se deben separar los metadatos de los datos comprimidos y, después, utilizar el formato deflate para descomprimirlos.

Elementos de API relacionados

Descomprime el conjunto de bytes con el algoritmo de compresión deflate. El conjunto de bytes debe estar comprimido con el mismo algoritmo.

Después de la llamada, la propiedad length de ByteArray se establece con la nueva longitud. La propiedad position está establecida en 0.

El algoritmo de compresión deflate se describ en http://www.ietf.org/rfc/rfc1951.txt.

Para poder descodificar datos comprimidos en formatos de archivo que utilicen el algoritmo de compresión deflate, por ejemplo, datos en formato gzip o zip, no basta con llamar a inflate() en un conjunto ByteArray que contenga datos con ese formato de compresión. Primero se deben separar los metadatos que forman parte del formato de datos comprimidos de los datos actuales. Para obtener más información, consulte la descripción del método compress().

Elementos de API relacionados

Lee un valor booleano del flujo de bytes. Se lee un solo byte y devuelve true si el byte es distinto de cero; en caso contrario, devuelve false.

Lee un byte con signo del flujo de bytes.

El valor devuelto se encuentra entre -128 y 127.

Lee el número de bytes de datos especificado por el parámetro length desde el flujo de bytes. Los bytes se leen en un objeto ByteArray especificado por el parámetro bytes y se escriben en el ByteArray de destino comenzando desde la posición especificada en offset.

Parámetros

Lee un número de coma flotante (64 bits) con precisión doble IEEE 754 del flujo de bytes.

Lee un número de coma flotante (32 bits) con precisión simple IEEE 754 del flujo de bytes.

Lee un entero de 32 bits con signo del flujo de bytes.

El valor devuelto se encuentra entre -2147483648 y 2147483647.

Lee una cadena multibyte de longitud especificada desde la transmisión de bytes mediante el juego de caracteres especificado.

Parámetros

Lee un objeto del conjunto de bytes, codificado en formato serializado AMF.

Elementos de API relacionados

Lee un entero de 16 bits con signo del flujo de bytes.

El valor devuelto se encuentra entre -32768 y 32767.

Lee un byte sin signo del flujo de bytes.

El valor devuelto se encuentra entre 0 y 255.

Lee un entero de 32 bits sin signo del flujo de bytes.

El valor devuelto se encuentra entre 0 y 4294967295.

Lee un entero de 16 bits sin signo del flujo de bytes.

El valor devuelto se encuentra entre 0 y 65535.

Lee una cadena UTF-8 del flujo de bytes. Se da por hecho que la cadena tiene un prefijo de declaración unsigned short que indica la longitud en bytes.

Elementos de API relacionados

Lee una secuencia de bytes UTF-8 especificada por el parámetro length desde el flujo de bytes y devuelve una cadena.

Parámetros

Proporciona un método anulable para personalizar la codificación JSON de valores de un objeto ByteArray.

El método JSON.stringify() busca un método toJSON() en cada objeto que atraviesa. Si el método toJSON() se encuentra, JSON.stringify() lo llama para cada valor que encuentra, transfiriendo la tecla que está emparejada con el valor.

ByteArray proporciona una implementación predeterminada de toJSON() que simplemente devuelve el nombre de la clase. Dado que el contenido de cualquier ByteArray requiere interpretación, los clientes que deseen exportar objetos ByteArray a JSON deben proporcionar su propia implementación. Para ello, puede redefinir el método toJSON() en el prototipo de la clase.

El método toJSON() puede devolver un valor de cualquier tipo. Si devuelve un objeto, stringify() se repite en el objeto. Si toJSON() devuelve una cadena, stringify() no se repite y continúa su recorrido.

Parámetros

Elementos de API relacionados

Convierte el conjunto de bytes en una cadena. Si los datos del conjunto comienzan con una marca de orden de byte Unicode, la aplicación conserva dicha marca al convertirla en una cadena. Si System.useCodePage se define como true, la aplicación trata los datos del conjunto como si estuvieran en la página de códigos del sistema actual durante la conversión.

Descomprime la matriz de bytes. Después de la llamada, la propiedad length de ByteArray se establece con la nueva longitud. La propiedad position está establecida en 0.

El conjunto de bytes debe estar comprimido con el mismo algoritmo que la descompresión. Especifica un algoritmo de descompresión transfiriendo un valor (definido en la clase CompressionAlgorithm) como el parámetro algorithm. Los algoritmos admitidos son los siguientes:

El formato de datos comprimidos zlib se describe en http://www.ietf.org/rfc/rfc1950.txt.

El algoritmo de compresión deflate se describ en http://www.ietf.org/rfc/rfc1951.txt.

El algoritmo de compresión lzma se describe en http://www.7-zip.org/7z.html.

Para poder descodificar datos comprimidos en formatos de archivo que utilicen el algoritmo de compresión deflate, por ejemplo, datos en formato gzip o zip, no basta con llamar a uncompress(CompressionAlgorithm.DEFLATE) en un conjunto ByteArray que contenga datos con ese formato de compresión. Primero se deben separar los metadatos que forman parte del formato de datos comprimidos de los datos actuales. Para obtener más información, consulte la descripción del método compress().

Parámetros

Elementos de API relacionados

Escribe un valor booleano. Se escribe un solo byte según el parámetro value, 1 si es true o 0 si es false.

Parámetros

Escribe un byte en el flujo de bytes.

Se utilizan los 8 bits más bajos del parámetro. Los 24 bits más altos se omiten.

Parámetros

Escribe una secuencia de length bytes desde el conjunto de bytes especificado, bytes, comenzando por offset (índice basado en cero) bytes en el flujo de bytes.

Si se omite el parámetro length, se utiliza la longitud predeterminada de 0; el método escribe todo el búfer comenzando por offset. Si también se omite el parámetro offset, se escribirá en todo el búfer.

Si offset o length está fuera de rango, se ajustarán para que coincidan con el principio y el final del conjunto bytes.

Parámetros

Escribe un número de coma flotante (64 bits) con precisión doble IEEE 754 en el flujo de bytes.

Parámetros

Escribe un número de coma flotante (32 bits) con precisión simple IEEE 754 en el flujo de bytes.

Parámetros

Escribe un entero de 32 bits con signo en el flujo de bytes.

Parámetros

Escribe una cadena multibyte en el flujo de bytes mediante el juego de caracteres especificado.

Parámetros

Escribe un objeto en el conjunto de bytes en formato serializado AMF.

Parámetros

Elementos de API relacionados

Escribe un entero de 16 bits en el flujo de bytes. Se utilizan los 16 bits más bajos del parámetro. Los 16 bits más altos se omiten.

Parámetros

Escribe un entero de 32 bits sin signo en el flujo de bytes.

Parámetros

Escribe una cadena UTF-8 en el flujo de bytes. La longitud de la cadena UTF-8 (expresada en bytes) se escribe primero, como un entero de 16 bits, seguida de los bytes que representan los caracteres de la cadena.

Parámetros

Escribe una cadena UTF-8 en el flujo de bytes. Similar al método writeUTF(), pero writeUTFBytes() no añade un prefijo a la cadena con una palabra de 16 bits de longitud.

Parámetros

1. Declare una nueva instancia del objeto ByteArray byteArr.
2. Escriba el valor equivalente a bytes del valor booleano false y, a continuación, compruebe la longitud y vuélvalo a leer.
3. Escriba el equivalente de coma flotante con precisión doble del valor matemático de pi.
4. Vuelva a leer cada uno de los nueves bytes escritos en el conjunto de bytes.

Nota: si trace() se llama en un byte, imprime el equivalente decimal de los bytes almacenados en el conjunto de bytes.

Observe que se añade un segmento de código al final para comprobar errores al final del archivo para garantizar que el flujo de bytes no se lea más allá de su final.

package {
    import flash.display.Sprite;
    import flash.utils.ByteArray;
    import flash.errors.EOFError;

    public class ByteArrayExample extends Sprite {        
        public function ByteArrayExample() {
            var byteArr:ByteArray = new ByteArray();

            byteArr.writeBoolean(false);
            trace(byteArr.length);            // 1
            trace(byteArr[0]);            // 0

            byteArr.writeDouble(Math.PI);
            trace(byteArr.length);            // 9
            trace(byteArr[0]);            // 0
            trace(byteArr[1]);            // 64
            trace(byteArr[2]);            // 9
            trace(byteArr[3]);            // 33
            trace(byteArr[4]);            // 251
            trace(byteArr[5]);            // 84
            trace(byteArr[6]);            // 68
            trace(byteArr[7]);            // 45
            trace(byteArr[8]);            // 24
            
            byteArr.position = 0;

            try {
                trace(byteArr.readBoolean() == false); // true
            } 
            catch(e:EOFError) {
                trace(e);           // EOFError: Error #2030: End of file was encountered.
            }
            
            try {
                trace(byteArr.readDouble());        // 3.141592653589793
            }
            catch(e:EOFError) {
                trace(e);           // EOFError: Error #2030: End of file was encountered.
            }
            
            try {
                trace(byteArr.readDouble());
            } 
            catch(e:EOFError) {
                trace(e);            // EOFError: Error #2030: End of file was encountered.
            }
        }
    }
}