The number of bytes of data available for reading from the current position in the byte array to the end of the array.

Use the bytesAvailable property in conjunction with the read methods each time you access a ByteArray object to ensure that you are reading valid data.

Denotes the default object encoding for the ByteArray class to use for a new ByteArray instance. When you create a new ByteArray instance, the encoding on that instance starts with the value of defaultObjectEncoding. The defaultObjectEncoding property is initialized to ObjectEncoding.AMF3.

When an object is written to or read from binary data, the objectEncoding value is used to determine whether the ActionScript 3.0, ActionScript2.0, or ActionScript 1.0 format should be used. The value is a constant from the ObjectEncoding class.

See also

Changes or reads the byte order for the data; either Endian.BIG_ENDIAN or Endian.LITTLE_ENDIAN.

See also

The length of the ByteArray object, in bytes.

If the length is set to a value that is larger than the current length, the the right side of the byte array is filled with zeros.

If the length is set to a value that is smaller than the current length, the byte array is truncated.

Used to determine whether the ActionScript 3.0, ActionScript 2.0, or ActionScript 1.0 format should be used when writing to, or reading from, a ByteArray instance. The value is a constant from the ObjectEncoding class.

See also

Moves, or returns the current position, in bytes, of the file pointer into the ByteArray object. This is the point at which the next call to a read method starts reading or a write method starts writing.

Creates a ByteArray instance representing a packed array of bytes, so that you can use the methods and properties in this class to optimize your data storage and stream.

Clears the contents of the byte array and resets the length and position properties to 0. Calling this method explicitly frees up the memory used by the ByteArray instance.

Compresses the byte array. The entire byte array is compressed. For content running in Adobe AIR, you can specify a compression algorithm by passing a value (defined in the CompressionAlgorithm class) as the algorithm parameter. Flash Player supports only the default algorithm, zlib.

After the call, the length property of the ByteArray is set to the new length. The position property is set to the end of the byte array.

The zlib compressed data format is described at http://www.ietf.org/rfc/rfc1950.txt.

The deflate compression algorithm is described at http://www.ietf.org/rfc/rfc1951.txt.

The deflate compression algorithm is used in several compression formats, such as zlib, gzip, some zip implementations, and others. When data is compressed using one of those compression formats, in addition to storing the compressed version of the original data, the compression format data (for example, the .zip file) includes metadata information. Some examples of the types of metadata included in various file formats are file name, file modification date/time, original file size, optional comments, checksum data, and more.

For example, when a ByteArray is compressed using the zlib algorithm, the resulting ByteArray is structured in a specific format. Certain bytes contain metadata about the compressed data, while other bytes contain the actual compressed version of the original ByteArray data. As defined by the zlib compressed data format specification, those bytes (that is, the portion containing the compressed version of the original data) are compressed using the deflate algorithm. Consequently those bytes are identical to the result of calling compress(CompressionAlgorithm.DEFLATE) on the original ByteArray. However, the result from compress(CompressionAlgorithm.ZLIB) includes the extra metadata, while the compress(CompressionAlgorithm.DEFLATE) result includes only the compressed version of the original ByteArray data and nothing else.

In order to use the deflate format to compress a ByteArray instance's data in a specific format such as gzip or zip, you cannot simply call compress(CompressionAlgorithm.DEFLATE). You must create a ByteArray structured according to the compression format's specification, including the appropriate metadata as well as the compressed data obtained using the deflate format. Likewise, in order to decode data compressed in a format such as gzip or zip, you can't simply call uncompress(CompressionAlgorithm.DEFLATE) on that data. First, you must separate the metadata from the compressed data, and you can then use the deflate format to decompress the compressed data.

Parameters

See also

Compresses the byte array using the deflate compression algorithm. The entire byte array is compressed.

After the call, the length property of the ByteArray is set to the new length. The position property is set to the end of the byte array.

The deflate compression algorithm is described at http://www.ietf.org/rfc/rfc1951.txt.

In order to use the deflate format to compress a ByteArray instance's data in a specific format such as gzip or zip, you cannot simply call deflate(). You must create a ByteArray structured according to the compression format's specification, including the appropriate metadata as well as the compressed data obtained using the deflate format. Likewise, in order to decode data compressed in a format such as gzip or zip, you can't simply call inflate() on that data. First, you must separate the metadata from the compressed data, and you can then use the deflate format to decompress the compressed data.

See also

Decompresses the byte array using the deflate compression algorithm. The byte array must have been compressed using the same algorithm.

After the call, the length property of the ByteArray is set to the new length. The position property is set to 0.

The deflate compression algorithm is described at http://www.ietf.org/rfc/rfc1951.txt.

In order to decode data compressed in a format that uses the deflate compression algorithm, such as data in gzip or zip format, it will not work to simply call inflate() on a ByteArray containing the compression formation data. First, you must separate the metadata that is included as part of the compressed data format from the actual compressed data. For more information, see the compress() method description.

See also

Reads a Boolean value from the byte stream. A single byte is read, and true is returned if the byte is nonzero, false otherwise.

Reads a signed byte from the byte stream.

The returned value is in the range -128 to 127.

Reads the number of data bytes, specified by the length parameter, from the byte stream. The bytes are read into the ByteArray object specified by the bytes parameter, and the bytes are written into the destination ByteArray starting at the position specified by offset.

Parameters

Reads an IEEE 754 double-precision (64-bit) floating-point number from the byte stream.

Reads an IEEE 754 single-precision (32-bit) floating-point number from the byte stream.

Reads a signed 32-bit integer from the byte stream.

The returned value is in the range -2147483648 to 2147483647.

Reads a multibyte string of specified length from the byte stream using the specified character set.

Parameters

Reads an object from the byte array, encoded in AMF serialized format.

See also

Reads a signed 16-bit integer from the byte stream.

The returned value is in the range -32768 to 32767.

Reads an unsigned byte from the byte stream.

The returned value is in the range 0 to 255.

Reads an unsigned 32-bit integer from the byte stream.

The returned value is in the range 0 to 4294967295.

Reads an unsigned 16-bit integer from the byte stream.

The returned value is in the range 0 to 65535.

Reads a UTF-8 string from the byte stream. The string is assumed to be prefixed with an unsigned short indicating the length in bytes.

See also

Reads a sequence of UTF-8 bytes specified by the length parameter from the byte stream and returns a string.

Parameters

Converts the byte array to a string. If the data in the array begins with a Unicode byte order mark, the application will honor that mark when converting to a string. If System.useCodePage is set to true, the application will treat the data in the array as being in the current system code page when converting.

Decompresses the byte array. For content running in Adobe AIR, you can specify a compression algorithm by passing a value (defined in the CompressionAlgorithm class) as the algorithm parameter. The byte array must have been compressed using the same algorithm. Flash Player supports only the default algorithm, zlib.

After the call, the length property of the ByteArray is set to the new length. The position property is set to 0.

The zlib compressed data format is described at http://www.ietf.org/rfc/rfc1950.txt.

The deflate compression algorithm is described at http://www.ietf.org/rfc/rfc1951.txt.

In order to decode data compressed in a format that uses the deflate compression algorithm, such as data in gzip or zip format, it will not work to call uncompress(CompressionAlgorithm.DEFLATE) on a ByteArray containing the compression formation data. First, you must separate the metadata that is included as part of the compressed data format from the actual compressed data. For more information, see the compress() method description.

Parameters

See also

Writes a Boolean value. A single byte is written according to the value parameter, either 1 if true or 0 if false.

Parameters

Writes a byte to the byte stream.

The low 8 bits of the parameter are used. The high 24 bits are ignored.

Parameters

Writes a sequence of length bytes from the specified byte array, bytes, starting offset (zero-based index) bytes into the byte stream.

If the length parameter is omitted, the default length of 0 is used; the method writes the entire buffer starting at offset. If the offset parameter is also omitted, the entire buffer is written.

If offset or length is out of range, they are clamped to the beginning and end of the bytes array.

Parameters

Writes an IEEE 754 double-precision (64-bit) floating-point number to the byte stream.

Parameters

Writes an IEEE 754 single-precision (32-bit) floating-point number to the byte stream.

Parameters

Writes a 32-bit signed integer to the byte stream.

Parameters

Writes a multibyte string to the byte stream using the specified character set.

Parameters

Writes an object into the byte array in AMF serialized format.

Parameters

See also

Writes a 16-bit integer to the byte stream. The low 16 bits of the parameter are used. The high 16 bits are ignored.

Parameters

Writes a 32-bit unsigned integer to the byte stream.

Parameters

Writes a UTF-8 string to the byte stream. The length of the UTF-8 string in bytes is written first, as a 16-bit integer, followed by the bytes representing the characters of the string.

Parameters

Writes a UTF-8 string to the byte stream. Similar to the writeUTF() method, but writeUTFBytes() does not prefix the string with a 16-bit length word.

Parameters

1. Declare a new ByteArray object instance byteArr.
2. Write the byte-equivalent value of the Boolean false and then check the length and read it back.
3. Write the double-precision floating-point equivalent of the mathematical value of pi.
4. Read back each of the nine bytes written into the byte array.

Note: when trace() is called on a byte, it prints the decimal equivalent of the bytes stored in the byte array.

Notice how a code segment is added at the end to check for end of file errors to ensure that the byte stream is not read past its end.

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.
            }
        }
    }
}