### Hierarchy

- ByteArray

### Implements

- IDataOutput
- IDataInput

## Index

### Constructors

- constructor

### Properties

- bytesAvailable
- endian
- length
- objectEncoding
- position
- defaultObjectEncoding

### Methods

- clear
- compress
- deflate
- get
- inflate
- readBoolean
- readByte
- readBytes
- readDouble
- readFloat
- readInt
- readMultiByte
- readObject
- readShort
- readUTF
- readUTFBytes
- readUnsignedByte
- readUnsignedInt
- readUnsignedShort
- set
- toString
- uncompress
- writeBoolean
- writeByte
- writeBytes
- writeDouble
- writeFloat
- writeInt
- writeMultiByte
- writeObject
- writeShort
- writeUTF
- writeUTFBytes
- writeUnsignedInt

## Constructors

### constructor

- new ByteArray(length?: number): ByteArray

- - Defined in lib/openfl/utils/ByteArray.d.ts:71

  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.

  #### Parameters

  - ##### Optional length: number

  #### Returns ByteArray

## Properties

### bytesAvailable

bytesAvailable: number

- Defined in lib/openfl/utils/ByteArray.d.ts:40

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.

### endian

endian: Endian

- Defined in lib/openfl/utils/ByteArray.d.ts:46

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

### length

length: number

- Defined in lib/openfl/utils/ByteArray.d.ts:57

The length of the ByteArray object, in bytes.

If the length is set to a value that is larger than the current length, 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.

### objectEncoding

objectEncoding: ObjectEncoding

- Defined in lib/openfl/utils/ByteArray.d.ts:64

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.

### position

position: number

- Defined in lib/openfl/utils/ByteArray.d.ts:71

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.

### Static defaultObjectEncoding

defaultObjectEncoding: ObjectEncoding

- Defined in lib/openfl/utils/ByteArray.d.ts:30

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.

## Methods

### clear

- clear(): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:102

  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.

  #### Returns void

### compress

- compress(algorithm?: CompressionAlgorithm): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:159

  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(<ph outputclass="javascript">air.CompressionAlgorithm.DEFLATE)` on the original ByteArray. However, the result from `compress(<ph outputclass="javascript">air.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

  - ##### Optional algorithm: CompressionAlgorithm

  #### Returns void

### deflate

- deflate(): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:184

  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.

  #### Returns void

### get

- get(position: number): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:14

  #### Parameters

  - ##### position: number

  #### Returns number

### inflate

- inflate(): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:209

  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.

  throws

    IOError The data is not valid compressed data; it was not compressed with the same compression algorithm used to compress.

  #### Returns void

### readBoolean

- readBoolean(): boolean

- - Defined in lib/openfl/utils/ByteArray.d.ts:221

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

  throws

    EOFError There is not sufficient data available to read.

  #### Returns boolean

  Returns `true` if the byte is nonzero, `false` otherwise.

### readByte

- readByte(): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:232

  Reads a signed byte from the byte stream.

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

  throws

    EOFError There is not sufficient data available to read.

  #### Returns number

  An integer between -128 and 127.

### readBytes

- readBytes(bytes: ByteArray, offset?: number, length?: number): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:251

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

  throws

    EOFError There is not sufficient data available to read.

  throws

    RangeError The value of the supplied offset and length, combined, is greater than the maximum for a uint.

  #### Parameters

  - ##### bytes: ByteArray

    The ByteArray object to read data into.

  - ##### Optional offset: number

    The offset(position) in `bytes` at which the read data should be written.

  - ##### Optional length: number

    The number of bytes to read. The default value of 0 causes all available data to be read.

  #### Returns void

### readDouble

- readDouble(): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:261

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

  throws

    EOFError There is not sufficient data available to read.

  #### Returns number

  A double-precision(64-bit) floating-point number.

### readFloat

- readFloat(): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:271

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

  throws

    EOFError There is not sufficient data available to read.

  #### Returns number

  A single-precision(32-bit) floating-point number.

### readInt

- readInt(): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:282

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

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

  throws

    EOFError There is not sufficient data available to read.

  #### Returns number

  A 32-bit signed integer between -2147483648 and 2147483647.

### readMultiByte

- readMultiByte(length: number, charSet: string): string

- - Defined in lib/openfl/utils/ByteArray.d.ts:310

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

  throws

    EOFError There is not sufficient data available to read.

  #### Parameters

  - ##### length: number

    The number of bytes from the byte stream to read.

  - ##### charSet: string

    The string denoting the character set to use to interpret the bytes. Possible character set strings include `"shift-jis"`, `"cn-gb"`, `"iso-8859-1"`, and others. For a complete list, see Supported Character Sets.

                   **Note:** If the value for the `charSet`
                   parameter is not recognized by the current system, the
                   application uses the system's default code page as the
                   character set. For example, a value for the
                   `charSet` parameter, as in
                   `myTest.readMultiByte(22, "iso-8859-01")` that
                   uses `01` instead of `1` might work
                   on your development system, but not on another system. On
                   the other system, the application will use the system's
                   default code page.

  #### Returns string

  UTF-8 encoded string.

### readObject

- readObject(): any

- - Defined in lib/openfl/utils/ByteArray.d.ts:319

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

  throws

    EOFError There is not sufficient data available to read.

  #### Returns any

  The deserialized object.

### readShort

- readShort(): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:330

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

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

  throws

    EOFError There is not sufficient data available to read.

  #### Returns number

  A 16-bit signed integer between -32768 and 32767.

### readUTF

- readUTF(): string

- - Defined in lib/openfl/utils/ByteArray.d.ts:340

  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.

  throws

    EOFError There is not sufficient data available to read.

  #### Returns string

  UTF-8 encoded string.

### readUTFBytes

- readUTFBytes(length: number): string

- - Defined in lib/openfl/utils/ByteArray.d.ts:351

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

  throws

    EOFError There is not sufficient data available to read.

  #### Parameters

  - ##### length: number

    An unsigned short indicating the length of the UTF-8 bytes.

  #### Returns string

  A string composed of the UTF-8 bytes of the specified length.

### readUnsignedByte

- readUnsignedByte(): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:362

  Reads an unsigned byte from the byte stream.

  The returned value is in the range 0 to 255.

  throws

    EOFError There is not sufficient data available to read.

  #### Returns number

  A 32-bit unsigned integer between 0 and 255.

### readUnsignedInt

- readUnsignedInt(): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:373

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

  The returned value is in the range 0 to 4294967295.

  throws

    EOFError There is not sufficient data available to read.

  #### Returns number

  A 32-bit unsigned integer between 0 and 4294967295.

### readUnsignedShort

- readUnsignedShort(): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:384

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

  The returned value is in the range 0 to 65535.

  throws

    EOFError There is not sufficient data available to read.

  #### Returns number

  A 16-bit unsigned integer between 0 and 65535.

### set

- set(position: number, value: number): number

- - Defined in lib/openfl/utils/ByteArray.d.ts:15

  #### Parameters

  - ##### position: number

  - ##### value: number

  #### Returns number

### toString

- toString(): string

- - Defined in lib/openfl/utils/ByteArray.d.ts:396

  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.

  #### Returns string

  The string representation of the byte array.

### uncompress

- uncompress(algorithm?: CompressionAlgorithm): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:427

  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.

  throws

    IOError The data is not valid compressed data; it was not compressed with the same compression algorithm used to compress.

  #### Parameters

  - ##### Optional algorithm: CompressionAlgorithm

  #### Returns void

### writeBoolean

- writeBoolean(value: boolean): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:439

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

  #### Parameters

  - ##### value: boolean

    A Boolean value determining which byte is written. If the parameter is `true`, the method writes a 1; if `false`, the method writes a 0.

  #### Returns void

### writeByte

- writeByte(value: number): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:451

  Writes a byte to the byte stream.

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

  #### Parameters

  - ##### value: number

    A 32-bit integer. The low 8 bits are written to the byte stream.

  #### Returns void

### writeBytes

- writeBytes(bytes: ByteArray, offset?: number, length?: number): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:473

  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

  - ##### bytes: ByteArray

    The ByteArray object.

  - ##### Optional offset: number

    A zero-based index indicating the position into the array to begin writing.

  - ##### Optional length: number

    An unsigned integer indicating how far into the buffer to write.

  #### Returns void

### writeDouble

- writeDouble(value: number): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:482

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

  #### Parameters

  - ##### value: number

    A double-precision(64-bit) floating-point number.

  #### Returns void

### writeFloat

- writeFloat(value: number): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:491

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

  #### Parameters

  - ##### value: number

    A single-precision(32-bit) floating-point number.

  #### Returns void

### writeInt

- writeInt(value: number): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:499

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

  #### Parameters

  - ##### value: number

    An integer to write to the byte stream.

  #### Returns void

### writeMultiByte

- writeMultiByte(value: string, charSet: string): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:514

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

  #### Parameters

  - ##### value: string

    The string value to be written.

  - ##### charSet: string

    The string denoting the character set to use. Possible character set strings include `"shift-jis"`, `"cn-gb"`, `"iso-8859-1"`, and others. For a complete list, see Supported Character Sets.

  #### Returns void

### writeObject

- writeObject(object: any): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:522

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

  #### Parameters

  - ##### object: any

    The object to serialize.

  #### Returns void

### writeShort

- writeShort(value: number): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:532

  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

  - ##### value: number

    32-bit integer, whose low 16 bits are written to the byte stream.

  #### Returns void

### writeUTF

- writeUTF(value: string): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:543

  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.

  throws

    RangeError If the length is larger than 65535.

  #### Parameters

  - ##### value: string

    The string value to be written.

  #### Returns void

### writeUTFBytes

- writeUTFBytes(value: string): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:553

  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

  - ##### value: string

    The string value to be written.

  #### Returns void

### writeUnsignedInt

- writeUnsignedInt(value: number): void

- - Defined in lib/openfl/utils/ByteArray.d.ts:561

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

  #### Parameters

  - ##### value: number

    An unsigned integer to write to the byte stream.

  #### Returns void

Generated using TypeDoc