ByteArray  - AS3

O número de bytes de dados disponíveis para leitura da posição atual na matriz de bytes até o final dessa matriz.

Use a propriedade bytesAvailable em conjunto com os métodos de leitura, sempre que acessar o objeto ByteArray para garantir a leitura de dados válidos.

Indica a codificação de objeto padrão para a classe ByteArray a ser usada para uma nova ocorrência de ByteArray. Quando você cria uma nova ocorrência ByteArray, a codificação desta ocorrência começa com o valor de defaultObjectEncoding. A propriedade defaultObjectEncoding é inicializada para ObjectEncoding.AMF3.

Se um objeto for gravado ou lido de dados binários, o valor objectEncoding é usado para determinar se o formato ActionScript 3.0, ActionScript2.0 ou ActionScript 1.0 deve ser usado. O valor é uma constante da classe ObjectEncoding.

Elementos da API relacionados

Altera ou faz a leitura da ordem de bytes para os dados; seja Endian.BIG_ENDIAN ou Endian.LITTLE_ENDIAN. O valor padrão é BIG_ENDIAN.

Elementos da API relacionados

O comprimento do objeto ByteArray, em bytes.

Se o comprimento for definido para um valor maior do que o comprimento atual, o lado direito da matriz de bytes é completado com zeros.

Se o comprimento for configurado para um valor menor que o comprimento atual, a matriz fica truncada.

Usada para determinar se o formato ActionScript 3.0, ActionScript 2.0 ou ActionScript 1.0 deve ser usado ao gravar em, ou ler de, uma ocorrência de ByteArray. O valor é uma constante da classe ObjectEncoding.

Elementos da API relacionados

Move, ou retorna a posição atual, em bytes, do ponteiro de arquivo no objeto ByteArray. Este é o ponto em que a chamada seguinte para um método de leitura tem início ou o método de gravação tem início.

Especifica se a memória subjacente da matriz de bytes é compartilhável Em uma matriz de bytes compartilhável, todas as instâncias de ByteArray em todos os workers que fazem referência à matriz de butes usam a mesma memória de sistema subjacente. O valor padrão é false, indicando que a memória subjacente não é compartilhada entre os workers.

Esta propriedade também afeta as ações do runtime em relação a esta matriz de bytes, se for transmitida a um worker usando o método Worker.setSharedProperty() ou o método MessageChannel.send():

• Não compartilhável: Se esta propriedade for false, quando a matriz de bytes for transmitida a um worker, o runtime cria uma cópia completa da matriz de bytes, incluindo a alocação de um novo segmento de memória em que armazenará o conteúdo duplicado da matriz de bytes.
• Compartilhável: Se esta propriedade for true, quando a matriz de bytes é transmitida a um worker, o runtime utiliza a mesma memória subjacente como buffer de armazenamento para o conteúdo da instância ByteArray original e para a nova instância ByteArray criadas pelo segundo worker. Na essência, ambas as instâncias da ByteArray contém uma referência à mesma matriz de bytes subjacente.

A capacidade de acesso a uma matriz de bytes a partir de diversos workers simultaneamente pode resultar em uma situação indesejada, em que ambos os workers estão manipulando a memória subjacente da matriz de bytes ao mesmo tempo. Você pode utilizar diversos mecanismos para controlar o acesso à memória compartilhada:

• os mecanismos de comparação e troca fornecidos pelos métodos atomicCompareAndSwapIntAt() e atomicCompareAndSwapLength() da classe ByteArray
• os mecanismos especializados produzidos pelas classes Mutex e Condition (no pacote flash.concurrent)

Se configurar esta propriedade para true, apenas afetará o código subsequente que transmite esta matriz de bytes a um worker. Qualquer cópia desta matriz de bytes que já foi transmitida a um worker continua a existir como uma cópia separada.

Se você definir a propriedade para false, quando, anteriormente, estava true, a memória subjacente da matriz de bytes é imediatamente copiada a um novo segmento da memória do sistema. Esta instância da ByteArray utiliza, então, a nova memória subjacente a partir daquele ponto. Como consequência, a memória subjacente desta matriz de bytes deixou de ser compartilhada com outros workers, mesmo que tenha sido previamente compartilhado. Se você transmitir esta matriz de bytes a um worker, a memória subjacente será copiada como qualquer objeto ByteArray cuja propriedade shareable é false.

O valor padrão é false.

Elementos da API relacionados

Cria uma ocorrência de ByteArray representando uma matriz compactada de bytes, para que você possa usar os métodos e as propriedades nessa classe, para otimizar o fluxo e o armazenamento de dados.

Em uma única operação atômica, ela compara um valor inteiro nesta matriz de bytes a outro valor inteiro. Se forem compatíveis, troque estes bytes por outros valores.

Este método deve ser usado com uma matriz de bytes cuja memória subjacente é compartilhada entre diversos workers (a propriedade compartilhável da instância ByteArray é verdadeira). Executa a sequência de passos a seguir:

1. Lê um valor inteiro a partir da matriz de bytes, iniciando-se no índice especificado (medido em bytes) no argumento byteIndex
2. Compara o valor real da matriz de bytes ao valor transmitido no argumento expectedValue.
3. Se os dois valores forem iguais, ele escreve o valor no argumento newValue na matriz de bytes no local especificado pelo parâmetro byteIndex e retorna o valor contido previamente naqueles bytes (o valor lido na etapa 1)
4. Caso contrário, o conteúdo da matriz de bytes não será alterado e o método retorna o valor real, lido a partir da matriz de bytes

Todas as etapas foram executadas em uma transação de hardware atômica. Essa ação garante que nenhuma operação de outros workers faça qualquer alteração ao conteúdo da matriz de bytes durante a operação de comparação e troca.

Parâmetros

Elementos da API relacionados

Em uma operação atômica simples, ele compara o comprimento da matriz de bytes com o valor fornecido e, se forem correspondentes, altera o comprimento desta matriz de bytes.

Este método deve ser usado com uma matriz de bytes cuja memória subjacente é compartilhada entre diversos workers (a propriedade compartilhável da instância ByteArray é verdadeira). Ele executa o seguinte:

1. Lê a propriedade length inteira da instância ByteArray
2. Compara o comprimento do valor transmitido no argumento expectedLength
3. Se os dois valores forem iguais, ele altera o comprimento da matriz de bytes ao valor transmitido como o parâmetro newLenght, aumentando ou diminuindo o tamanho da matriz de bytes
4. Caso contrário, a matriz de bytes não é alterada

Todas as etapas foram executadas em uma transação de hardware atômica. Essa ação garante que nenhuma operação de outros workers faça qualquer alteração ao conteúdo da matriz de bytes durante a operação de comparação e redimensionamento.

Parâmetros

Elementos da API relacionados

Limpa o conteúdo da matriz de bytes e redefine as propriedades length e position como 0. Chamar o método libera explicitamente a memória usada pela ocorrência de ByteArray.

Compacta a matriz de bytes. Toda a matriz de bytes é compactada. Após a chamada, a propriedade length do ByteArray é configurada no novo comprimento. A propriedade posição é configurada no fim da matriz de bytes.

Especifica um algoritmo de compactação transmitindo um valor (definido na classe CompressionAlgorithm) como o parâmetro algorithm. Os algoritmos suportados incluem o seguinte:

O formato dos dados comprimidos zlib está descrito em http://www.ietf.org/rfc/rfc1950.txt_br.

O algoritmo de compactação deflate está descrito em http://www.ietf.org/rfc/rfc1951.txt_br.

O algoritmo de compactação lzma é descrito em http://www.7-zip.org/7z.html.

O algoritmo de compactação deflate é usado em vários formatos de compactação, tais como zlib, gzip, algumas implementações zip e outros. Quando os dados são compactados usando um desses formatos de compactação, além de armazenar a versão compactada dos dados originais, os dados do formato de compressão (por exemplo, um arquivo .zip) incluem informações de metadados. Alguns exemplos de tipos de metadados incluídos em vários formatos de arquivo são o nome do arquivo, data/hora de modificação do arquivo, tamanho original, comentários opcionais, dados checksum e mais.

Por exemplo, quando um ByteArray é compactado usando o algoritmo zlib, o ByteArray resultante é estruturado num formato específico. Certos bytes contêm metadados sobre os dados compactados, enquanto outros contêm a versão atual compactada dos dados originais ByteArray. Conforme definido nas especificações de formato de dados compactados zlib, esses bytes (que são a parte contendo a versão compactada dos dados originais) são compactados usando o algoritmo deflate. Consequentemente, esses bytes são idênticos ao resultado da chamada de compress(air. CompressionAlgorithm.DEFLATE) no ByteArray original. No entanto, o resultado de compress(air. CompressionAlgorithm.ZLIB) inclui os metadados extras, enquanto o resultado compress( CompressionAlgorithm.DEFLATE) inclui apenas a versão compactada dos dados ByteArray originais e nada mais.

Para usar o formato deflate para compactar dados da ocorrência ByteArray em um formato específico, como gzip ou zip, não é possível chamar simplesmente compress( CompressionAlgorithm.DEFLATE) . É necessário criar um ByteArray estruturado de acordo com as especificações de formato de compressão, incluindo os metadados apropriados, bem como os dados compactados obtidos com o uso da formatação deflate. Do mesmo modo, para decodificar os dados compactados em um formato como gzip ou zip, não é possível simplesmente chamar uncompress(CompressionAlgorithm.DEFLATE) nos dados. Primeiro, é necessário separar os metadados dos dados compactados e é possível usar o formato deflate para compactar e descompactar os dados.

Parâmetros

Elementos da API relacionados

Compacta a matriz de bytes usando o algoritmo de compactação deflate. Toda a matriz de bytes é compactada.

Após a chamada, a propriedade length do ByteArray é configurada no novo comprimento. A propriedade posição é configurada no fim da matriz de bytes.

O algoritmo de compactação deflate está descrito em http://www.ietf.org/rfc/rfc1951.txt_br.

Consequentemente, para usar o formato deflate para compactar dados da instância ByteArray em um formato específico, tais como gzip ou zip, não é possível chamar simplesmente deflate(). É necessário criar um ByteArray estruturado de acordo com as especificações de formato de compressão, incluindo os metadados apropriados, bem como os dados compactados obtidos com o uso da formatação deflate. Do mesmo modo, para decodificar os dados compactados em um formato como gzip ou zip, não é possível simplesmente chamar inflate() nos dados. Primeiro, é necessário separar os metadados dos dados compactados e é possível usar o formato deflate para compactar e descompactar os dados.

Elementos da API relacionados

Descompacta a matriz de bytes usando o algoritmo de compactação deflate. A matriz de bytes deve ter sido compactada usando o mesmo algoritmo.

Após a chamada, a propriedade length do ByteArray é configurada no novo comprimento. A propriedade posição é configurada para 0.

O algoritmo de compactação deflate está descrito em http://www.ietf.org/rfc/rfc1951.txt_br.

Para decodificar os dados compactados em um formato que use o algoritmo de compactação deflate como, por exemplo, os dados no formato gzip ou zip, chamar o método inflate() não funcionará em ByteArray que contenha os dados de formação da compactação. Primeiro, os metadados incluídos como parte do formato de dados compactados devem ser separados dos dados atualmente compactados. Para obter mais informações, consulte a descrição do métodocompress().

Elementos da API relacionados

Lê um valor booliano do fluxo de bytes. O único byte é lido e é retornado true se o byte for diferente de zero, false em caso contrário.

Lê um byte assinado do fluxo de bytes.

O valor retornado está na faixa de -128 a 127.

Lê o número de bytes de dados especificados pelo parâmetro comprimento, do fluxo de bytes. Os bytes são lidos no objeto ByteArray, especificado pelo parâmetro bytes, e os bytes são escritos no ByteArray de destino, com o início na posição especificada pelo deslocamento.

Parâmetros

Lê um número de ponto flutuante de precisão dupla (64 bits) IEEE 754 do fluxo de bytes.

Lê um número de ponto flutuante de precisão única (32 bits) IEEE 754 do fluxo de bytes.

Lê um inteiro de 32 bits assinado do fluxo de bytes.

O valor retornado está na faixa de -2147483648 a 2147483647.

Lê uma string de vários bytes de comprimento especificado, do fluxo de bytes, usando o conjunto de caracteres especificado.

Parâmetros

Lê um objeto da matriz de bytes, codificado no formato serializado AMF.

Elementos da API relacionados

Lê um inteiro de 16 bits assinado do fluxo de bytes.

O valor retornado está na faixa de -32768 a 32767.

Lê um byte não assinado do fluxo de bytes.

O valor retornado está na faixa de 0 a 255.

Lê um inteiro de 32 bits não assinado do fluxo de bytes.

O valor retornado está na faixa de 0 a 4294967295.

Lê um inteiro de 16 bits não assinado do fluxo de bytes.

O valor retornado está na faixa de 0 a 65535.

Lê uma string UTF-8 do fluxo de bytes. A string é assumida como prefixada com uma curta não assinada, indicativa do comprimento em bytes.

Elementos da API relacionados

Lê uma sequência de bytes UTF-8 especificados pelo parâmetro length do fluxo de bytes e retorna uma string.

Parâmetros

Fornece um método substituível para personalizar a codificação de JSON dos valores em um objeto ByteArray.

O método JSON.stringify() procura um método toJSON() em cada objeto que percorre. Se o método toJSON() for encontrado, JSON.stringify() o invocará para cada valor que encontrar, passando a chave pareada ao valor.

ByteArray fornece uma implementação padrão de toJSON (), que simplesmente retorna o nome da classe. Como o conteúdo de qualquer ByteArray requer interpretação, os clientes que desejam exportar objetos ByteArray para JSON devem fornecer a sua própria implementação. Isso pode ser feito redefinindo o método toJSON () no protótipo de classe.

O método toJSON() pode retornar um valor de qualquer tipo. Se retornar um objeto, stringify() aplicará funções recursivas a esse objeto. Se toJSON() retornar uma string, stringify() não usará funções recursivas e continuará sua travessia.

Parâmetros

Elementos da API relacionados

Converte a matriz de bytes em uma string. Se os dados na matriz começarem com a marca de ordem de bytes Unicode, o aplicativo respeitará essa marca na conversão para string. Se a System.useCodePage é configurada para true, na conversão o aplicativo tratará os dados da matriz como pertencentes à página de código do sistema atual.

Descompacta a matriz de bytes. Após a chamada, a propriedade length do ByteArray é configurada no novo comprimento. A propriedade posição é configurada para 0.

A matriz de bytes deve ter sido compactada usando o mesmo algoritmo da descompactação. Especifica um algoritmo de descompactação transmitindo um valor (definido na classe CompressionAlgorithm) como o parâmetro algorithm. Os algoritmos suportados incluem o seguinte:

O formato dos dados comprimidos zlib está descrito em http://www.ietf.org/rfc/rfc1950.txt_br.

O algoritmo de compactação deflate está descrito em http://www.ietf.org/rfc/rfc1951.txt_br.

O algoritmo de compactação lzma é descrito em http://www.7-zip.org/7z.html.

Para decodificar os dados compactados em um formato que usa o algoritmo de compactação deflate, tais como os dados no formato gzip ou zip, não funcionará chamar uncompress(CompressionAlgorithm.DEFLATE) em um ByteArray contendo os dados de formação da compactação. Primeiro, os metadados incluídos como parte do formato de dados compactados devem ser separados dos dados atualmente compactados. Para obter mais informações, consulte a descrição do métodocompress().

Parâmetros

Elementos da API relacionados

Grava um valor booliano. Um único byte é gravado de acordo com o parâmetro value, 1 se for true ou 0 se for false.

Parâmetros

Grava um byte no fluxo de bytes.

Os 8 bits baixos do parâmetro são usados. Os 24 bits altos são ignorados.

Parâmetros

Grava uma sequência de bytes de comprimento de uma matriz de bytes especificada, bytes, iniciando com os bytes de deslocamento (índice com base zero) no fluxo de bytes.

Se o parâmetro comprimento for omitido, é usado o comprimento padrão de 0; o método escreve todo o buffer com início no deslocamento. Se o parâmetro deslocamento também for omitido, é gravado todo o buffer.

Se offset ou length estiverem fora do limite, eles são fixados no início e no fim da matriz de bytes.

Parâmetros

Grava no fluxo de bytes um número de ponto flutuante de precisão dupla (64 bits) IEEE 754.

Parâmetros

Grava no fluxo de bytes um número de ponto flutuante de precisão única (32 bits) IEEE 754.

Parâmetros

Grava um inteiro assinado de 32 bits no fluxo de bytes.

Parâmetros

Grava uma string de vários bytes no fluxo de bytes, usando o conjunto de caracteres especificado.

Parâmetros

Grava um objeto na matriz de bytes no formato serializado AMF.

Parâmetros

Elementos da API relacionados

Grava um inteiro de 16 bits no fluxo de bytes. Os 16 bits baixos do parâmetro são usados. Os 16 bits altos são ignorados.

Parâmetros

Grava um inteiro não assinado de 32 bits no fluxo de bytes.

Parâmetros

Grava uma string UTF-8 no fluxo de bytes. O comprimento da string UTF-8 em bytes é gravado primeiro, como uma integral de 16 bits, seguido pelos bytes que representam os caracteres da string.

Parâmetros

Grava uma string UTF-8 no fluxo de bytes. Semelhante ao método writeUTF(), mas o writeUTFBytes() não coloca como prefixo da string uma palavra com o comprimento de 16 bits.

Parâmetros

1. Explique uma nova ocorrência de objeto byteArr do ByteArray.
2. Grave o valor equivalente em bytes do número booliano false e depois verifique o comprimento e confira-o.
3. Grave o ponto de flutuação de precisão dupla do equivalente do valor matemático de pi.
4. Confira todos os nove bytes gravados na matriz de bytes.

Observação: quando o trace() é chamado em um byte, ele imprime o equivalente decimal dos bytes armazenado na matriz de bytes.

Observe como um segmento de código é incluído no fim, para verificar erros de fim de arquivo, de modo que o fluxo de bytes não seja lido além de seu fim.

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