基于flash AS3.0 的BASE64编码与解码类

代码

// 调用代码：

import  com.dynamicflash.utils.Base64;      
  
// 编码和解码字符串     
var source:String  =   " Hello, world " ;      
var encoded:String  =  Base64.encode(source);      
trace(encoded);      
     
var decoded:String  =  Base64.decode(encoded);      
trace(decoded);     
  
// 编码和解码ByteArray     
var obj:Object =  {name: " Dynamic Flash " ,url: " http://dynamicflash.com " };   
var source:ByteArray  =   new  ByteArray();   
source.writeObject(obj);   
  
var encoded:String  =  Base64.encodeByteArray(source);   
trace(encoded);   
  
var decoded:ByteArray  =  Base64.decodeToByteArray(encoded);   
obj  =  decoded.readObject();   
trace(obj.name  +   " ( "   +  obj.url  +   " ) " );  


// Base64类代码：


package  com.dynamicflash.util{   
  
     import  flash.utils.ByteArray;   
       
     public   class  Base64 {   
           
         private   static   const  BASE64_CHARS:String  =   " ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/= " ;   
  
         public   static   const  version:String  =   " 1.0.0 " ;   
  
         public   static  function encode(data:String):String {   
             //  Convert string to ByteArray   
            var bytes:ByteArray  =   new  ByteArray();   
            bytes.writeUTFBytes(data);   
               
             //  Return encoded ByteArray   
             return  encodeByteArray(bytes);   
        }   
           
         public   static  function encodeByteArray(data:ByteArray):String {   
             //  Initialise output   
            var output:String  =   "" ;   
               
             //  Create data and output buffers   
            var dataBuffer:Array;   
            var outputBuffer:Array  =   new  Array( 4 );   
               
             //  Rewind ByteArray   
            data.position  =   0 ;   
               
             //  while there are still bytes to be processed   
             while  (data.bytesAvailable  >   0 ) {   
                 //  Create new data buffer and populate next 3 bytes from data   
                dataBuffer  =   new  Array();   
                 for  (var i:uint  =   0 ; i  <   3   &&  data.bytesAvailable  >   0 ; i ++ ) {   
                    dataBuffer[i]  =  data.readUnsignedByte();   
                }   
                   
                 //  Convert to data buffer Base64 character positions and    
                 //  store in output buffer   
                outputBuffer[ 0 ]  =  (dataBuffer[ 0 ]  &   0xfc )  >>   2 ;   
                outputBuffer[ 1 ]  =  ((dataBuffer[ 0 ]  &   0x03 )  <<   4 )  |  ((dataBuffer[ 1 ])  >>   4 );   
                outputBuffer[ 2 ]  =  ((dataBuffer[ 1 ]  &   0x0f )  <<   2 )  |  ((dataBuffer[ 2 ])  >>   6 );   
                outputBuffer[ 3 ]  =  dataBuffer[ 2 ]  &   0x3f ;   
                   
                 //  If data buffer was short (i.e not 3 characters) then set   
                 //  end character indexes in data buffer to index of '=' symbol.   
                 //  This is necessary because Base64 data is always a multiple of   
                 //  4 bytes and is basses with '=' symbols.   
                 for  (var j:uint  =  dataBuffer.length; j  <   3 ; j ++ ) {   
                    outputBuffer[j  +   1 ]  =   64 ;   
                }   
                   
                 //  Loop through output buffer and add Base64 characters to    
                 //  encoded data string for each character.   
                 for  (var k:uint  =   0 ; k  <  outputBuffer.length; k ++ ) {   
                    output  +=  BASE64_CHARS.charAt(outputBuffer[k]);   
                }   
            }   
               
             //  Return encoded data   
             return  output;   
        }   
           
         public   static  function decode(data:String):String {   
             //  Decode data to ByteArray   
            var bytes:ByteArray  =  decodeToByteArray(data);   
               
             //  Convert to string and return   
             return  bytes.readUTFBytes(bytes.length);   
        }   
           
         public   static  function decodeToByteArray(data:String):ByteArray {   
             //  Initialise output ByteArray for decoded data   
            var output:ByteArray  =   new  ByteArray();   
               
             //  Create data and output buffers   
            var dataBuffer:Array  =   new  Array( 4 );   
            var outputBuffer:Array  =   new  Array( 3 );   
  
             //  While there are data bytes left to be processed   
             for  (var i:uint  =   0 ; i  <  data.length; i  +=   4 ) {   
                 //  Populate data buffer with position of Base64 characters for   
                 //  next 4 bytes from encoded data   
                 for  (var j:uint  =   0 ; j  <   4   &&  i  +  j  <  data.length; j ++ ) {   
                    dataBuffer[j]  =  BASE64_CHARS.indexOf(data.charAt(i  +  j));   
                }   
                   
                 //  Decode data buffer back into bytes   
                outputBuffer[ 0 ]  =  (dataBuffer[ 0 ]  <<   2 )  +  ((dataBuffer[ 1 ]  &   0x30 )  >>   4 );   
                outputBuffer[ 1 ]  =  ((dataBuffer[ 1 ]  &   0x0f )  <<   4 )  +  ((dataBuffer[ 2 ]  &   0x3c )  >>   2 );           
                outputBuffer[ 2 ]  =  ((dataBuffer[ 2 ]  &   0x03 )  <<   6 )  +  dataBuffer[ 3 ];   
                   
                 //  Add all non-padded bytes in output buffer to decoded data   
                 for  (var k:uint  =   0 ; k  <  outputBuffer.length; k ++ ) {   
                     if  (dataBuffer[k + 1 ]  ==   64 )  break ;   
                    output.writeByte(outputBuffer[k]);   
                }   
            }   
               
             //  Rewind decoded data ByteArray   
            output.position  =   0 ;   
               
             //  Return decoded data   
             return  output;   
        }   
           
         public  function Base64() {   
             throw   new  Error( " Base64 class is static container only " );   
        }   
    }   
}